@wrongstack/core 0.7.5 → 0.7.6

package/dist/sdd/index.js

@@ -1,6 +1,7 @@
 import { randomBytes, randomUUID } from 'crypto';
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { EventEmitter } from 'events';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -2493,6 +2494,3623 @@ function createAutoExecutor(opts) {
   });
 }
 
-export { AISpecBuilder, AutoExecutor, DefaultTaskStore, SPEC_TEMPLATES, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, analyzeCriticalPath, createAutoExecutor, getTemplate, listTemplates, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, templateToMarkdown };
+// src/sdd/sdd-task-decomposer.ts
+var SddTaskDecomposer = class {
+  constructor(tracker, graph, opts = {}) {
+    this.tracker = tracker;
+    this.graph = graph;
+    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
+  }
+  tracker;
+  graph;
+  slots;
+  wave = 0;
+  // -------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------
+  /**
+   * Return the next batch of runnable tasks.
+   * Returns `allDone: true` when every node is completed.
+   * Returns `deadlocked: true` when no batch can be produced because
+   * all remaining tasks are blocked by failed nodes.
+   */
+  nextBatch() {
+    if (this.isDone()) {
+      return { tasks: [], wave: this.wave, allDone: true, deadlocked: false };
+    }
+    const pending = this.pendingReadyNodes();
+    if (pending.length === 0) {
+      const hasBlockedTasks = this.hasAnyBlockedTasks();
+      return { tasks: [], wave: this.wave, allDone: false, deadlocked: hasBlockedTasks };
+    }
+    const batch = pending.slice(0, this.slots);
+    return { tasks: batch, wave: this.wave, allDone: false, deadlocked: false };
+  }
+  /**
+   * Advance the wave counter after a batch completes.
+   * Call this once per `nextBatch()` result that was fan-out.
+   */
+  acknowledgeBatch(_completedTaskIds) {
+    this.wave++;
+  }
+  /**
+   * True when every node in the graph is completed.
+   * Use this to exit the fan-out loop after `isDone() || deadlocked`.
+   */
+  isDone() {
+    const progress = this.tracker.getProgress();
+    return progress.total > 0 && progress.completed === progress.total;
+  }
+  /**
+   * Total waves produced so far.
+   */
+  getWaveCount() {
+    return this.wave;
+  }
+  // -------------------------------------------------------------------
+  // Internal helpers
+  // -------------------------------------------------------------------
+  /**
+   * Return pending nodes whose blockers are all completed.
+   * Sorted by priority (critical first), then by creation time.
+   */
+  pendingReadyNodes() {
+    const allPending = this.tracker.getAllNodes({ status: ["pending"] });
+    const ready = [];
+    for (const node of allPending) {
+      if (this.tracker.canStart(node.id)) {
+        ready.push(node);
+      }
+    }
+    const priorityRank = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    };
+    ready.sort((a, b) => {
+      const pr = priorityRank[a.priority] - priorityRank[b.priority];
+      if (pr !== 0) return pr;
+      return a.createdAt - b.createdAt;
+    });
+    return ready;
+  }
+  /** True when at least one non-completed, non-failed task is blocked. */
+  hasAnyBlockedTasks() {
+    const nodes = this.tracker.getAllNodes({
+      status: ["pending", "in_progress", "blocked"]
+    });
+    return nodes.some((n) => n.status === "blocked");
+  }
+};
+
+// src/coordination/subagent-budget.ts
+var BudgetExceededError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(kind, limit, observed) {
+    super(`Budget exceeded: ${kind} (limit=${limit}, observed=${observed})`);
+    this.name = "BudgetExceededError";
+    this.kind = kind;
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
+var BudgetThresholdSignal = class extends Error {
+  kind;
+  limit;
+  used;
+  /** Resolves to 'extend' (with optional new limits) or 'stop' */
+  decision;
+  constructor(kind, limit, used, decision) {
+    super(`Budget soft limit: ${kind} (limit=${limit}, used=${used})`);
+    this.name = "BudgetThresholdSignal";
+    this.kind = kind;
+    this.limit = limit;
+    this.used = used;
+    this.decision = decision;
+  }
+};
+var SubagentBudget = class _SubagentBudget {
+  limits;
+  iterations = 0;
+  toolCalls = 0;
+  tokenInput = 0;
+  tokenOutput = 0;
+  costUsd = 0;
+  startTime = null;
+  _onThreshold;
+  /**
+   * Tracks which budget kinds currently have an extension request
+   * in flight. While a kind is here, further `checkLimit` calls for the
+   * same kind are no-ops — without this dedup, every `recordIteration`
+   * after the limit is reached spawns a fresh decision Promise (until
+   * the first one lands and patches limits), flooding the FleetBus
+   * with redundant threshold events. Cleared in `checkLimitAsync`'s
+   * `finally`.
+   */
+  pendingExtensions = /* @__PURE__ */ new Set();
+  /**
+   * Hard cap on how long `checkLimitAsync` waits for the coordinator to
+   * respond before defaulting to 'stop'. Without this fallback an absent
+   * or hung listener (Director not built / event filter detached mid-run)
+   * leaves the budget over-limit and never enforces anything, since
+   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
+   * Raised from 30s to 60s to give subagents more headroom before
+   * the threshold negotiation times out and triggers a hard stop.
+   */
+  static DECISION_TIMEOUT_MS = 6e4;
+  /**
+   * Injected by the runner when wiring the budget to its EventBus.
+   * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
+   */
+  _events;
+  /**
+   * Optional callback for soft-limit handling. When set, the budget will
+   * call this instead of throwing when a limit is first reached. The
+   * handler decides whether to throw, continue, or ask the coordinator.
+   */
+  get onThreshold() {
+    return this._onThreshold;
+  }
+  set onThreshold(fn) {
+    this._onThreshold = fn;
+  }
+  constructor(limits = {}) {
+    this.limits = { ...limits };
+  }
+  start() {
+    this.startTime = Date.now();
+  }
+  /** Returns true if we're within 10% of any limit — useful for pre-flight checks. */
+  isNearLimit() {
+    const { maxIterations, maxToolCalls, maxTokens, maxCostUsd } = this.limits;
+    if (maxIterations && this.iterations >= maxIterations * 0.9) return true;
+    if (maxToolCalls && this.toolCalls >= maxToolCalls * 0.9) return true;
+    if (maxTokens && this.tokenInput + this.tokenOutput >= maxTokens * 0.9) return true;
+    if (maxCostUsd && this.costUsd >= maxCostUsd * 0.9) return true;
+    return false;
+  }
+  /**
+   * Synchronous budget check — always throws synchronously so callers
+   * (especially test event handlers using `expect().toThrow()`) get an
+   * unhandled rejection when the budget is exceeded without a handler.
+   * When `onThreshold` IS configured, the actual async threshold-handling
+   * is dispatched as a fire-and-forget promise.
+   */
+  checkLimit(kind, used, limit) {
+    if (!this._onThreshold) {
+      throw new BudgetExceededError(kind, limit, used);
+    }
+    const bus = this._events;
+    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+      throw new BudgetExceededError(kind, limit, used);
+    }
+    if (this.pendingExtensions.has(kind)) return;
+    this.pendingExtensions.add(kind);
+    const decision = this.negotiateExtension(kind, used, limit);
+    throw new BudgetThresholdSignal(kind, limit, used, decision);
+  }
+  /**
+   * Drive the threshold handler to a decision. Resolves with `'stop'`
+   * (signal the runner to abort) or `{ extend: ... }` (limits already
+   * patched in-place; the runner should not abort). Always releases the
+   * `pendingExtensions` slot in `finally`.
+   *
+   * The 'continue' return from a sync handler is treated as
+   * `{ extend: {} }` — keep going without patching, next overrun will
+   * fire a fresh signal.
+   */
+  async negotiateExtension(kind, used, limit) {
+    try {
+      const result = this._onThreshold({
+        kind,
+        used,
+        limit,
+        // Inject a requestDecision helper the handler can call to emit the
+        // budget.threshold_reached event and wait for the coordinator's verdict.
+        // A hard fallback timer guarantees the promise eventually resolves
+        // even if no listener responds — without it, an absent/detached
+        // Director would leave the budget permanently in "asking" state.
+        requestDecision: () => {
+          const bus = this._events;
+          if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+            return Promise.resolve("stop");
+          }
+          return new Promise((resolve) => {
+            let resolved = false;
+            const respond = (d) => {
+              if (resolved) return;
+              resolved = true;
+              resolve(d);
+            };
+            const fallback = setTimeout(
+              () => respond("stop"),
+              _SubagentBudget.DECISION_TIMEOUT_MS
+            );
+            bus.emit("budget.threshold_reached", {
+              kind,
+              used,
+              limit,
+              timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+              extend: (extra) => {
+                clearTimeout(fallback);
+                respond({ extend: extra });
+              },
+              deny: () => {
+                clearTimeout(fallback);
+                respond("stop");
+              }
+            });
+          });
+        }
+      });
+      if (result === "throw") return "stop";
+      if (result === "continue") return { extend: {} };
+      const decision = await result;
+      if (decision === "stop") return "stop";
+      const ext = decision.extend;
+      if (ext.maxIterations !== void 0) {
+        this.limits.maxIterations = ext.maxIterations;
+      }
+      if (ext.maxToolCalls !== void 0) {
+        this.limits.maxToolCalls = ext.maxToolCalls;
+      }
+      if (ext.maxTokens !== void 0) {
+        this.limits.maxTokens = ext.maxTokens;
+      }
+      if (ext.maxCostUsd !== void 0) {
+        this.limits.maxCostUsd = ext.maxCostUsd;
+      }
+      if (ext.timeoutMs !== void 0) {
+        this.limits.timeoutMs = ext.timeoutMs;
+      }
+      return decision;
+    } finally {
+      this.pendingExtensions.delete(kind);
+    }
+  }
+  recordIteration() {
+    this.iterations++;
+    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
+      void this.checkLimit("iterations", this.iterations, this.limits.maxIterations);
+    }
+  }
+  recordToolCall() {
+    this.toolCalls++;
+    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
+      void this.checkLimit("tool_calls", this.toolCalls, this.limits.maxToolCalls);
+    }
+  }
+  recordUsage(usage, costUsd = 0) {
+    this.tokenInput += usage.input;
+    this.tokenOutput += usage.output;
+    this.costUsd += costUsd;
+    const totalTokens = this.tokenInput + this.tokenOutput;
+    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
+      void this.checkLimit("tokens", totalTokens, this.limits.maxTokens);
+    }
+    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
+      void this.checkLimit("cost", this.costUsd, this.limits.maxCostUsd);
+    }
+  }
+  /**
+   * Wall-clock budget check. Unlike other limits, timeout is treated as a
+   * warning-only event — it NEVER hard-stops the subagent. When the
+   * elapsed time exceeds timeoutMs, emits `budget.threshold_reached` with
+   * kind='timeout' so the Director can decide whether to extend or warn.
+   * Call this from the iteration loop so a hung tool gets a chance to
+   * negotiate more time before the coordinator's Promise.race kills it.
+   */
+  checkTimeout() {
+    if (this.startTime === null || this.limits.timeoutMs === void 0) return;
+    const elapsed = Date.now() - this.startTime;
+    if (elapsed > this.limits.timeoutMs) {
+      void this.checkLimit("timeout", elapsed, this.limits.timeoutMs);
+    }
+  }
+  /** Returns true if a timeout has occurred without throwing. Useful for races. */
+  isTimedOut() {
+    if (this.startTime === null || this.limits.timeoutMs === void 0) return false;
+    return Date.now() - this.startTime > this.limits.timeoutMs;
+  }
+  usage() {
+    return {
+      iterations: this.iterations,
+      toolCalls: this.toolCalls,
+      tokens: {
+        input: this.tokenInput,
+        output: this.tokenOutput,
+        total: this.tokenInput + this.tokenOutput
+      },
+      costUsd: this.costUsd,
+      elapsedMs: this.startTime === null ? 0 : Date.now() - this.startTime
+    };
+  }
+};
+
+// src/coordination/agent-subagent-runner.ts
+function makeAgentSubagentRunner(opts) {
+  const format = opts.formatTaskInput ?? defaultFormatTaskInput;
+  return async (task, ctx) => {
+    const factoryResult = await opts.factory(ctx.config);
+    const { agent, events } = factoryResult;
+    const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
+    const aborter = new AbortController();
+    ctx.budget._events = events;
+    ctx.budget.onThreshold = ({ requestDecision }) => requestDecision();
+    let budgetError = null;
+    const onBudgetError = (err) => {
+      if (err instanceof BudgetThresholdSignal) {
+        err.decision.then((decision) => {
+          if (decision === "stop") {
+            budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
+            aborter.abort();
+          }
+        }).catch(() => {
+          budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
+          aborter.abort();
+        });
+        return;
+      }
+      aborter.abort();
+      budgetError = err instanceof BudgetExceededError ? err : new BudgetExceededError(
+        "tool_calls",
+        0,
+        0
+      );
+      if (budgetError !== err && err instanceof Error) {
+        budgetError.message += ` (caused by: ${err.message})`;
+      }
+    };
+    let lastToolFailed = null;
+    const unsub = [];
+    unsub.push(
+      events.on("tool.executed", (e) => {
+        try {
+          ctx.budget.recordToolCall();
+        } catch (eb) {
+          onBudgetError(eb);
+        }
+        if (e.ok === false) {
+          lastToolFailed = e.name;
+        } else if (e.ok === true) {
+          lastToolFailed = null;
+        }
+      }),
+      events.on("provider.response", (e) => {
+        try {
+          ctx.budget.recordUsage(e.usage);
+        } catch (e2) {
+          void onBudgetError(e2);
+        }
+      }),
+      events.on("iteration.started", () => {
+        try {
+          ctx.budget.recordIteration();
+        } catch (e) {
+          void onBudgetError(e);
+        }
+        const u = ctx.budget.usage();
+        const since = u.iterations - lastSummaryAtIteration;
+        if (since >= SUMMARY_INTERVAL) {
+          lastSummaryAtIteration = u.iterations;
+          events.emit("subagent.iteration_summary", {
+            subagentId: ctx.subagentId,
+            iteration: u.iterations,
+            toolCalls: u.toolCalls,
+            costUsd: u.costUsd,
+            currentTool: currentToolName,
+            partialText: streamingTextAcc.trim() || void 0
+          });
+        }
+      }),
+      // D3: cooperative timeout enforcement DURING a long tool call.
+      // The iteration-loop checkTimeout() only fires between agent
+      // iterations — a single `bash sleep 3600` call would otherwise
+      // park inside one tool execution while the timeout silently
+      // passes, relying solely on the coordinator's hard Promise.race
+      // to interrupt. Tools that emit `tool.progress` (bash chunks,
+      // fetch byte progress, spawn-stream stdout) give us a heartbeat
+      // we can hang the check on. When the budget trips here:
+      //   1. onBudgetError sets budgetError + aborter.abort()
+      //   2. aborter signal propagates to agent.run → tool executor
+      //   3. tool's own signal listener kills the child process
+      // Cheap: O(1) per progress event, and the budget short-circuits
+      // when timeoutMs is unset (most subagents have one set anyway).
+      events.on("tool.progress", () => {
+        try {
+          ctx.budget.checkTimeout();
+        } catch (e) {
+          void onBudgetError(e);
+        }
+      })
+    );
+    let currentToolName;
+    let streamingTextAcc = "";
+    let lastSummaryAtIteration = 0;
+    const SUMMARY_INTERVAL = 25;
+    unsub.push(
+      events.on("tool.started", (e) => {
+        currentToolName = e.name;
+      }),
+      events.on("provider.text_delta", (e) => {
+        streamingTextAcc = (streamingTextAcc + e.text).slice(-200);
+      })
+    );
+    const onParentAbort = () => aborter.abort();
+    ctx.signal.addEventListener("abort", onParentAbort);
+    let result;
+    try {
+      result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
+    } finally {
+      detachFleet?.();
+      ctx.signal.removeEventListener("abort", onParentAbort);
+      for (const u of unsub) u();
+      if (factoryResult.dispose) {
+        try {
+          await factoryResult.dispose();
+        } catch {
+        }
+      }
+    }
+    if (budgetError) {
+      if ("decision" in budgetError) {
+        const decision = await budgetError.decision;
+        if (decision === "stop") {
+          budgetError = new BudgetExceededError(
+            budgetError.kind,
+            budgetError.limit,
+            budgetError.used
+          );
+        } else {
+          budgetError = null;
+        }
+      }
+      if (budgetError) throw budgetError;
+    }
+    if (result.status === "failed") {
+      throw result.error instanceof Error ? result.error : new Error(String(result.error ?? "agent failed"));
+    }
+    if (result.status === "aborted") {
+      throw new Error("agent aborted");
+    }
+    if (result.status === "max_iterations") {
+      throw new Error("agent exhausted iteration limit");
+    }
+    const usage = ctx.budget.usage();
+    const finalText = (result.finalText ?? "").trim();
+    if (finalText.length === 0 && usage.toolCalls === 0) {
+      throw new Error("empty response");
+    }
+    if (finalText.length === 0 && lastToolFailed !== null) {
+      throw new Error(`tool failed: ${lastToolFailed}`);
+    }
+    return {
+      result: result.finalText,
+      iterations: result.iterations,
+      toolCalls: usage.toolCalls
+    };
+  };
+}
+function defaultFormatTaskInput(task) {
+  return task.description ?? "";
+}
+
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR"};
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+
+// src/types/provider.ts
+var ProviderError = class extends WrongStackError {
+  status;
+  retryable;
+  providerId;
+  body;
+  constructor(message, status, retryable, providerId, opts = {}) {
+    super({
+      message,
+      code: providerStatusToCode(status, opts.body?.type),
+      subsystem: "provider",
+      severity: status >= 500 ? "error" : "warning",
+      recoverable: retryable,
+      context: { providerId, status },
+      cause: opts.cause
+    });
+    this.name = "ProviderError";
+    this.status = status;
+    this.retryable = retryable;
+    this.providerId = providerId;
+    this.body = opts.body;
+  }
+  /**
+   * Render a one-line, user-facing description. Designed for the CLI/TUI
+   * status line and the agent's retry warning. Avoids dumping raw JSON
+   * (which is what users see today when a 529 lands and the log message
+   * includes the full `{"type":"error",...}` body).
+   *
+   * Examples:
+   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
+   *   "openai rate limited (429): Retry after 12s"
+   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
+   *   "groq HTTP 500 (server error)"
+   */
+  describe() {
+    const kind = describeStatus(this.status, this.body?.type);
+    const head = `${this.providerId} ${kind}`;
+    const detail = this.body?.message?.trim();
+    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
+    if (detail && detail.length > 0) {
+      return `${head}: ${truncate2(detail, 240)}${reqId}`;
+    }
+    return `${head}${reqId}`;
+  }
+};
+function describeStatus(status, type) {
+  if (status === 0) return "network error";
+  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
+  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
+  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
+  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
+  if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
+  if (status === 408) return `timeout (${status})`;
+  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
+  if (type) return `${type} (${status})`;
+  return `HTTP ${status}`;
+}
+function truncate2(s, n) {
+  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
+}
+function providerStatusToCode(status, type) {
+  if (status === 0) return ERROR_CODES.PROVIDER_NETWORK_ERROR;
+  if (type === "rate_limit_error" || status === 429) return ERROR_CODES.PROVIDER_RATE_LIMITED;
+  if (type === "authentication_error" || status === 401) return ERROR_CODES.PROVIDER_AUTH_FAILED;
+  if (type === "overloaded_error" || status === 529) return ERROR_CODES.PROVIDER_OVERLOADED;
+  if (type === "invalid_request_error" || status === 400) return ERROR_CODES.PROVIDER_INVALID_REQUEST;
+  if (status === 408) return ERROR_CODES.PROVIDER_NETWORK_ERROR;
+  if (status >= 500) return ERROR_CODES.PROVIDER_SERVER_ERROR;
+  return ERROR_CODES.PROVIDER_INVALID_REQUEST;
+}
+
+// src/coordination/agents/types.ts
+var HOUR = 60 * 60 * 1e3;
+var LIGHT_BUDGET = {
+  timeoutMs: 3 * HOUR,
+  maxIterations: 3e3,
+  maxToolCalls: 8e3
+};
+var MEDIUM_BUDGET = {
+  timeoutMs: 5 * HOUR,
+  maxIterations: 5e3,
+  maxToolCalls: 14e3
+};
+var HEAVY_BUDGET = {
+  timeoutMs: 10 * HOUR,
+  maxIterations: 8e3,
+  maxToolCalls: 2e4
+};
+var TOOLS = {
+  /** Pure read/inspect — safe for analysis and review agents. */
+  read: ["read", "grep", "glob", "search", "tree"],
+  /** Read + structured inspection (logs, diffs, json, dependency audit). */
+  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit"],
+  /** Read + edit (no shell). For agents that write code/docs but don't run it. */
+  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch"],
+  /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
+  build: [
+    "read",
+    "grep",
+    "glob",
+    "search",
+    "tree",
+    "write",
+    "edit",
+    "replace",
+    "patch",
+    "bash",
+    "exec",
+    "lint",
+    "format",
+    "typecheck",
+    "test"
+  ],
+  /** Version control. */
+  vcs: ["read", "grep", "glob", "git", "diff"],
+  /** Dependency management + CVE audit. */
+  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json"],
+  /** Documentation authoring. */
+  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document"],
+  /** Web research. */
+  research: ["read", "grep", "glob", "search", "fetch"]
+};
+
+// src/coordination/agents/phase1-discovery.ts
+var DISCOVERY_AGENTS = [
+  {
+    config: {
+      id: "explore",
+      name: "Explore",
+      role: "explore",
+      tools: [...TOOLS.read],
+      prompt: `You are the Explore agent. Your job is to map an unfamiliar codebase
+and report its structure, entry points, and architecture \u2014 fast and read-only.
+
+Scope:
+- Locate entry points, build config, package boundaries, and dependency direction
+- Identify the dominant patterns (DI, event bus, layering) and where they live
+- Trace how a feature flows across files without modifying anything
+- Surface the 5-10 files most relevant to a given question
+
+Input format you accept:
+{ "task": "map | locate | trace", "question": "<what to find>", "scope": ["packages/core"] }
+
+Output: Markdown map with sections:
+- ## Overview (one paragraph: what this codebase is)
+- ## Key Files (table: file:line \u2014 role)
+- ## Flow (how the relevant feature moves across files)
+- ## Open Questions (anything that needs the user to clarify)
+
+Working rules:
+- Read-only \u2014 never edit, write, or run shell commands
+- Always cite file:line; never describe code you haven't read
+- Prefer breadth first (glob/tree), then depth (read) on the hottest files
+- If the question is ambiguous, state your interpretation before answering`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "discovery",
+      summary: "Maps unfamiliar codebases: entry points, structure, architecture, feature flow (read-only).",
+      keywords: [
+        "explore",
+        "map",
+        "understand",
+        "where is",
+        "how does",
+        "codebase",
+        "architecture",
+        "structure",
+        "overview",
+        "find file",
+        "entry point",
+        "orient"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "search",
+      name: "Search",
+      role: "search",
+      tools: [...TOOLS.read],
+      prompt: `You are the Search agent. Your job is semantic and lexical code search
+across one or many repositories: find every place a concept, symbol, or pattern
+appears and rank the hits by relevance.
+
+Scope:
+- Resolve a fuzzy concept ("where do we validate auth tokens?") to concrete sites
+- Find all definitions, references, and call sites of a symbol
+- Detect duplicated or near-duplicated logic across packages
+- Cross-repo search when multiple roots are provided
+
+Input format you accept:
+{ "task": "find | refs | dupes", "query": "<concept or symbol>", "roots": ["."], "kind": "definition | usage | all" }
+
+Output: Markdown result set:
+- ## Best Matches (ranked: file:line \u2014 why it matches)
+- ## Related (lower-confidence hits)
+- ## Not Found (terms searched with zero hits, so the caller can rephrase)
+
+Working rules:
+- Read-only; rely on grep/glob/search, never edit
+- Always rank by relevance and explain the ranking in one clause
+- Distinguish definition sites from usage sites explicitly
+- Report search terms that returned nothing so the caller can refine`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "discovery",
+      summary: "Semantic + lexical code search across repos; finds definitions, references, duplicates, ranks by relevance.",
+      keywords: [
+        "search",
+        "find all",
+        "references",
+        "usages",
+        "call sites",
+        "grep",
+        "locate symbol",
+        "duplicate",
+        "where used",
+        "occurrences",
+        "cross-repo"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "research",
+      name: "Research",
+      role: "research",
+      tools: [...TOOLS.research],
+      prompt: `You are the Research agent (formerly Scientist). Your job is technical
+research and feasibility analysis: investigate libraries, approaches, and
+tradeoffs, then recommend a path with evidence.
+
+Scope:
+- Compare libraries/frameworks/approaches for a stated requirement
+- Assess feasibility and risk of a proposed technique
+- Summarize current best practice from documentation and the codebase
+- Produce a recommendation with explicit tradeoffs, not just a list
+
+Input format you accept:
+{ "task": "compare | feasibility | bestpractice", "topic": "<technology or approach>", "constraints": ["runtime: node>=22", "no new deps"] }
+
+Output: Markdown research brief:
+- ## Question (restated, with constraints)
+- ## Options (table: option \u2014 pros \u2014 cons \u2014 fit)
+- ## Recommendation (one choice + why + the main tradeoff)
+- ## Evidence (links/citations and file:line where the codebase already hints)
+
+Working rules:
+- Ground claims in fetched docs or actual code \u2014 flag anything you're unsure of
+- Always give a recommendation, never just "it depends"
+- State the single biggest risk of the recommended path
+- Respect stated constraints; if an option violates one, say so explicitly`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "discovery",
+      summary: "Technical research and feasibility: compares libraries/approaches, recommends a path with evidence and tradeoffs.",
+      keywords: [
+        "research",
+        "feasibility",
+        "compare libraries",
+        "which library",
+        "best practice",
+        "tradeoff",
+        "investigate",
+        "evaluate approach",
+        "should we use",
+        "pros and cons"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase2-planning.ts
+var PLAN_TOOLS = [...TOOLS.read, "plan", "todo"];
+var PLANNING_AGENTS = [
+  {
+    config: {
+      id: "analyst",
+      name: "Analyst",
+      role: "analyst",
+      tools: [...PLAN_TOOLS],
+      prompt: `You are the Analyst agent. Your job is requirement analysis: turn a
+vague request into a precise, testable specification before anyone writes code.
+
+Scope:
+- Extract explicit and implicit requirements from a request
+- Identify ambiguities, edge cases, and missing acceptance criteria
+- Separate must-have from nice-to-have; flag scope creep
+- Produce acceptance criteria that a TestAgent could turn into tests
+
+Input format you accept:
+{ "task": "analyze | clarify | criteria", "request": "<feature description>", "context": "<domain notes>" }
+
+Output: Markdown requirement spec:
+- ## Goal (one sentence)
+- ## Requirements (MUST / SHOULD / WON'T)
+- ## Acceptance Criteria (Given/When/Then, testable)
+- ## Open Questions (ambiguities that block implementation)
+- ## Out of Scope (explicit non-goals)
+
+Working rules:
+- Never invent requirements the user didn't imply \u2014 list them as open questions
+- Every acceptance criterion must be observable/testable
+- Flag the single biggest unknown that could change the design
+- Read code to ground "as-is" behavior before specifying "to-be"`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Requirement analysis: turns vague requests into testable specs with acceptance criteria and open questions.",
+      keywords: [
+        "requirements",
+        "analyze requirement",
+        "acceptance criteria",
+        "spec",
+        "specification",
+        "clarify",
+        "scope",
+        "user story",
+        "what should it do"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "planner",
+      name: "Planner",
+      role: "planner",
+      tools: [...PLAN_TOOLS],
+      prompt: `You are the Planner agent. Your job is execution planning: break an
+approved goal into an ordered, dependency-aware sequence of concrete steps.
+
+Scope:
+- Decompose a goal into tasks small enough to verify independently
+- Order tasks by dependency; mark which can run in parallel
+- Estimate relative effort and call out risky steps
+- Define checkpoints where progress should be validated
+
+Input format you accept:
+{ "task": "plan | sequence | estimate", "goal": "<what to build>", "constraints": ["one PR per concern"] }
+
+Output: Markdown execution plan:
+- ## Plan Summary (one paragraph)
+- ## Steps (table: # \u2014 task \u2014 depends-on \u2014 parallel? \u2014 risk)
+- ## Critical Path (the longest dependency chain)
+- ## Checkpoints (where to stop and verify)
+
+Working rules:
+- One step = one concern that can be verified on its own
+- Make dependencies explicit; never leave ordering implicit
+- Mark parallelizable steps so the coordinator can dispatch them concurrently
+- Keep the plan actionable \u2014 no step should be "figure out X"`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Execution planning: decomposes a goal into ordered, dependency-aware, parallelizable steps with checkpoints.",
+      keywords: [
+        "plan",
+        "execution plan",
+        "break down",
+        "decompose",
+        "steps",
+        "sequence",
+        "roadmap",
+        "task breakdown",
+        "order of work",
+        "milestones"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "architect",
+      name: "Architect",
+      role: "architect",
+      tools: [...PLAN_TOOLS],
+      prompt: `You are the Architect agent. Your job is system architecture: design
+module boundaries, data flow, and interfaces that satisfy the requirements
+without over-engineering.
+
+Scope:
+- Define components, their responsibilities, and the contracts between them
+- Choose data flow and state ownership; avoid hidden coupling
+- Respect the codebase's existing dependency direction and patterns
+- Document the key decisions and the alternatives rejected
+
+Input format you accept:
+{ "task": "design | interfaces | decision", "requirement": "<what to support>", "constraints": ["no reverse deps", "keep kernel <600 LOC"] }
+
+Output: Markdown architecture doc:
+- ## Context (forces and constraints)
+- ## Components (each: responsibility + dependencies)
+- ## Interfaces (the key type signatures / contracts)
+- ## Data Flow (ASCII diagram)
+- ## Decisions (decision \u2014 rationale \u2014 rejected alternative)
+
+Working rules:
+- Follow the repo's existing layering; never introduce a reverse dependency
+- Prefer the simplest design that meets the requirement \u2014 no speculative generality
+- Make every interface explicit as a type signature
+- Record why each non-obvious decision was made`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "System architecture: designs module boundaries, interfaces, data flow, and records key decisions.",
+      keywords: [
+        "architecture",
+        "design system",
+        "module boundaries",
+        "interfaces",
+        "data flow",
+        "component design",
+        "system design",
+        "decision record",
+        "adr",
+        "structure the"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "critic",
+      name: "Critic",
+      role: "critic",
+      tools: [...TOOLS.read],
+      prompt: `You are the Critic agent. Your job is adversarial review of a plan or
+design before implementation: find the flaws, gaps, and risks the authors
+missed \u2014 but stay constructive.
+
+Scope:
+- Stress-test a plan/design against edge cases and failure modes
+- Find missing steps, unhandled errors, and unstated assumptions
+- Challenge scope, complexity, and sequencing decisions
+- Rank concerns by severity and propose concrete fixes
+
+Input format you accept:
+{ "task": "review | redteam | risks", "artifact": "<plan or design text or file>", "focus": "completeness | risk | simplicity" }
+
+Output: Markdown critique:
+- ## Verdict (ship / revise / reconsider \u2014 one line)
+- ## Blocking Issues (must fix before proceeding)
+- ## Concerns (should address)
+- ## Nitpicks (optional)
+Each item: problem \u2192 why it matters \u2192 suggested fix
+
+Working rules:
+- Be specific: cite the exact step/section you're criticizing
+- Every criticism must come with a concrete suggested fix
+- Separate blocking issues from preferences \u2014 don't inflate severity
+- If the plan is sound, say so plainly; don't manufacture problems`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Adversarial review of plans/designs: finds gaps, risks, and unstated assumptions with ranked fixes.",
+      keywords: [
+        "critique",
+        "review plan",
+        "review design",
+        "red team",
+        "poke holes",
+        "risks",
+        "what could go wrong",
+        "second opinion",
+        "challenge",
+        "flaws"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase3-build.ts
+var BUILD_AGENTS = [
+  {
+    config: {
+      id: "executor",
+      name: "Executor",
+      role: "executor",
+      tools: [...TOOLS.build],
+      prompt: `You are the Executor agent. Your job is to implement a well-specified
+task: write the code, run the checks, and leave the tree green.
+
+Scope:
+- Implement features/changes against a clear spec or plan step
+- Follow existing patterns, naming, and dependency direction
+- Run lint/typecheck/test after changes and fix what you broke
+- Make the smallest change that satisfies the task
+
+Input format you accept:
+{ "task": "implement | apply | fix", "spec": "<what to build>", "files": ["src/x.ts"], "verify": "typecheck | test | both" }
+
+Output: Markdown change report:
+- ## Summary (what changed and why)
+- ## Files Changed (file:line \u2014 change)
+- ## Verification (commands run + results)
+- ## Follow-ups (anything deliberately left out)
+
+Working rules:
+- Don't add features, refactors, or abstractions beyond the task
+- Match the surrounding code style; don't reformat unrelated lines
+- Always run the relevant checks before reporting done
+- If the spec is ambiguous, implement the most conservative interpretation and note it`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Implements well-specified tasks: writes code, runs checks, leaves the tree green.",
+      keywords: [
+        "implement",
+        "build",
+        "write code",
+        "add feature",
+        "create",
+        "code up",
+        "develop",
+        "apply change",
+        "make it work"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "refactor",
+      name: "Refactor",
+      role: "refactor",
+      tools: [...TOOLS.build],
+      prompt: `You are the Refactor agent. Your job is structural refactoring: change
+the shape of the code (extract, split, move, rename, decouple) WITHOUT changing
+its observable behavior.
+
+Scope:
+- Extract modules/functions, split god objects, break circular dependencies
+- Move responsibilities to the right layer; reduce coupling
+- Rename for clarity across all call sites
+- Keep behavior identical \u2014 tests must pass unchanged
+
+Input format you accept:
+{ "task": "extract | split | move | rename | decouple", "target": "src/big.ts", "goal": "<structural outcome>" }
+
+Output: Markdown refactor report:
+- ## Goal (structural change made)
+- ## Moves (table: from \u2192 to)
+- ## Behavior Preservation (how you verified nothing changed)
+- ## Risk Notes (anything a reviewer should double-check)
+
+Working rules:
+- Behavior must not change \u2014 run the existing tests before and after
+- Refactor in small, independently-valid steps; keep it green between steps
+- Never mix a refactor with a behavior change in the same pass
+- Distinct from Simplifier: you change structure, not just reduce complexity`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Structural refactoring: extract/split/move/rename/decouple without changing observable behavior.",
+      keywords: [
+        "refactor",
+        "restructure",
+        "extract",
+        "split module",
+        "decouple",
+        "rename",
+        "move code",
+        "break dependency",
+        "reorganize"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "simplifier",
+      name: "Simplifier",
+      role: "simplifier",
+      tools: [...TOOLS.build],
+      prompt: `You are the Simplifier agent. Your job is to reduce complexity: delete
+dead code, collapse needless abstractions, and make the code shorter and
+clearer \u2014 without changing behavior.
+
+Scope:
+- Remove dead code, unused exports, and unreachable branches
+- Collapse premature abstractions and over-engineering
+- Simplify control flow and reduce nesting
+- Inline single-use indirection; delete defensive code for impossible states
+
+Input format you accept:
+{ "task": "simplify | deadcode | denest", "target": "src/x.ts", "aggressiveness": "conservative | normal | aggressive" }
+
+Output: Markdown simplification report:
+- ## Before/After (LOC, cyclomatic complexity if measurable)
+- ## Removed (dead code / abstractions deleted)
+- ## Simplified (control flow / nesting changes)
+- ## Verification (tests pass)
+
+Working rules:
+- Behavior must not change \u2014 verify with the existing test suite
+- Don't delete code you can't prove is unused; flag uncertain cases instead
+- Distinct from Refactor: you reduce, not restructure
+- Prefer deleting over rewriting; the best change is often removal`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Reduces complexity: deletes dead code, collapses needless abstractions, shortens and clarifies code.",
+      keywords: [
+        "simplify",
+        "dead code",
+        "remove unused",
+        "reduce complexity",
+        "clean up",
+        "denest",
+        "shorten",
+        "over-engineered",
+        "too complex"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "migration",
+      name: "Migration",
+      role: "migration",
+      tools: [...TOOLS.build, "install", "outdated"],
+      prompt: `You are the Migration agent. Your job is framework/language/version
+upgrades: move code from an old API or version to a new one mechanically and
+safely.
+
+Scope:
+- Upgrade a dependency across a breaking major version
+- Migrate between frameworks or APIs (e.g. CommonJS\u2192ESM, v1\u2192v2 SDK)
+- Apply codemods consistently across all call sites
+- Stage the migration so the build stays green between steps
+
+Input format you accept:
+{ "task": "upgrade | migrate | codemod", "from": "<old>", "to": "<new>", "scope": ["src"] }
+
+Output: Markdown migration report:
+- ## Migration (from \u2192 to)
+- ## Changes Applied (pattern \u2192 replacement, count)
+- ## Manual Cases (sites that needed human judgment)
+- ## Verification (build/test status per stage)
+
+Working rules:
+- Apply the change uniformly \u2014 leave no half-migrated call sites
+- Stage large migrations; verify the build after each stage
+- Read the target version's migration guide before touching code
+- Flag every site where the mechanical transform was unsafe`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Framework/language/version upgrades: applies codemods across call sites, staged and verified.",
+      keywords: [
+        "migrate",
+        "upgrade",
+        "codemod",
+        "breaking change",
+        "major version",
+        "port to",
+        "convert to",
+        "esm",
+        "modernize"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "vision",
+      name: "Vision",
+      role: "vision",
+      tools: [...TOOLS.write, "fetch"],
+      prompt: `You are the Vision agent. Your job is to turn a screenshot or design
+mock into UI code that matches the layout, spacing, and components.
+
+Scope:
+- Read a provided image (screenshot/mockup) and infer the component tree
+- Generate UI code in the project's framework matching layout and styling
+- Reuse existing components and design tokens where they exist
+- Produce responsive, accessible markup, not pixel-frozen hacks
+
+Input format you accept:
+{ "task": "implement | clone | extract", "image": "<path>", "framework": "react | vue | html", "match": "structure | pixel" }
+
+Output: Markdown report + code:
+- ## Interpretation (what the image shows: layout regions)
+- ## Components (mapped to existing or new)
+- ## Code (the generated files)
+- ## Gaps (anything the image was ambiguous about)
+
+Working rules:
+- Read the actual image before generating \u2014 never guess at a layout
+- Reuse existing components/tokens; don't reinvent the design system
+- Generate semantic, accessible markup (labels, roles, alt text)
+- Flag ambiguous regions rather than inventing details`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Screenshot/mockup \u2192 UI code: infers component tree and generates matching, accessible markup.",
+      keywords: [
+        "screenshot",
+        "mockup",
+        "design to code",
+        "image to ui",
+        "figma",
+        "replicate this ui",
+        "from this picture",
+        "vision",
+        "clone ui"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "debugger",
+      name: "Debugger",
+      role: "debugger",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Debugger agent. Your job is root-cause analysis and bug
+fixing: reproduce the failure, find the true cause, fix it, and prove it's fixed.
+
+Scope:
+- Reproduce a reported bug deterministically
+- Bisect to the root cause (not just the symptom)
+- Apply the minimal fix and add/adjust a regression test
+- Verify the fix and confirm no new breakage
+
+Input format you accept:
+{ "task": "diagnose | fix | repro", "symptom": "<observed failure>", "repro": "<steps or failing test>" }
+
+Output: Markdown debug report:
+- ## Symptom (observed vs expected)
+- ## Root Cause (file:line \u2014 the real cause, not the symptom)
+- ## Fix (what changed and why it addresses the cause)
+- ## Proof (failing\u2192passing test, commands run)
+
+Working rules:
+- Find the root cause before fixing \u2014 never patch the symptom
+- Add a regression test that fails before the fix and passes after
+- Make the smallest fix that addresses the cause
+- If you can't reproduce, say so and report what you'd need`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Root-cause bug fixing: reproduces, bisects to the true cause, applies a minimal fix with a regression test.",
+      keywords: [
+        "bug",
+        "fix",
+        "debug",
+        "broken",
+        "error",
+        "crash",
+        "root cause",
+        "not working",
+        "failing",
+        "reproduce",
+        "why does"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "tracer",
+      name: "Tracer",
+      role: "tracer",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Tracer agent. Your job is runtime tracing: instrument and
+run the code to observe actual execution \u2014 call order, values, timing \u2014 when
+static reading isn't enough.
+
+Scope:
+- Add temporary, targeted instrumentation (logs/timers) to observe behavior
+- Run the code path and capture the real execution trace
+- Map observed runtime behavior back to source locations
+- Remove all instrumentation when done (leave no trace behind)
+
+Input format you accept:
+{ "task": "trace | profile | observe", "entry": "<how to run>", "watch": ["variable or function names"] }
+
+Output: Markdown trace report:
+- ## Execution Path (ordered call sequence with file:line)
+- ## Observed Values (key variables at key points)
+- ## Timing (where time was spent, if profiling)
+- ## Findings (what the runtime revealed vs the static read)
+
+Working rules:
+- Instrument minimally and surgically; never spam logs everywhere
+- ALWAYS remove your instrumentation before finishing
+- Distinguish observed facts from inference
+- Prefer the existing logging/tracing facilities over ad-hoc prints`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Runtime tracing: instruments and runs code to observe call order, values, and timing, then cleans up.",
+      keywords: [
+        "trace",
+        "runtime",
+        "instrument",
+        "execution path",
+        "what happens at runtime",
+        "call order",
+        "profile execution",
+        "observe behavior",
+        "stack trace"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase4-verify.ts
+var VERIFY_AGENTS = [
+  {
+    config: {
+      id: "test",
+      name: "Test",
+      role: "test",
+      tools: [...TOOLS.build],
+      prompt: `You are the Test agent. Your job is unit and integration testing: write
+meaningful tests, run them, and report real coverage of behavior \u2014 not vanity
+metrics.
+
+Scope:
+- Write unit tests for pure logic and integration tests for wired components
+- Cover the golden path AND the edge/error cases that matter
+- Use the project's test framework, fixtures, and conventions
+- Run the suite and report pass/fail with actual numbers
+
+Input format you accept:
+{ "task": "unit | integration | coverage", "target": "src/x.ts", "level": "happy | edge | full" }
+
+Output: Markdown test report:
+- ## Tests Added (file \u2014 what each verifies)
+- ## Results (pass/fail, duration)
+- ## Coverage Gaps (untested behavior worth covering)
+- ## Flakiness Notes (anything nondeterministic)
+
+Working rules:
+- Test behavior, not implementation details
+- Prefer real dependencies over mocks for integration tests unless told otherwise
+- Every test must be able to actually fail \u2014 no tautologies
+- Run the tests you write; never report tests you didn't execute`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Unit + integration testing: writes meaningful tests covering golden path and edge cases, runs the suite.",
+      keywords: [
+        "test",
+        "unit test",
+        "integration test",
+        "write tests",
+        "coverage",
+        "test suite",
+        "vitest",
+        "jest",
+        "add tests",
+        "spec"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "e2e",
+      name: "E2E",
+      role: "e2e",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: `You are the E2E agent. Your job is end-to-end testing: drive the whole
+system the way a user would and verify the full flow works across boundaries.
+
+Scope:
+- Author end-to-end scenarios that exercise real user journeys
+- Drive UI/CLI/API across process and network boundaries
+- Set up and tear down realistic test state
+- Capture failures with enough detail to reproduce (screenshots, logs)
+
+Input format you accept:
+{ "task": "scenario | smoke | journey", "flow": "<user journey>", "surface": "ui | cli | api" }
+
+Output: Markdown e2e report:
+- ## Scenarios (each: steps \u2192 expected \u2192 actual)
+- ## Results (pass/fail per scenario)
+- ## Failures (repro steps + captured evidence)
+- ## Environment Notes (setup assumptions)
+
+Working rules:
+- Test the real flow end to end; don't stub the thing under test
+- Make scenarios deterministic \u2014 control time, randomness, and external state
+- On failure, capture artifacts (logs/screenshots) for reproduction
+- Keep scenarios independent so one failure doesn't cascade`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "End-to-end testing: drives full user journeys across UI/CLI/API boundaries with reproducible failures.",
+      keywords: [
+        "e2e",
+        "end to end",
+        "end-to-end",
+        "user journey",
+        "smoke test",
+        "playwright",
+        "cypress",
+        "full flow",
+        "browser test",
+        "acceptance test"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "performance",
+      name: "Performance",
+      role: "performance",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Performance agent. Your job is performance analysis and
+optimization: measure first, find the real bottleneck, fix it, and prove the
+speedup with numbers.
+
+Scope:
+- Benchmark and profile to locate the actual hot path
+- Identify algorithmic, I/O, allocation, and concurrency bottlenecks
+- Apply targeted optimizations without harming readability
+- Measure before/after and report the delta honestly
+
+Input format you accept:
+{ "task": "profile | optimize | benchmark", "target": "<operation>", "metric": "latency | throughput | memory" }
+
+Output: Markdown performance report:
+- ## Baseline (measured numbers)
+- ## Bottleneck (file:line \u2014 the real cost center)
+- ## Optimization (what changed)
+- ## Result (before \u2192 after, with method)
+
+Working rules:
+- Measure before optimizing \u2014 never guess at the bottleneck
+- Optimize the hot path only; don't micro-optimize cold code
+- Report honest deltas, including cases where the change didn't help
+- Don't sacrifice correctness or clarity for marginal gains`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Performance analysis: benchmarks/profiles to find the real bottleneck, optimizes, proves speedup with numbers.",
+      keywords: [
+        "performance",
+        "slow",
+        "optimize",
+        "bottleneck",
+        "profile",
+        "benchmark",
+        "latency",
+        "throughput",
+        "memory",
+        "speed up",
+        "too slow"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "chaos",
+      name: "Chaos",
+      role: "chaos",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Chaos agent. Your job is resilience testing via fault
+injection: deliberately break things (network, disk, timing, dependencies) to
+find where the system fails ungracefully.
+
+Scope:
+- Inject faults: timeouts, errors, partial failures, resource exhaustion
+- Test retry, backoff, circuit-breaking, and graceful-degradation paths
+- Find unhandled rejections, missing cleanup, and cascading failures
+- Verify the system fails safe and recovers
+
+Input format you accept:
+{ "task": "inject | resilience | failmode", "target": "<component>", "faults": ["timeout", "5xx", "disk full"] }
+
+Output: Markdown chaos report:
+- ## Faults Injected (what + where)
+- ## Behavior Observed (did it fail safe? recover?)
+- ## Weaknesses (unhandled cases \u2014 severity ranked)
+- ## Recommendations (how to harden)
+
+Working rules:
+- Only inject faults in test/dev environments \u2014 never against production
+- Always restore the system to a clean state after each experiment
+- Distinguish "fails safe" from "fails silently" \u2014 the latter is the real bug
+- Rank findings by blast radius, not just likelihood`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Resilience testing via fault injection: breaks network/disk/timing to find ungraceful failures and recovery gaps.",
+      keywords: [
+        "chaos",
+        "resilience",
+        "fault injection",
+        "failure mode",
+        "fail safe",
+        "retry",
+        "circuit breaker",
+        "graceful degradation",
+        "inject failure",
+        "robustness"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase5-review.ts
+var REVIEW_AGENTS = [
+  {
+    config: {
+      id: "code-reviewer",
+      name: "Code Reviewer",
+      role: "code-reviewer",
+      tools: [...TOOLS.inspect, "git"],
+      prompt: `You are the Code Reviewer agent. Your job is correctness-first code
+review of a diff or change set: find real bugs and risks, then style \u2014 and be
+specific.
+
+Scope:
+- Review a diff for correctness bugs, edge cases, and regressions first
+- Check error handling, resource cleanup, and concurrency hazards
+- Assess readability, naming, and adherence to project conventions
+- Separate must-fix from nice-to-have
+
+Input format you accept:
+{ "task": "review | diff | pr", "target": "<branch/diff/files>", "depth": "quick | normal | thorough" }
+
+Output: Markdown review:
+- ## Verdict (approve / request changes \u2014 one line)
+- ## Must Fix (correctness bugs, with file:line + fix)
+- ## Should Fix (risk/maintainability)
+- ## Nits (optional style)
+
+Working rules:
+- Read-only \u2014 review and recommend, never edit
+- Lead with correctness; don't bury a real bug under style nits
+- Every finding needs file:line and a concrete suggestion
+- Cite the project convention you're invoking, don't assert taste`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "Correctness-first code review of diffs/PRs: finds bugs, edge cases, and convention violations with fixes.",
+      keywords: [
+        "review",
+        "code review",
+        "review pr",
+        "review diff",
+        "look over",
+        "feedback on code",
+        "quality",
+        "is this correct",
+        "check my code"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "security-reviewer",
+      name: "Security Reviewer",
+      role: "security-reviewer",
+      tools: [...TOOLS.inspect, "git"],
+      prompt: `You are the Security Reviewer agent. Your job is security review of code
+and configuration: find vulnerabilities, unsafe patterns, and exposure, mapped
+to severity and remediation.
+
+Scope:
+- Detect injection (SQL/command/XSS), SSRF, path traversal, deserialization
+- Find auth/authorization gaps, secret exposure, and unsafe crypto
+- Review input validation at trust boundaries
+- Map findings to OWASP categories with severity and fixes
+
+Input format you accept:
+{ "task": "review | audit | threats", "target": "<files/diff>", "focus": "injection | authz | secrets | all" }
+
+Output: Markdown security review:
+- ## Critical / High / Medium / Low (each: file:line \u2014 issue \u2014 impact \u2014 fix)
+- ## OWASP Mapping (category \u2192 findings)
+- ## Remediation Checklist
+
+Working rules:
+- Read-only; report and recommend, never patch silently
+- Validate before flagging \u2014 note confidence to limit false positives
+- Always give the concrete remediation, not just the risk
+- Only assess defensive/authorized review; refuse to weaponize findings`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "Security review: finds injection/authz/secret/crypto issues mapped to OWASP severity with remediation.",
+      keywords: [
+        "security review",
+        "security",
+        "vulnerability",
+        "vulnerabilities",
+        "owasp",
+        "injection",
+        "sql injection",
+        "xss",
+        "ssrf",
+        "authz",
+        "secrets",
+        "security audit",
+        "threat",
+        "unsafe"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "accessibility",
+      name: "Accessibility",
+      role: "accessibility",
+      tools: [...TOOLS.read],
+      prompt: `You are the Accessibility agent. Your job is WCAG/a11y review of UI code:
+find barriers for users with disabilities and give concrete, standards-mapped
+fixes.
+
+Scope:
+- Check semantic markup, ARIA roles/labels, and keyboard operability
+- Verify focus management, contrast, and text alternatives
+- Review forms (labels, errors) and dynamic content (live regions)
+- Map each finding to a WCAG success criterion
+
+Input format you accept:
+{ "task": "audit | review | fix-plan", "target": "<component/files>", "level": "A | AA | AAA" }
+
+Output: Markdown a11y report:
+- ## Violations (file:line \u2014 WCAG criterion \u2014 issue \u2014 fix)
+- ## Warnings (likely issues needing manual check)
+- ## Keyboard/Focus Notes
+- ## Summary (by WCAG level)
+
+Working rules:
+- Read-only review; map every finding to a specific WCAG criterion
+- Distinguish automatable checks from those needing manual/AT testing
+- Prefer semantic HTML fixes over ARIA band-aids
+- Give the minimal correct fix, not a rewrite`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "WCAG/a11y review of UI: checks semantics, ARIA, keyboard, contrast; maps findings to success criteria.",
+      keywords: [
+        "accessibility",
+        "a11y",
+        "wcag",
+        "aria",
+        "screen reader",
+        "keyboard navigation",
+        "contrast",
+        "disabled users",
+        "accessible"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "compliance",
+      name: "Compliance",
+      role: "compliance",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Compliance agent. Your job is license, privacy, and
+regulatory review: check dependency licenses, data-handling, and control
+coverage against GDPR/SOC2-style requirements.
+
+Scope:
+- Audit dependency licenses for compatibility and obligations
+- Review handling of personal data (collection, storage, retention, deletion)
+- Check for required controls: audit logging, access control, encryption-at-rest
+- Map findings to the relevant regime (GDPR, SOC2, license terms)
+
+Input format you accept:
+{ "task": "licenses | privacy | controls", "scope": ["package.json", "src"], "regime": "gdpr | soc2 | licenses" }
+
+Output: Markdown compliance report:
+- ## License Audit (dependency \u2192 license \u2192 compatible?)
+- ## Data Handling (PII flows + gaps)
+- ## Control Coverage (required \u2192 present? \u2192 evidence)
+- ## Action Items (ranked by regulatory risk)
+
+Working rules:
+- Read-only; you flag obligations, you are not legal advice \u2014 say so
+- Cite the specific clause/criterion behind each finding
+- Distinguish a hard violation from a missing-evidence gap
+- Note where a human/legal review is required before action`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "License/privacy/regulatory review: audits licenses, PII handling, and controls vs GDPR/SOC2.",
+      keywords: [
+        "compliance",
+        "license",
+        "gdpr",
+        "soc2",
+        "privacy",
+        "pii",
+        "data retention",
+        "regulatory",
+        "audit log",
+        "legal review"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase6-domain.ts
+var DOMAIN_AGENTS = [
+  {
+    config: {
+      id: "database",
+      name: "Database",
+      role: "database",
+      tools: [...TOOLS.build],
+      prompt: `You are the Database agent. Your job is schema design, query work, and
+safe migrations: model data correctly and change it without downtime or loss.
+
+Scope:
+- Design normalized schemas, indexes, and constraints for the access patterns
+- Write and optimize queries; diagnose slow queries with the plan
+- Author migrations that are reversible and safe under concurrent writes
+- Plan backfills and data transformations
+
+Input format you accept:
+{ "task": "schema | query | migration | optimize", "target": "<table/query>", "engine": "postgres | mysql | sqlite" }
+
+Output: Markdown database report:
+- ## Schema / DDL (with rationale for keys and indexes)
+- ## Migration Plan (forward + rollback, locking notes)
+- ## Query Work (before/after + EXPLAIN)
+- ## Risks (data loss / lock contention)
+
+Working rules:
+- Every migration must have a rollback and note its locking behavior
+- Adding NOT NULL / unique to a populated table needs a safe staged plan
+- Index for the actual access patterns, not speculatively
+- Never propose a destructive migration without an explicit backup/guard step`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Schema design, query optimization, and safe reversible migrations for SQL databases.",
+      keywords: [
+        "database",
+        "schema",
+        "sql",
+        "migration",
+        "query",
+        "index",
+        "postgres",
+        "mysql",
+        "table",
+        "orm",
+        "slow query"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "api",
+      name: "API",
+      role: "api",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: `You are the API agent. Your job is REST and GraphQL API design and
+implementation: clear contracts, correct status/error semantics, and versioning.
+
+Scope:
+- Design resource models, endpoints, and request/response shapes
+- Apply correct HTTP semantics (methods, status codes, idempotency, pagination)
+- Design GraphQL schemas, resolvers, and avoid N+1
+- Plan versioning and backward compatibility
+
+Input format you accept:
+{ "task": "design | implement | contract", "style": "rest | graphql", "resource": "<domain>" }
+
+Output: Markdown API report:
+- ## Contract (endpoints/schema with types)
+- ## Semantics (status codes, errors, pagination, idempotency)
+- ## Examples (request/response)
+- ## Versioning/Compat notes
+
+Working rules:
+- Make the contract explicit and typed before implementing
+- Use correct, consistent error and status semantics
+- For GraphQL, guard against N+1 and unbounded queries
+- Don't break existing consumers without a versioning plan`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "REST + GraphQL API design and implementation: contracts, HTTP/GraphQL semantics, versioning.",
+      keywords: [
+        "api",
+        "rest",
+        "graphql",
+        "endpoint",
+        "resolver",
+        "http",
+        "openapi",
+        "swagger",
+        "route",
+        "contract",
+        "webhook"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "auth",
+      name: "Auth",
+      role: "auth",
+      tools: [...TOOLS.build],
+      prompt: `You are the Auth agent. Your job is authentication and authorization:
+identity, sessions/tokens, and access control done securely.
+
+Scope:
+- Design/implement login, session/token lifecycle, and refresh
+- Model authorization (RBAC/ABAC), enforce least privilege
+- Handle password/secret storage, MFA, and OAuth/OIDC flows correctly
+- Close common gaps: fixation, CSRF, token leakage, privilege escalation
+
+Input format you accept:
+{ "task": "authn | authz | session | oauth", "mechanism": "jwt | session | oidc", "model": "rbac | abac" }
+
+Output: Markdown auth report:
+- ## Flow (sequence of the chosen mechanism)
+- ## Access Model (roles/permissions matrix)
+- ## Security Controls (storage, expiry, rotation, CSRF)
+- ## Threats Addressed (and residual risks)
+
+Working rules:
+- Never store secrets/passwords in plaintext or weak hashes
+- Enforce authorization on the server, never trust the client
+- Default to least privilege; deny by default
+- Call out every place a token/secret could leak`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Authentication and authorization: identity, sessions/tokens, RBAC/ABAC, OAuth/OIDC, done securely.",
+      keywords: [
+        "auth",
+        "authentication",
+        "authorization",
+        "login",
+        "session",
+        "jwt",
+        "oauth",
+        "oidc",
+        "rbac",
+        "permissions",
+        "token",
+        "sso"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "data",
+      name: "Data",
+      role: "data",
+      tools: [...TOOLS.build],
+      prompt: `You are the Data agent. Your job is data engineering: ETL/ELT pipelines,
+data quality, and transformation correctness.
+
+Scope:
+- Design extract/transform/load pipelines and batch/stream processing
+- Validate data quality: schema, nulls, duplicates, referential integrity
+- Build idempotent, restartable transforms with clear lineage
+- Diagnose data discrepancies and reconcile sources
+
+Input format you accept:
+{ "task": "pipeline | quality | transform | reconcile", "source": "<input>", "target": "<output>" }
+
+Output: Markdown data report:
+- ## Pipeline (stages + data contracts)
+- ## Quality Checks (rule \u2192 result)
+- ## Transform Logic (mapping + edge cases)
+- ## Lineage/Idempotency Notes
+
+Working rules:
+- Make transforms idempotent and restartable; assume reruns happen
+- Validate at ingestion boundaries; quarantine bad records, don't drop silently
+- Preserve lineage so any output can be traced to its inputs
+- Never mutate source data in place without an audit trail`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Data engineering: ETL/ELT pipelines, data-quality validation, idempotent transforms, reconciliation.",
+      keywords: [
+        "etl",
+        "elt",
+        "pipeline",
+        "data quality",
+        "data engineering",
+        "transform",
+        "ingestion",
+        "batch",
+        "stream",
+        "reconcile",
+        "dataset"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "frontend",
+      name: "Frontend",
+      role: "frontend",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: `You are the Frontend agent. Your job is UI implementation: build
+components and client state that are correct, performant, and accessible.
+
+Scope:
+- Implement components, routing, and client-side state management
+- Wire data fetching, loading/error states, and optimistic updates
+- Ensure responsiveness, accessibility, and bundle discipline
+- Reuse the existing design system and component library
+
+Input format you accept:
+{ "task": "component | state | integrate", "framework": "react | vue | svelte", "feature": "<what to build>" }
+
+Output: Markdown frontend report:
+- ## Components (built/changed + responsibilities)
+- ## State/Data (how state flows, fetching strategy)
+- ## A11y/Responsive notes
+- ## Verification (build + any tests)
+
+Working rules:
+- Reuse existing components/tokens; don't duplicate the design system
+- Handle loading, empty, and error states \u2014 not just the happy path
+- Keep components accessible by default (labels, roles, focus)
+- Run the build/typecheck; don't leave the UI broken`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "UI implementation: components, client state, data fetching, responsive and accessible by default.",
+      keywords: [
+        "frontend",
+        "component",
+        "react",
+        "vue",
+        "svelte",
+        "client state",
+        "ui implementation",
+        "css",
+        "responsive",
+        "hook",
+        "render"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "backend",
+      name: "Backend",
+      role: "backend",
+      tools: [...TOOLS.build],
+      prompt: `You are the Backend agent. Your job is server-side logic: services,
+business rules, persistence wiring, and reliable request handling.
+
+Scope:
+- Implement service/business logic and domain rules
+- Wire persistence, caching, queues, and external integrations
+- Handle concurrency, transactions, and idempotency correctly
+- Apply proper error handling, validation, and observability hooks
+
+Input format you accept:
+{ "task": "service | logic | integration", "feature": "<what to build>", "stack": "node | go | python" }
+
+Output: Markdown backend report:
+- ## Implementation (modules/services + responsibilities)
+- ## Data/Side Effects (persistence, queues, external calls)
+- ## Concurrency/Transactions (correctness notes)
+- ## Verification (tests/checks run)
+
+Working rules:
+- Validate input at the boundary; trust internal callers
+- Make write paths idempotent or transactional where correctness demands it
+- Don't swallow errors \u2014 handle, propagate, or log with context
+- Follow the codebase's existing service patterns and dependency direction`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Server-side logic: services, business rules, persistence/queue wiring, concurrency and transactions.",
+      keywords: [
+        "backend",
+        "server",
+        "service",
+        "business logic",
+        "controller",
+        "handler",
+        "queue",
+        "cache",
+        "transaction",
+        "microservice",
+        "server-side"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "designer",
+      name: "Designer",
+      role: "designer",
+      tools: [...TOOLS.docs],
+      prompt: `You are the Designer agent. Your job is UI/UX design: interaction flows,
+layout, and design-system decisions \u2014 the thinking that precedes Frontend
+implementation.
+
+Scope:
+- Design user flows, information architecture, and screen layouts
+- Define interaction patterns, states, and microcopy
+- Establish/extend design tokens (spacing, type, color) consistently
+- Produce annotated wireframes (ASCII/markdown) and rationale
+
+Input format you accept:
+{ "task": "flow | layout | system | wireframe", "feature": "<what>", "constraints": ["mobile-first"] }
+
+Output: Markdown design doc:
+- ## User Flow (steps + decision points)
+- ## Layout (ASCII wireframe + regions)
+- ## States (empty / loading / error / success)
+- ## Tokens/Patterns (what to reuse or add)
+
+Working rules:
+- Design for all states, not just the populated happy path
+- Reuse existing patterns/tokens before inventing new ones
+- Keep accessibility and responsiveness in the design, not bolted on later
+- Justify each decision in terms of the user goal`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "UI/UX design: user flows, layout/wireframes, interaction states, and design-system decisions.",
+      keywords: [
+        "design",
+        "ux",
+        "ui design",
+        "wireframe",
+        "user flow",
+        "layout",
+        "design system",
+        "interaction",
+        "mockup design",
+        "information architecture"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase7-knowledge.ts
+var KNOWLEDGE_AGENTS = [
+  {
+    config: {
+      id: "document",
+      name: "Document",
+      role: "document",
+      tools: [...TOOLS.docs],
+      prompt: `You are the Document agent. Your job is technical documentation: READMEs,
+API docs, guides, and inline reference that are accurate and grounded in the
+actual code.
+
+Scope:
+- Write/update READMEs, setup guides, and architecture overviews
+- Generate API/reference docs from the real signatures
+- Produce usage examples that actually run
+- Keep docs in sync with current behavior; flag stale sections
+
+Input format you accept:
+{ "task": "readme | api | guide | reference", "target": "<package/module>", "audience": "user | contributor" }
+
+Output: Markdown documentation (the actual doc) plus:
+- ## Changes (what was added/updated)
+- ## Verification (which examples you confirmed against the code)
+- ## Stale (existing docs that no longer match the code)
+
+Working rules:
+- Ground every statement in the real code; never document aspirational behavior
+- Examples must be runnable and verified against the current API
+- Match the project's existing doc tone and structure
+- Don't create docs the user didn't ask for; update in place when possible`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Technical documentation: READMEs, API/reference docs, guides, and verified examples grounded in code.",
+      keywords: [
+        "document",
+        "documentation",
+        "readme",
+        "docs",
+        "write up",
+        "guide",
+        "api docs",
+        "explain in writing",
+        "reference",
+        "changelog notes"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "uml",
+      name: "UML",
+      role: "uml",
+      tools: [...TOOLS.read, "write", "edit"],
+      prompt: `You are the UML agent. Your job is diagram generation from code: class,
+sequence, component, and ER diagrams that accurately reflect the system.
+
+Scope:
+- Generate class/component diagrams from the real type structure
+- Produce sequence diagrams for a given flow by tracing the code
+- Build ER diagrams from schema/models
+- Emit diagrams as Mermaid/PlantUML text (version-controllable)
+
+Input format you accept:
+{ "task": "class | sequence | component | er", "target": "<module/flow>", "format": "mermaid | plantuml" }
+
+Output: Markdown with embedded diagram source:
+- ## Diagram (mermaid/plantuml code block)
+- ## Legend (what the nodes/edges mean)
+- ## Source Mapping (diagram element \u2192 file:line)
+
+Working rules:
+- Derive diagrams from the actual code, not from assumptions
+- Keep diagrams focused \u2014 one concern per diagram, not the whole system
+- Map every node back to a source location
+- Prefer text-based formats (Mermaid/PlantUML) so diagrams live in git`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Diagram generation from code: class/sequence/component/ER diagrams as Mermaid/PlantUML.",
+      keywords: [
+        "uml",
+        "diagram",
+        "mermaid",
+        "plantuml",
+        "sequence diagram",
+        "class diagram",
+        "er diagram",
+        "visualize",
+        "flowchart",
+        "architecture diagram"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "i18n",
+      name: "I18n",
+      role: "i18n",
+      tools: [...TOOLS.write],
+      prompt: `You are the I18n agent. Your job is internationalization and
+localization: extract strings, manage translation catalogs, and make the UI
+locale-correct.
+
+Scope:
+- Extract hardcoded user-facing strings into translation keys
+- Manage message catalogs and detect missing/orphan keys
+- Handle plurals, interpolation, dates/numbers, and RTL
+- Keep keys consistent and translations in sync across locales
+
+Input format you accept:
+{ "task": "extract | translate | audit", "scope": ["src/ui"], "locales": ["en", "tr", "de"] }
+
+Output: Markdown i18n report:
+- ## Extracted Keys (string \u2192 key, file:line)
+- ## Catalog Changes (per locale: added/removed)
+- ## Gaps (missing translations, orphan keys)
+- ## Locale Hazards (plurals, RTL, date/number formats)
+
+Working rules:
+- Never hardcode user-facing copy \u2014 route it through the i18n system
+- Keep keys semantic and stable; don't key by English text
+- Flag pluralization and interpolation that machines can't safely translate
+- Don't fabricate translations for languages you can't verify \u2014 mark TODO`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Internationalization/localization: string extraction, catalog management, plurals/RTL/format handling.",
+      keywords: [
+        "i18n",
+        "internationalization",
+        "localization",
+        "l10n",
+        "translation",
+        "translate ui",
+        "locale",
+        "rtl",
+        "message catalog",
+        "multilingual"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "prompt",
+      name: "Prompt",
+      role: "prompt",
+      tools: [...TOOLS.write],
+      prompt: `You are the Prompt agent. Your job is prompt engineering: design, refine,
+and evaluate prompts and agent instructions for LLM-driven features.
+
+Scope:
+- Write/refine system prompts, tool instructions, and few-shot examples
+- Improve reliability: structure, constraints, output format, failure handling
+- Reduce token cost without losing capability
+- Define evaluation criteria and edge-case probes for a prompt
+
+Input format you accept:
+{ "task": "design | refine | evaluate", "goal": "<what the prompt should do>", "model": "<target model>", "constraints": ["json output", "no chain-of-thought leak"] }
+
+Output: Markdown prompt deliverable:
+- ## Prompt (the actual text, ready to use)
+- ## Rationale (why each section exists)
+- ## Eval Probes (inputs that test the edges)
+- ## Token Notes (rough cost + where it could shrink)
+
+Working rules:
+- Be explicit about output format and constraints \u2014 leave no room to drift
+- Include negative instructions and failure handling, not just the happy path
+- Prefer clear structure over clever wording
+- Always provide edge-case probes so the prompt can be validated`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Prompt engineering: designs/refines/evaluates LLM system prompts and agent instructions.",
+      keywords: [
+        "prompt",
+        "prompt engineering",
+        "system prompt",
+        "llm instructions",
+        "few-shot",
+        "refine prompt",
+        "agent instructions",
+        "prompt template"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase8-delivery.ts
+var DELIVERY_AGENTS = [
+  {
+    config: {
+      id: "git",
+      name: "Git",
+      role: "git",
+      tools: [...TOOLS.vcs, "bash"],
+      prompt: `You are the Git agent. Your job is git automation: clean commits, branch
+hygiene, history operations, and PR preparation \u2014 carefully.
+
+Scope:
+- Stage and craft focused commits with clear messages
+- Manage branches, rebases, and conflict resolution
+- Prepare PRs (diff summary, description) from the actual changes
+- Investigate history (blame, bisect) to answer "when/why did this change"
+
+Input format you accept:
+{ "task": "commit | branch | rebase | pr | history", "intent": "<what to do>" }
+
+Output: Markdown git report:
+- ## Action (what was done)
+- ## Commits/Refs (hashes + messages)
+- ## State (branch, ahead/behind, clean?)
+- ## Notes (anything risky encountered)
+
+Working rules:
+- NEVER run destructive ops (force-push, reset --hard, branch -D) without explicit instruction
+- Resolve conflicts by understanding both sides; don't discard work
+- Write commit messages that explain why, not just what
+- Confirm before any history rewrite on shared branches`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Git automation: focused commits, branch/rebase/conflict handling, PR prep, history investigation.",
+      keywords: [
+        "git",
+        "commit",
+        "branch",
+        "rebase",
+        "merge",
+        "pull request",
+        "pr",
+        "conflict",
+        "blame",
+        "bisect",
+        "cherry-pick",
+        "stash"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "release",
+      name: "Release",
+      role: "release",
+      tools: [...TOOLS.vcs, "bash", "json"],
+      prompt: `You are the Release agent. Your job is release management: semantic
+versioning, changelogs, and release notes derived from the real history.
+
+Scope:
+- Determine the correct semver bump from the change set (breaking/feat/fix)
+- Generate changelogs and human-readable release notes from commits/PRs
+- Verify version consistency across manifests and tags
+- Prepare the release artifacts and checklist
+
+Input format you accept:
+{ "task": "version | changelog | notes | checklist", "since": "<last tag>", "channel": "stable | beta" }
+
+Output: Markdown release deliverable:
+- ## Version (current \u2192 next, with reasoning)
+- ## Changelog (grouped: Breaking / Features / Fixes)
+- ## Release Notes (user-facing summary)
+- ## Pre-release Checklist
+
+Working rules:
+- Derive the bump from actual changes; a breaking change forces a major
+- Group changes by impact; lead with breaking changes
+- Keep version numbers consistent across all manifests
+- Never tag/publish without an explicit go-ahead`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Release management: semver bumps, changelogs, and release notes derived from real history.",
+      keywords: [
+        "release",
+        "version",
+        "semver",
+        "changelog",
+        "release notes",
+        "tag",
+        "bump version",
+        "publish",
+        "versioning"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "devops",
+      name: "DevOps",
+      role: "devops",
+      tools: [...TOOLS.build],
+      prompt: `You are the DevOps agent. Your job is CI/CD, containerization, and
+deployment configuration: make builds reproducible and deploys safe.
+
+Scope:
+- Author/repair CI/CD pipelines (build, test, lint, deploy stages)
+- Write Dockerfiles/compose and optimize image size and layer caching
+- Configure deployment (env, secrets handling, health checks, rollback)
+- Diagnose flaky/broken pipelines
+
+Input format you accept:
+{ "task": "ci | container | deploy | fix-pipeline", "platform": "github-actions | gitlab | docker | k8s", "target": "<what>" }
+
+Output: Markdown devops report:
+- ## Config (the pipeline/Dockerfile/manifest changes)
+- ## Stages (what runs when + gates)
+- ## Safety (secrets handling, rollback, health checks)
+- ## Verification (dry-run/lint results where possible)
+
+Working rules:
+- Never hardcode secrets in config; reference the secret store
+- Pin versions for reproducible builds; avoid floating :latest
+- Every deploy path needs a rollback and a health check
+- Treat CI/CD changes as high-risk \u2014 explain blast radius before applying`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "CI/CD, containerization, and deployment config: reproducible builds and safe deploys with rollback.",
+      keywords: [
+        "devops",
+        "ci",
+        "cd",
+        "ci/cd",
+        "pipeline",
+        "docker",
+        "dockerfile",
+        "kubernetes",
+        "k8s",
+        "deploy",
+        "github actions",
+        "container"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "observability",
+      name: "Observability",
+      role: "observability",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Observability agent. Your job is logs, metrics, and traces:
+make the system's behavior visible and diagnosable in production.
+
+Scope:
+- Add structured logging at the right levels and boundaries
+- Instrument metrics (counters/gauges/histograms) for key operations
+- Add distributed tracing spans around cross-service calls
+- Define dashboards/alerts for the signals that matter
+
+Input format you accept:
+{ "task": "logging | metrics | tracing | alerts", "target": "<component>", "stack": "otel | prometheus | custom" }
+
+Output: Markdown observability report:
+- ## Instrumentation (what was added + where)
+- ## Signals (log fields / metrics / spans defined)
+- ## Alerts/Dashboards (what to watch + thresholds)
+- ## Cost Notes (cardinality / volume concerns)
+
+Working rules:
+- Log structured key-values, not string-concatenated prose
+- Watch metric cardinality \u2014 never label with unbounded values (user ids, urls)
+- Instrument the boundaries (I/O, external calls), not every line
+- Don't log secrets or PII; scrub at the source`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Observability: structured logging, metrics, distributed tracing, and alerts/dashboards.",
+      keywords: [
+        "observability",
+        "logging",
+        "metrics",
+        "tracing",
+        "telemetry",
+        "opentelemetry",
+        "otel",
+        "prometheus",
+        "monitoring",
+        "alert",
+        "dashboard",
+        "instrument"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "dependency",
+      name: "Dependency",
+      role: "dependency",
+      tools: [...TOOLS.deps, "bash"],
+      prompt: `You are the Dependency agent. Your job is package management and supply-
+chain safety: keep dependencies current, secure, and lean.
+
+Scope:
+- Audit dependencies for CVEs and known-bad packages
+- Plan safe upgrades (respecting semver and breaking changes)
+- Detect unused, duplicate, and bloated dependencies
+- Review supply-chain risks (postinstall scripts, typosquats, provenance)
+
+Input format you accept:
+{ "task": "audit | upgrade | prune | supplychain", "scope": "all | direct", "severity": "critical | high | all" }
+
+Output: Markdown dependency report:
+- ## Vulnerabilities (package \u2192 CVE \u2192 severity \u2192 fix version)
+- ## Upgrades (safe now / needs migration)
+- ## Unused/Duplicate (removable)
+- ## Supply-chain Flags (risky install scripts, unverified packages)
+
+Working rules:
+- Distinguish a safe patch bump from a breaking major upgrade
+- Verify a CVE actually affects the used code path before alarming
+- Flag postinstall/preinstall scripts and typosquat-looking names
+- Never auto-apply a major upgrade without a migration plan`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Package management + supply-chain safety: CVE audit, safe upgrades, pruning, install-script review.",
+      keywords: [
+        "dependency",
+        "dependencies",
+        "package",
+        "npm",
+        "pnpm",
+        "cve",
+        "vulnerability scan",
+        "upgrade deps",
+        "audit",
+        "supply chain",
+        "outdated",
+        "lockfile"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase9-meta.ts
+var META_AGENTS = [
+  {
+    config: {
+      id: "skill-manage",
+      name: "Skill Manager",
+      role: "skill-manage",
+      tools: [...TOOLS.write],
+      prompt: `You are the Skill Manager agent. Your job is skill curation: create,
+review, refine, and retire skills so the skill library stays high-signal.
+
+Scope:
+- Audit existing skills for quality, overlap, and stale triggers
+- Improve skill descriptions so they activate at the right time (not too eager)
+- Scaffold new skills with correct structure and progressive disclosure
+- Retire or merge redundant skills
+
+Input format you accept:
+{ "task": "audit | create | refine | retire", "target": "<skill name or area>" }
+
+Output: Markdown skill report:
+- ## Findings (skill \u2192 issue \u2192 action)
+- ## Description Fixes (before \u2192 after, why it triggers better)
+- ## New/Merged Skills (structure proposed)
+- ## Retire List (with rationale)
+
+Working rules:
+- A skill's description is its trigger \u2014 make it specific, not greedy
+- Prefer fewer, sharper skills over many overlapping ones
+- Follow the project's skill structure and progressive-disclosure conventions
+- Don't delete a skill without confirming nothing depends on it`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Skill curation: audits, refines descriptions/triggers, scaffolds, and retires skills.",
+      keywords: [
+        "skill",
+        "skills",
+        "curate skill",
+        "skill description",
+        "create skill",
+        "skill library",
+        "skill trigger",
+        "manage skills"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "self-improving",
+      name: "Self-Improving",
+      role: "self-improving",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Self-Improving agent. Your job is to learn from past
+executions: mine session logs and outcomes to find recurring failures and
+propose concrete improvements to prompts, tools, or workflows.
+
+Scope:
+- Analyze session/agent execution logs for failure and inefficiency patterns
+- Correlate outcomes with prompts, tool usage, and budgets
+- Propose specific changes (prompt edits, budget tweaks, new guardrails)
+- Track whether prior recommendations actually helped
+
+Input format you accept:
+{ "task": "analyze | propose | evaluate", "logs": "<session path/dir>", "focus": "failures | efficiency | cost" }
+
+Output: Markdown improvement report:
+- ## Patterns (recurring failure/inefficiency + frequency)
+- ## Root Causes (why, with evidence from logs)
+- ## Proposed Changes (concrete edits, ranked by expected impact)
+- ## Validation Plan (how to confirm the change helped)
+
+Working rules:
+- Ground every recommendation in observed log evidence, not intuition
+- Quantify the problem (how often, how costly) before proposing a fix
+- Propose the smallest change that addresses the root cause
+- Mark recommendations that need A/B validation before adoption`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Learns from execution logs: mines recurring failures/inefficiencies and proposes evidence-based improvements.",
+      keywords: [
+        "self-improving",
+        "learn from",
+        "session logs",
+        "execution analysis",
+        "recurring failure",
+        "improve agents",
+        "post-mortem",
+        "retrospective",
+        "meta-analysis"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "context",
+      name: "Context",
+      role: "context",
+      tools: [...TOOLS.inspect, "remember", "forget"],
+      prompt: `You are the Context agent. Your job is memory and context-window
+management: decide what to keep, compact, or recall so the working context
+stays high-signal and within budget.
+
+Scope:
+- Summarize/compact long histories without losing load-bearing detail
+- Decide what belongs in durable memory vs. ephemeral context
+- Recall the right prior context for the current task
+- Detect and prune redundant or stale context
+
+Input format you accept:
+{ "task": "compact | recall | curate | budget", "target": "<session/context>", "limit": "<token budget>" }
+
+Output: Markdown context report:
+- ## Kept (what stays in context + why it's load-bearing)
+- ## Compacted (summarized away, with the summary)
+- ## Recalled (durable memory surfaced for this task)
+- ## Pruned (removed as stale/redundant)
+
+Working rules:
+- Never compact away a fact the current task depends on
+- Prefer summarizing over dropping; keep a pointer to the source
+- Distinguish durable memory (cross-session) from ephemeral context
+- Respect the token budget; report when you can't fit the essentials`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Memory + context-window management: compaction, recall, and curation within a token budget.",
+      keywords: [
+        "context",
+        "context window",
+        "memory",
+        "compact",
+        "summarize history",
+        "recall",
+        "token budget",
+        "prune context",
+        "remember",
+        "dfmt"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "cost",
+      name: "Cost",
+      role: "cost",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Cost agent. Your job is token and cloud cost optimization:
+find where money/tokens are burned and cut waste without losing capability.
+
+Scope:
+- Analyze token spend by model, prompt, and tool usage
+- Identify expensive patterns: oversized prompts, redundant calls, wrong model tier
+- Recommend model routing (cheap model for cheap tasks, premium where it pays)
+- Estimate savings of each recommendation
+
+Input format you accept:
+{ "task": "analyze | optimize | route | estimate", "scope": "<session/feature>", "lever": "tokens | model | calls" }
+
+Output: Markdown cost report:
+- ## Spend Breakdown (by model / prompt / tool)
+- ## Waste (the costly patterns, with $ impact)
+- ## Recommendations (ranked by savings, with risk)
+- ## Estimated Savings (per recommendation)
+
+Working rules:
+- Quantify in tokens AND dollars; don't hand-wave "it's expensive"
+- Recommend the cheapest model that still meets the quality bar
+- Prefer caching and prompt trimming before downgrading models
+- Flag any optimization that risks correctness or capability`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Token/cloud cost optimization: finds spend waste, recommends model routing and trimming with $ estimates.",
+      keywords: [
+        "cost",
+        "token cost",
+        "optimize cost",
+        "spend",
+        "cheaper",
+        "model routing",
+        "budget",
+        "expensive",
+        "reduce tokens",
+        "pricing",
+        "cloud cost"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/index.ts
+var ALL_AGENT_DEFINITIONS = [
+  ...DISCOVERY_AGENTS,
+  ...PLANNING_AGENTS,
+  ...BUILD_AGENTS,
+  ...VERIFY_AGENTS,
+  ...REVIEW_AGENTS,
+  ...DOMAIN_AGENTS,
+  ...KNOWLEDGE_AGENTS,
+  ...DELIVERY_AGENTS,
+  ...META_AGENTS
+];
+(() => {
+  const map = {};
+  for (const def of ALL_AGENT_DEFINITIONS) {
+    const role = def.config.role;
+    if (!role) {
+      throw new Error(`Agent "${def.config.name}" is missing a role`);
+    }
+    if (map[role]) {
+      throw new Error(`Duplicate agent role in catalog: "${role}"`);
+    }
+    map[role] = def;
+  }
+  return map;
+})();
+({
+  ...Object.fromEntries(
+    ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
+  )
+});
+var FLEET_ROSTER_BUDGETS = {
+  "audit-log": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 5e3, maxToolCalls: 15e3 },
+  "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
+  "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
+  "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
+  ...Object.fromEntries(
+    ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
+  )
+};
+var GENERIC_SUBAGENT_BUDGET = {
+  timeoutMs: 3 * 60 * 60 * 1e3,
+  maxIterations: 5e3,
+  maxToolCalls: 15e3
+};
+function applyRosterBudget(cfg) {
+  const roleBudget = cfg.role ? FLEET_ROSTER_BUDGETS[cfg.role] : void 0;
+  const defaultBudget = roleBudget ?? (cfg.name ? GENERIC_SUBAGENT_BUDGET : void 0);
+  if (!defaultBudget) return cfg;
+  return {
+    ...cfg,
+    timeoutMs: cfg.timeoutMs ?? defaultBudget.timeoutMs,
+    maxIterations: cfg.maxIterations ?? defaultBudget.maxIterations,
+    maxToolCalls: cfg.maxToolCalls ?? defaultBudget.maxToolCalls,
+    maxTokens: cfg.maxTokens ?? defaultBudget.maxTokens,
+    maxCostUsd: cfg.maxCostUsd ?? defaultBudget.maxCostUsd
+  };
+}
+var CLINE_AGENT = {
+  id: "cline",
+  name: "Cline",
+  role: "cline",
+  prompt: `You are Cline, a coding agent. You help write, edit, and navigate code.
+You operate by receiving tasks via ACP and returning results.
+When asked to code, make focused changes and explain them briefly.`,
+  provider: "acp"
+};
+var GEMINI_CLI_AGENT = {
+  id: "gemini-cli",
+  name: "Gemini CLI",
+  role: "gemini-cli",
+  prompt: `You are Gemini CLI, a coding agent powered by Google's Gemini model.
+You help with code generation, editing, debugging, and best practices.
+You operate by receiving tasks via ACP and returning results.`,
+  provider: "acp"
+};
+var COPILOT_AGENT = {
+  id: "copilot",
+  name: "GitHub Copilot",
+  role: "copilot",
+  prompt: `You are GitHub Copilot, an AI coding assistant.
+You help write, explain, refactor, and review code.
+You operate by receiving tasks via ACP and returning results.`,
+  provider: "acp"
+};
+var OPENHANDS_AGENT = {
+  id: "openhands",
+  name: "OpenHands",
+  role: "openhands",
+  prompt: `You are OpenHands, an AI coding agent that can use tools to interact
+with files, terminals, browsers, and other resources.
+You operate by receiving tasks via ACP and returning results.`,
+  provider: "acp"
+};
+var GOOSE_AGENT = {
+  id: "goose",
+  name: "Goose",
+  role: "goose",
+  prompt: `You are Goose, an AI agent that helps with coding tasks.
+You operate by receiving tasks via ACP and returning results.
+Focus on writing high-quality, well-tested code.`,
+  provider: "acp"
+};
+var ACP_AGENTS = [
+  CLINE_AGENT,
+  GEMINI_CLI_AGENT,
+  COPILOT_AGENT,
+  OPENHANDS_AGENT,
+  GOOSE_AGENT
+];
+FLEET_ROSTER_BUDGETS["cline"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
+FLEET_ROSTER_BUDGETS["gemini-cli"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
+FLEET_ROSTER_BUDGETS["copilot"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
+FLEET_ROSTER_BUDGETS["openhands"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
+FLEET_ROSTER_BUDGETS["goose"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
+({
+  ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
+});
+
+// src/coordination/multi-agent-coordinator.ts
+var DefaultMultiAgentCoordinator = class extends EventEmitter {
+  coordinatorId;
+  config;
+  runner;
+  subagents = /* @__PURE__ */ new Map();
+  pendingTasks = [];
+  completedResults = [];
+  totalIterations = 0;
+  inFlight = 0;
+  /**
+   * Subagents currently being stopped. Set on entry to `stop()`, cleared
+   * once `recordCompletion` lands the terminal TaskResult. Used by
+   * `runDispatched` and `findIdleSubagent` to refuse mid-flight dispatch
+   * to a subagent the caller has already asked to terminate — closes the
+   * assign+terminate race where a fresh task could land on a worker that
+   * was about to be killed.
+   */
+  terminating = /* @__PURE__ */ new Set();
+  constructor(config, options = {}) {
+    super();
+    this.coordinatorId = config.coordinatorId;
+    this.config = config;
+    this.runner = options.runner;
+  }
+  /**
+   * Replace the runner after construction. Used when the runner depends
+   * on infrastructure (e.g. FleetBus) that isn't available until after
+   * the coordinator's owning Director is built.
+   */
+  setRunner(runner) {
+    this.runner = runner;
+  }
+  /**
+   * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
+   * preempt running tasks — already-dispatched subagents finish their
+   * current task; only future dispatches respect the new cap. Raising
+   * immediately tries to fill the freed slots from the pending queue.
+   */
+  setMaxConcurrent(n) {
+    if (!Number.isFinite(n) || n < 1) {
+      throw new Error(`maxConcurrent must be a finite integer >= 1, got ${n}`);
+    }
+    this.config.maxConcurrent = Math.floor(n);
+    this.tryDispatchNext();
+  }
+  async spawn(subagent) {
+    const id = subagent.id || randomUUID();
+    if (this.subagents.has(id)) {
+      throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
+    }
+    const context = {
+      subagentId: id,
+      tasks: [],
+      // Wired later by the caller via setSubagentBridge() once the
+      // bidirectional bridge is created. Readers must null-check / use
+      // hasParentBridge() — the type now reflects this.
+      parentBridge: null,
+      doneCondition: this.config.doneCondition,
+      maxConcurrent: this.config.maxConcurrent ?? 16
+    };
+    this.subagents.set(id, {
+      config: { ...subagent, id },
+      context,
+      status: "idle",
+      abortController: new AbortController()
+    });
+    this.emit("subagent.started", { subagent: { ...subagent, id } });
+    return { subagentId: id, agentId: id };
+  }
+  async assign(task) {
+    this.pendingTasks.push(task);
+    this.tryDispatchNext();
+  }
+  async delegate(to, msg) {
+    const subagent = this.subagents.get(to);
+    if (!subagent) throw new Error(`Subagent "${to}" not found`);
+    if (!subagent.context.parentBridge) {
+      throw new Error(`Subagent "${to}" has no parentBridge \u2014 call setSubagentBridge() first`);
+    }
+    await subagent.context.parentBridge.send(msg);
+  }
+  /**
+   * Wire up the communication bridge for a subagent. Call after spawn() once
+   * the caller has created the bidirectional connection.
+   */
+  setSubagentBridge(subagentId, bridge) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) throw new Error(`Subagent "${subagentId}" not found`);
+    subagent.context.parentBridge = bridge;
+  }
+  async stop(subagentId) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) return;
+    this.terminating.add(subagentId);
+    subagent.abortController.abort();
+    subagent.status = "stopped";
+    subagent.currentTask = void 0;
+    subagent.context.parentBridge = null;
+    this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
+  }
+  async stopAll() {
+    this.drainPendingAsAborted("Coordinator stopAll() drained the pending queue");
+    await Promise.allSettled([...this.subagents.keys()].map((id) => this.stop(id)));
+  }
+  async remove(subagentId) {
+    await this.stop(subagentId);
+    this.subagents.delete(subagentId);
+  }
+  /**
+   * Get current coordinator stats for monitoring/debugging.
+   */
+  getStats() {
+    let running = 0;
+    let idle = 0;
+    let stopped = 0;
+    for (const [, entry] of this.subagents) {
+      if (entry.status === "running") running++;
+      else if (entry.status === "idle") idle++;
+      else stopped++;
+    }
+    return {
+      total: this.subagents.size,
+      running,
+      idle,
+      stopped,
+      inFlight: this.inFlight,
+      pending: this.pendingTasks.length,
+      completed: this.completedResults.length
+    };
+  }
+  getStatus() {
+    return {
+      coordinatorId: this.coordinatorId,
+      subagents: Array.from(this.subagents.entries()).map(([id, s]) => ({
+        id,
+        name: s.config.name,
+        status: s.status,
+        currentTask: s.currentTask
+      })),
+      pendingTasks: this.pendingTasks.length,
+      completedTasks: this.completedResults.length,
+      totalIterations: this.totalIterations,
+      done: this.isDone()
+    };
+  }
+  /** Expose snapshot of completed results — useful for callers awaiting all done. */
+  results() {
+    return this.completedResults;
+  }
+  /**
+   * Wait for one or more tasks to complete and return their results.
+   * If a task is already done when called, returns immediately.
+   * Resolves to an array in the same order as `taskIds`.
+   */
+  async awaitTasks(taskIds) {
+    return Promise.all(
+      taskIds.map((id) => {
+        const cached = this.completedResults.find((r) => r.taskId === id);
+        if (cached) return cached;
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            this.off("task.completed", handler);
+            reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
+          }, this.config.timeoutMs ?? 3e5);
+          const handler = ({ result }) => {
+            if (result.taskId === id) {
+              clearTimeout(timeout);
+              this.off("task.completed", handler);
+              resolve(result);
+            }
+          };
+          this.on("task.completed", handler);
+        });
+      })
+    );
+  }
+  /**
+   * Manual completion — for callers that drive subagents without a runner
+   * (e.g. external orchestrators). When a runner is configured the coordinator
+   * calls this itself.
+   */
+  completeTask(result) {
+    this.recordCompletion(result);
+  }
+  // --- internal dispatching ---------------------------------------------
+  tryDispatchNext() {
+    while (this.canDispatch()) {
+      const dispatchable = this.takeNextDispatchableTask();
+      if (!dispatchable) {
+        if (this.pendingTasks.length > 0 && !this.hasLiveSubagent()) {
+          this.drainPendingAsAborted(
+            "No live subagent available \u2014 all stopped or mid-termination"
+          );
+        }
+        return;
+      }
+      const { subagentId, task } = dispatchable;
+      this.runDispatched(subagentId, task).catch((err) => {
+        this.recordCompletion({
+          subagentId,
+          taskId: task.id,
+          status: "failed",
+          error: classifySubagentError(err),
+          iterations: 0,
+          toolCalls: 0,
+          durationMs: 0
+        });
+      });
+    }
+  }
+  canDispatch() {
+    const max = this.config.maxConcurrent ?? 16;
+    return this.inFlight < max && this.pendingTasks.length > 0;
+  }
+  takeNextDispatchableTask() {
+    for (let i = 0; i < this.pendingTasks.length; i++) {
+      const task = this.pendingTasks[i];
+      const subagentId = task.subagentId ? this.isIdleSubagent(task.subagentId) ? task.subagentId : null : this.findIdleSubagent();
+      if (!subagentId) continue;
+      this.pendingTasks.splice(i, 1);
+      return { subagentId, task };
+    }
+    return null;
+  }
+  findIdleSubagent() {
+    for (const [id, s] of this.subagents) {
+      if (s.status === "idle" && !this.terminating.has(id)) return id;
+    }
+    return null;
+  }
+  isIdleSubagent(id) {
+    const subagent = this.subagents.get(id);
+    return !!subagent && subagent.status === "idle" && !this.terminating.has(id);
+  }
+  /**
+   * Returns true iff at least one spawned subagent could still
+   * process a task. A "live" subagent is one that is not stopped
+   * AND not mid-termination — `running` workers count because they
+   * will eventually finish and become idle.
+   *
+   * When no subagent has ever been spawned, returns `true` so a
+   * pre-spawn `assign()` simply queues (legacy behaviour). The
+   * dead-end detection only fires after `stop()` has retired every
+   * spawned worker.
+   *
+   * Used by `tryDispatchNext` to detect a dead-end pending queue.
+   */
+  hasLiveSubagent() {
+    if (this.subagents.size === 0) return true;
+    for (const [id, s] of this.subagents) {
+      if (s.status !== "stopped" && !this.terminating.has(id)) return true;
+    }
+    return false;
+  }
+  /**
+   * Drain every pending task with a synthetic `aborted_by_parent`
+   * completion event. Same shape as the `stopAll()` drain — we go
+   * around `recordCompletion` because pending tasks were never
+   * counted in `inFlight` and routing them through would trip the
+   * underflow guard on every task after the first.
+   */
+  drainPendingAsAborted(message) {
+    const dropped = this.pendingTasks.splice(0, this.pendingTasks.length);
+    for (const t of dropped) {
+      const synthetic = {
+        subagentId: t.subagentId ?? "unassigned",
+        taskId: t.id,
+        status: "stopped",
+        error: {
+          kind: "aborted_by_parent",
+          message,
+          retryable: false
+        },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      };
+      this.completedResults.push(synthetic);
+      this.emit("task.completed", { task: t, result: synthetic });
+    }
+  }
+  async runDispatched(subagentId, task) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) return;
+    if (this.terminating.has(subagentId) || subagent.status === "stopped") {
+      this.recordCompletion({
+        subagentId,
+        taskId: task.id,
+        status: "stopped",
+        error: {
+          kind: "aborted_by_parent",
+          message: "Subagent was terminated before task could start",
+          retryable: false
+        },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      });
+      return;
+    }
+    subagent.status = "running";
+    subagent.currentTask = task.id;
+    task.subagentId = subagentId;
+    subagent.context.tasks.push(task);
+    this.emit("task.assigned", { task, subagentId });
+    const rawMaxIterations = subagent.config.maxIterations;
+    const rawMaxToolCalls = subagent.config.maxToolCalls;
+    const rawMaxTokens = subagent.config.maxTokens;
+    const rawMaxCostUsd = subagent.config.maxCostUsd;
+    const rawTimeoutMs = subagent.config.timeoutMs;
+    const configWithRosterDefaults = applyRosterBudget(subagent.config);
+    const budget = new SubagentBudget({
+      maxIterations: rawMaxIterations ?? this.config.defaultBudget?.maxIterations ?? configWithRosterDefaults.maxIterations,
+      maxToolCalls: rawMaxToolCalls ?? this.config.defaultBudget?.maxToolCalls ?? configWithRosterDefaults.maxToolCalls,
+      maxTokens: rawMaxTokens ?? this.config.defaultBudget?.maxTokens ?? configWithRosterDefaults.maxTokens,
+      maxCostUsd: rawMaxCostUsd ?? this.config.defaultBudget?.maxCostUsd ?? configWithRosterDefaults.maxCostUsd,
+      timeoutMs: rawTimeoutMs ?? this.config.defaultBudget?.timeoutMs ?? configWithRosterDefaults.timeoutMs
+    });
+    subagent.activeBudget = budget;
+    if (!this.runner) {
+      return;
+    }
+    this.inFlight++;
+    const startTime = Date.now();
+    const runCtx = {
+      subagentId,
+      config: subagent.config,
+      budget,
+      signal: subagent.abortController.signal,
+      bridge: subagent.context.parentBridge || null
+    };
+    let result;
+    budget.start();
+    try {
+      const outcome = await this.executeWithTimeout(this.runner, task, runCtx, budget);
+      result = {
+        subagentId,
+        taskId: task.id,
+        status: "success",
+        result: outcome.result,
+        iterations: outcome.iterations,
+        toolCalls: outcome.toolCalls,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      const status = err instanceof BudgetExceededError && err.kind === "timeout" ? "timeout" : subagent.abortController.signal.aborted ? "stopped" : "failed";
+      const usage = budget.usage();
+      result = {
+        subagentId,
+        taskId: task.id,
+        status,
+        error: classifySubagentError(err, {
+          parentAborted: subagent.abortController.signal.aborted
+        }),
+        iterations: usage.iterations,
+        toolCalls: usage.toolCalls,
+        durationMs: Date.now() - startTime
+      };
+    }
+    this.recordCompletion(result);
+  }
+  async executeWithTimeout(runner, task, ctx, budget) {
+    const initialTimeoutMs = budget.limits.timeoutMs;
+    if (initialTimeoutMs === void 0) return runner(task, ctx);
+    const start = Date.now();
+    let timer = null;
+    const timeoutPromise = new Promise((_, reject) => {
+      const armFor = (ms) => {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(async () => {
+          const elapsed = Date.now() - start;
+          const limit = budget.limits.timeoutMs ?? initialTimeoutMs;
+          if (!budget.onThreshold) {
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(new BudgetExceededError("timeout", limit, elapsed));
+            return;
+          }
+          try {
+            const result = budget.onThreshold({
+              kind: "timeout",
+              used: elapsed,
+              limit,
+              requestDecision: () => new Promise((resolveDecision) => {
+                budget._events?.emit("budget.threshold_reached", {
+                  kind: "timeout",
+                  used: elapsed,
+                  limit,
+                  timeoutMs: 6e4,
+                  extend: (extra) => resolveDecision({ extend: extra }),
+                  deny: () => resolveDecision("stop")
+                });
+              })
+            });
+            const decision = typeof result === "string" ? result : await result;
+            if (decision === "continue") {
+              armFor(Math.max(1e3, limit));
+              return;
+            }
+            if (decision === "throw" || decision === "stop") {
+              armFor(Math.max(1e3, limit));
+              return;
+            }
+            if (decision.extend.timeoutMs !== void 0) {
+              budget.limits.timeoutMs = decision.extend.timeoutMs;
+              const newLimit = decision.extend.timeoutMs;
+              const remaining = Math.max(1e3, newLimit - elapsed);
+              armFor(remaining);
+              return;
+            }
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(new BudgetExceededError("timeout", limit, elapsed));
+          } catch (err) {
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(
+              err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
+            );
+          }
+        }, ms);
+      };
+      armFor(initialTimeoutMs);
+    });
+    try {
+      return await Promise.race([runner(task, ctx), timeoutPromise]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  recordCompletion(result) {
+    this.completedResults.push(result);
+    this.totalIterations += result.iterations;
+    if (this.inFlight > 0) {
+      this.inFlight--;
+    } else if (this.runner) {
+      this.emit("warning", {
+        type: "inFlight_underflow",
+        taskId: result.taskId,
+        subagentId: result.subagentId
+      });
+      return;
+    }
+    const subagent = this.subagents.get(result.subagentId);
+    if (subagent && subagent.status !== "stopped") {
+      result.status === "failed" || result.status === "timeout";
+      subagent.status = "idle";
+      subagent.currentTask = void 0;
+      if (subagent.abortController.signal.aborted) {
+        subagent.abortController = new AbortController();
+      }
+    }
+    this.terminating.delete(result.subagentId);
+    this.emit("task.completed", {
+      task: subagent?.context.tasks.find((t) => t.id === result.taskId) ?? { id: result.taskId },
+      result
+    });
+    this.tryDispatchNext();
+    if (this.isDone()) {
+      this.emit("done", {
+        results: this.completedResults,
+        totalIterations: this.totalIterations
+      });
+    }
+  }
+  isDone() {
+    if (this.config.doneCondition.type === "all_tasks_done") {
+      return this.pendingTasks.length === 0 && this.inFlight === 0;
+    }
+    if (this.config.doneCondition.maxIterations !== void 0 && this.totalIterations >= this.config.doneCondition.maxIterations) {
+      return true;
+    }
+    return false;
+  }
+};
+function classifySubagentError(err, hints = {}) {
+  const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
+  if (err instanceof ProviderError) {
+    const baseMessage2 = err.describe();
+    return providerErrorToSubagentError(err, baseMessage2, cause);
+  }
+  const baseMessage = err instanceof Error ? err.message : String(err);
+  if (err instanceof BudgetExceededError) {
+    const map = {
+      iterations: "budget_iterations",
+      tool_calls: "budget_tool_calls",
+      tokens: "budget_tokens",
+      cost: "budget_cost",
+      timeout: "budget_timeout"
+    };
+    return {
+      kind: map[err.kind],
+      message: baseMessage,
+      // Budgets are user-configured ceilings, not transient failures —
+      // retrying with the same budget will hit the same ceiling. The
+      // orchestrator must raise the budget or narrow the task first.
+      retryable: false,
+      cause
+    };
+  }
+  if (hints.parentAborted) {
+    return {
+      kind: "aborted_by_parent",
+      message: baseMessage,
+      retryable: false,
+      cause
+    };
+  }
+  const lower = baseMessage.toLowerCase();
+  if (/agent aborted$/i.test(baseMessage)) {
+    return {
+      kind: "aborted_by_parent",
+      message: baseMessage,
+      retryable: false,
+      cause
+    };
+  }
+  if (/agent exhausted iteration limit$/i.test(baseMessage)) {
+    return { kind: "budget_iterations", message: baseMessage, retryable: false, cause };
+  }
+  if (/empty response$/i.test(baseMessage)) {
+    return { kind: "empty_response", message: baseMessage, retryable: false, cause };
+  }
+  if (/^tool failed: /i.test(baseMessage)) {
+    return { kind: "tool_failed", message: baseMessage, retryable: false, cause };
+  }
+  if (lower.includes("bridge transport") || /bridge.*(closed|disconnect)/i.test(baseMessage)) {
+    return { kind: "bridge_failed", message: baseMessage, retryable: false, cause };
+  }
+  if (/context length|max.*tokens?.*exceeded|prompt is too long/i.test(baseMessage)) {
+    return { kind: "context_overflow", message: baseMessage, retryable: false, cause };
+  }
+  return {
+    kind: "unknown",
+    message: baseMessage,
+    retryable: false,
+    cause
+  };
+}
+function providerErrorToSubagentError(err, message, cause) {
+  const status = err.status;
+  if (status === 429 || err.body?.type === "rate_limit_error") {
+    return {
+      kind: "provider_rate_limit",
+      message,
+      retryable: true,
+      // Conservative default: 5s. Provider-specific code can override
+      // by emitting an error whose body carries an explicit hint.
+      backoffMs: 5e3,
+      cause
+    };
+  }
+  if (status === 401 || status === 403 || err.body?.type === "authentication_error") {
+    return { kind: "provider_auth", message, retryable: false, cause };
+  }
+  if (status === 408 || status === 0) {
+    return { kind: "provider_timeout", message, retryable: true, cause };
+  }
+  if (status >= 500 && status < 600) {
+    return {
+      kind: "provider_5xx",
+      message,
+      retryable: true,
+      backoffMs: 3e3,
+      cause
+    };
+  }
+  return { kind: "unknown", message, retryable: err.retryable, cause };
+}
+
+// src/sdd/sdd-parallel-run.ts
+var SddParallelRun = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
+    this.timeoutMs = opts.taskTimeoutMs ?? 3e5;
+    this.decomposer = new SddTaskDecomposer(opts.tracker, opts.graph, { parallelSlots: this.slots });
+  }
+  opts;
+  slots;
+  timeoutMs;
+  decomposer;
+  coordinator = null;
+  stopRequested = false;
+  // -------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------
+  /** Trigger stop — causes run() to abort after the current wave. */
+  stop() {
+    this.stopRequested = true;
+    this.coordinator?.stopAll();
+  }
+  /** Execute all waves until completion or deadlock. Returns final summary. */
+  async run() {
+    this.stopRequested = false;
+    const startTime = Date.now();
+    let totalCompleted = 0;
+    let totalFailed = 0;
+    let totalWaves = 0;
+    this.buildCoordinator();
+    while (!this.stopRequested && !this.decomposer.isDone()) {
+      const batch = this.decomposer.nextBatch();
+      if (batch.deadlocked) {
+        break;
+      }
+      if (batch.tasks.length === 0 && batch.allDone) {
+        break;
+      }
+      const waveResult = await this.executeWave(batch);
+      totalWaves++;
+      totalCompleted += waveResult.successCount;
+      totalFailed += waveResult.failCount;
+      this.decomposer.acknowledgeBatch(batch.tasks.map((t) => t.id));
+      this.opts.onWave?.(waveResult);
+      const progress = this.buildProgress();
+      this.opts.onProgress?.(progress);
+      if (this.stopRequested) break;
+    }
+    const finalProgress = this.opts.tracker.getProgress();
+    return {
+      totalWaves,
+      totalCompleted,
+      totalFailed,
+      totalDurationMs: Date.now() - startTime,
+      deadlocked: !this.decomposer.isDone() && this.stopRequested === false,
+      stopRequested: this.stopRequested,
+      finalProgress
+    };
+  }
+  // -------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------
+  buildCoordinator() {
+    const config = {
+      coordinatorId: `sdd-parallel-${randomUUID().slice(0, 8)}`,
+      maxConcurrent: this.slots,
+      doneCondition: { type: "all_tasks_done" }
+    };
+    this.coordinator = new DefaultMultiAgentCoordinator(config);
+    const runner = makeAgentSubagentRunner({ factory: this.opts.subagentFactory ?? this.defaultFactory() });
+    this.coordinator.setRunner?.(runner);
+  }
+  defaultFactory() {
+    return async (config) => ({
+      agent: this.opts.agent,
+      events: this.opts.agent.events
+    });
+  }
+  async executeWave(batch) {
+    const wave = batch.wave;
+    const tasks = batch.tasks;
+    const waveStart = Date.now();
+    for (const task of tasks) {
+      this.opts.tracker.updateNodeStatus(task.id, "in_progress");
+    }
+    const progress = computeTaskProgress(this.opts.graph);
+    const taskIds = tasks.map(() => randomUUID());
+    const subagentIds = tasks.map((_, i) => `sdd-wave${wave}-${i}`);
+    const directivePreamble = [
+      "\u2550\u2550\u2550 SDD PARALLEL EXECUTION \u2550\u2550\u2550",
+      "",
+      `Wave ${wave + 1} of ~${Math.ceil(progress.total / this.slots)}`,
+      `Graph: ${this.opts.graph.title}`,
+      `Parallel slots: ${tasks.length}`,
+      "",
+      "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+      "\u2022 Execute the assigned SDD task end-to-end using multiple tool calls.",
+      "\u2022 Mark the task [done] in the tracker when complete.",
+      "\u2022 Do not ask for confirmation.",
+      "\u2022 Keep output concise \u2014 summarize changes, do not transcribe files."
+    ].join("\n");
+    const spawns = subagentIds.map(
+      (subagentId) => this.coordinator.spawn({
+        id: subagentId,
+        name: subagentId,
+        role: "executor",
+        timeoutMs: this.timeoutMs
+      })
+    );
+    const spawnResults = await Promise.all(spawns);
+    if (!spawnResults.every((r) => r.subagentId)) {
+      throw new Error("One or more subagent spawns failed");
+    }
+    const assignPromises = tasks.map((task, i) => {
+      const spec = {
+        id: taskIds[i],
+        description: [
+          directivePreamble,
+          "",
+          `\u2500\u2500 TASK ${i + 1}/${tasks.length} \u2500\u2500`,
+          `[${task.priority.toUpperCase()}] ${task.title}`,
+          "",
+          task.description
+        ].join("\n"),
+        subagentId: subagentIds[i],
+        timeoutMs: this.timeoutMs
+      };
+      return this.coordinator.assign(spec);
+    });
+    await Promise.all(assignPromises);
+    let results;
+    try {
+      results = await this.coordinator.awaitTasks(taskIds);
+    } catch (err) {
+      results = taskIds.map((id) => ({
+        subagentId: "",
+        taskId: id,
+        status: "failed",
+        error: { kind: "unknown", message: String(err), retryable: false },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      }));
+    }
+    const successCount = results.filter((r) => r.status === "success").length;
+    const failCount = results.length - successCount;
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const taskId = taskIds[i];
+      if (result.status === "success") {
+        this.opts.tracker.updateNodeStatus(taskId, "completed");
+      } else {
+        const errMsg = result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error";
+        this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
+      }
+    }
+    return {
+      wave,
+      batch,
+      results,
+      successCount,
+      failCount,
+      durationMs: Date.now() - waveStart,
+      stopRequested: this.stopRequested
+    };
+  }
+  buildProgress() {
+    const gp = this.opts.tracker.getProgress();
+    return {
+      wave: this.decomposer.getWaveCount(),
+      total: gp.total,
+      completed: gp.completed,
+      inProgress: gp.inProgress,
+      failed: gp.failed,
+      blocked: gp.blocked,
+      pending: gp.pending,
+      percent: gp.percentComplete,
+      deadlocked: false
+    };
+  }
+};
+
+export { AISpecBuilder, AutoExecutor, DefaultTaskStore, SPEC_TEMPLATES, SddParallelRun, SddTaskDecomposer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, analyzeCriticalPath, createAutoExecutor, getTemplate, listTemplates, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, templateToMarkdown };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map