@wrongstack/core 0.6.7 → 0.7.2

package/dist/index.js

@@ -106,6 +106,53 @@ var init_atomic_write = __esm({
 });
 
 // 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",
+  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
+  // Tool
+  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
+  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
+  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
+  TOOL_TIMEOUT: "TOOL_TIMEOUT",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  // Config
+  CONFIG_INVALID: "CONFIG_INVALID",
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
+  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
+  // Plugin
+  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
+  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
+  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // Session
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_CORRUPTED: "SESSION_CORRUPTED",
+  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
+  // Container / Registry
+  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
+  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
+  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_WRITE_FAILED: "FS_WRITE_FAILED",
+  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
+  FS_DELETE_FAILED: "FS_DELETE_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
+  // General
+  UNKNOWN: "UNKNOWN"
+};
 var WrongStackError = class extends Error {
   code;
   subsystem;
@@ -171,7 +218,7 @@ var PluginError = class extends WrongStackError {
       code: opts.code,
       subsystem: "plugin",
       severity: "error",
-      recoverable: opts.code === "PLUGIN_MISSING_DEPENDENCY",
+      recoverable: opts.code === ERROR_CODES.PLUGIN_MISSING_DEPENDENCY,
       context: { plugin: opts.pluginName, ...opts.context },
       cause: opts.cause
     });
@@ -185,20 +232,20 @@ var AgentError = class extends WrongStackError {
       message: opts.message,
       code: opts.code,
       subsystem: "agent",
-      severity: opts.code === "AGENT_ABORTED" ? "warning" : "error",
-      recoverable: opts.recoverable ?? opts.code === "AGENT_ITERATION_LIMIT",
+      severity: opts.code === ERROR_CODES.AGENT_ABORTED ? "warning" : "error",
+      recoverable: opts.recoverable ?? opts.code === ERROR_CODES.AGENT_ITERATION_LIMIT,
       context: opts.context,
       cause: opts.cause
     });
     this.name = "AgentError";
   }
 };
-function toWrongStackError(err, code = "AGENT_RUN_FAILED") {
+function toWrongStackError(err, code = ERROR_CODES.AGENT_RUN_FAILED) {
   if (err instanceof WrongStackError) return err;
   const message = err instanceof Error ? err.message : String(err);
   return new AgentError({
     message,
-    code: code === "UNKNOWN" ? "AGENT_RUN_FAILED" : code,
+    code: code === "UNKNOWN" ? ERROR_CODES.AGENT_RUN_FAILED : code,
     cause: err
   });
 }
@@ -209,8 +256,8 @@ var SessionError = class extends WrongStackError {
       message: opts.message,
       code: opts.code,
       subsystem: "session",
-      severity: opts.code === "SESSION_WRITE_FAILED" ? "error" : "warning",
-      recoverable: opts.code !== "SESSION_CORRUPTED",
+      severity: opts.code === ERROR_CODES.SESSION_WRITE_FAILED ? "error" : "warning",
+      recoverable: opts.code !== ERROR_CODES.SESSION_CORRUPTED,
       context: { sessionId: opts.sessionId, ...opts.context },
       cause: opts.cause
     });
@@ -218,6 +265,22 @@ var SessionError = class extends WrongStackError {
     this.sessionId = opts.sessionId;
   }
 };
+var FsError = class extends WrongStackError {
+  path;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "fs",
+      severity: "error",
+      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
+      context: { path: opts.path, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FsError";
+    this.path = opts.path;
+  }
+};
 function isWrongStackError(err) {
   return err instanceof WrongStackError;
 }
@@ -236,6 +299,9 @@ function isSessionError(err) {
 function isAgentError(err) {
   return err instanceof AgentError;
 }
+function isFsError(err) {
+  return err instanceof FsError;
+}
 
 // src/kernel/container.ts
 var Container = class {
@@ -244,7 +310,7 @@ var Container = class {
     if (this.entries.has(token)) {
       throw new WrongStackError({
         message: `Container: token "${token.description ?? "unknown"}" already bound`,
-        code: "CONTAINER_TOKEN_ALREADY_BOUND",
+        code: ERROR_CODES.CONTAINER_TOKEN_ALREADY_BOUND,
         subsystem: "container",
         context: { token: token.description }
       });
@@ -261,7 +327,7 @@ var Container = class {
     if (!existing) {
       throw new WrongStackError({
         message: `Container: cannot override "${token.description ?? "unknown"}" \u2014 not bound`,
-        code: "CONTAINER_TOKEN_NOT_BOUND",
+        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
         subsystem: "container",
         context: { token: token.description }
       });
@@ -278,7 +344,7 @@ var Container = class {
     if (!existing) {
       throw new WrongStackError({
         message: `Container: cannot decorate "${token.description ?? "unknown"}" \u2014 not bound`,
-        code: "CONTAINER_TOKEN_NOT_BOUND",
+        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
         subsystem: "container",
         context: { token: token.description }
       });
@@ -292,7 +358,7 @@ var Container = class {
     if (!entry) {
       throw new WrongStackError({
         message: `Container: token "${token.description ?? "unknown"}" not bound`,
-        code: "CONTAINER_TOKEN_NOT_BOUND",
+        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
         subsystem: "container",
         context: { token: token.description }
       });
@@ -600,6 +666,18 @@ var EventBus = class {
   wildcardCount() {
     return this.wildcards.length;
   }
+  /**
+   * True if anything would receive an emit for `event` — a named listener
+   * OR a wildcard/regex pattern that matches the event name. Unlike
+   * `listenerCount`, this DOES account for wildcards, so callers that gate
+   * behavior on "is anyone listening?" (e.g. SubagentBudget deciding whether
+   * to negotiate a soft limit vs hard-stop) don't misfire when the only
+   * subscriber is a pattern listener like the FleetBus's `onPattern('*')`.
+   */
+  hasListenerFor(event) {
+    if ((this.listeners.get(event)?.size ?? 0) > 0) return true;
+    return this.wildcards.some((w) => w.match(event));
+  }
 };
 var ScopedEventBus = class extends EventBus {
   // Track registrations by a unique counter key so that EventBus.once()'s
@@ -895,16 +973,30 @@ function truncate(s, n) {
   return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
 }
 function providerStatusToCode(status, type) {
-  if (status === 0) return "PROVIDER_NETWORK_ERROR";
-  if (type === "rate_limit_error" || status === 429) return "PROVIDER_RATE_LIMITED";
-  if (type === "authentication_error" || status === 401) return "PROVIDER_AUTH_FAILED";
-  if (type === "overloaded_error" || status === 529) return "PROVIDER_OVERLOADED";
-  if (type === "invalid_request_error" || status === 400) return "PROVIDER_INVALID_REQUEST";
-  if (status === 408) return "PROVIDER_NETWORK_ERROR";
-  if (status >= 500) return "PROVIDER_SERVER_ERROR";
-  return "PROVIDER_INVALID_REQUEST";
+  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/types/default-config.ts
+var DEFAULT_TOOLS_CONFIG = Object.freeze({
+  defaultExecutionStrategy: "smart",
+  maxIterations: 100,
+  iterationTimeoutMs: 3e5,
+  sessionTimeoutMs: 18e5,
+  perIterationOutputCapBytes: 1e5,
+  autoExtendLimit: true
+});
+var DEFAULT_CONTEXT_CONFIG = Object.freeze({
+  preserveK: 10,
+  eliseThreshold: 2e3
+});
+
 // src/types/secret-vault.ts
 var ENCRYPTED_PREFIX = "enc:v1:";
 
@@ -1230,6 +1322,7 @@ function formatCtx(ctx) {
 }
 
 // src/infrastructure/token-counter.ts
+var PRICE_CACHE_MAX_SIZE = 100;
 var DefaultTokenCounter = class {
   input = 0;
   output = 0;
@@ -1260,6 +1353,10 @@ var DefaultTokenCounter = class {
     if (price) {
       this.applyPrice(usage, price);
     } else if (this.registry && this.providerId && model) {
+      if (this.priceCache.size >= PRICE_CACHE_MAX_SIZE) {
+        const keys = [...this.priceCache.keys()];
+        this.priceCache.delete(keys[0]);
+      }
       void this.registry.getModel(this.providerId, model).then((m) => {
         if (m) {
           const p = priceFromModel(m);
@@ -1281,6 +1378,10 @@ var DefaultTokenCounter = class {
     this.lastInput = usage.input;
     this.lastCacheRead = usage.cacheRead ?? 0;
     const price = priceFromModel(resolved);
+    if (this.priceCache.size >= PRICE_CACHE_MAX_SIZE) {
+      const keys = [...this.priceCache.keys()];
+      this.priceCache.delete(keys[0]);
+    }
     this.priceCache.set(resolved.modelId, price);
     this.applyPrice(usage, price);
   }
@@ -1736,9 +1837,11 @@ var DefaultPathResolver = class {
   }
 };
 
+// src/execution/regex-patterns.ts
+var NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
+
 // src/execution/error-handler.ts
 var CONTEXT_OVERFLOW_RE = /context|too long|tokens/i;
-var NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
 function buildRecoveryStrategies(opts) {
   return [
     {
@@ -1845,15 +1948,14 @@ var DefaultErrorHandler = class {
 };
 
 // src/execution/retry-policy.ts
-var DefaultRetryPolicy = class _DefaultRetryPolicy {
-  static NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
+var DefaultRetryPolicy = class {
   shouldRetry(err, attempt) {
     if (err instanceof ProviderError) {
       if (!err.retryable) return false;
       return attempt < this.maxAttempts(err);
     }
     const msg = err.message ?? "";
-    const isNetwork = _DefaultRetryPolicy.NETWORK_ERR_RE.test(msg);
+    const isNetwork = NETWORK_ERR_RE.test(msg);
     if (isNetwork) return attempt < 2;
     return false;
   }
@@ -2789,6 +2891,11 @@ var ToolExecutor = class {
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
+      if (hasMalformedArguments(use.input)) {
+        const result = this.malformedInputResult(use);
+        budget = this.decrementBudget(result, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
       const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
       if (decision.permission === "deny") {
         const result = this.deniedResult(use, decision.reason);
@@ -2992,6 +3099,14 @@ var ToolExecutor = class {
       is_error: true
     };
   }
+  malformedInputResult(use) {
+    return {
+      type: "tool_result",
+      tool_use_id: use.id,
+      content: `Tool "${use.name}" received arguments that were not a valid JSON object, so they could not be parsed. Re-issue the call with the arguments encoded as a single well-formed JSON object matching the tool's input schema.`,
+      is_error: true
+    };
+  }
   deniedResult(use, reason) {
     return {
       type: "tool_result",
@@ -3037,6 +3152,13 @@ var ToolExecutor = class {
     return void 0;
   }
 };
+var MALFORMED_ARG_MARKERS = ["__raw", "__raw_arguments", "_raw"];
+function hasMalformedArguments(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return false;
+  const obj = input;
+  const keys = Object.keys(obj);
+  return keys.length === 1 && MALFORMED_ARG_MARKERS.includes(keys[0]);
+}
 
 // src/utils/regex-guard.ts
 var MAX_PATTERN_LEN = 512;
@@ -3922,8 +4044,16 @@ var DefaultSessionStore = class {
     }
   }
   async resume(id) {
-    const data = await this.load(id);
     const file = path6.join(this.dir, `${id}.jsonl`);
+    try {
+      await fsp2.access(file, fsp2.constants.R_OK);
+    } catch {
+      throw new Error(
+        `Session "${id}" not found \u2014 the session file does not exist or was deleted.`,
+        { cause: new Error("ENOENT") }
+      );
+    }
+    const data = await this.load(id);
     let handle;
     try {
       handle = await fsp2.open(file, "a", 384);
@@ -4820,16 +4950,16 @@ var BEHAVIOR_DEFAULTS = {
     softThreshold: 0.75,
     hardThreshold: 0.9,
     autoCompact: true,
-    preserveK: 10,
-    eliseThreshold: 2e3
+    preserveK: DEFAULT_CONTEXT_CONFIG.preserveK,
+    eliseThreshold: DEFAULT_CONTEXT_CONFIG.eliseThreshold
   },
   tools: {
-    defaultExecutionStrategy: "smart",
-    maxIterations: 100,
-    iterationTimeoutMs: 3e5,
-    sessionTimeoutMs: 18e5,
-    perIterationOutputCapBytes: 1e5,
-    autoExtendLimit: true
+    defaultExecutionStrategy: DEFAULT_TOOLS_CONFIG.defaultExecutionStrategy,
+    maxIterations: DEFAULT_TOOLS_CONFIG.maxIterations,
+    iterationTimeoutMs: DEFAULT_TOOLS_CONFIG.iterationTimeoutMs,
+    sessionTimeoutMs: DEFAULT_TOOLS_CONFIG.sessionTimeoutMs,
+    perIterationOutputCapBytes: DEFAULT_TOOLS_CONFIG.perIterationOutputCapBytes,
+    autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit
   },
   log: { level: "info" },
   features: {
@@ -4843,19 +4973,23 @@ var BEHAVIOR_DEFAULTS = {
 var ENV_MAP = {
   WRONGSTACK_PROVIDER: (c, v) => {
     c.provider = v;
-    (c._envSource ??= /* @__PURE__ */ new Set()).add("provider");
+    if (c._envSource === void 0) c._envSource = /* @__PURE__ */ new Set();
+    c._envSource.add("provider");
   },
   WRONGSTACK_MODEL: (c, v) => {
     c.model = v;
-    (c._envSource ??= /* @__PURE__ */ new Set()).add("model");
+    if (c._envSource === void 0) c._envSource = /* @__PURE__ */ new Set();
+    c._envSource.add("model");
   },
   WRONGSTACK_API_KEY: (c, v) => {
     c.apiKey = v;
-    (c._envSource ??= /* @__PURE__ */ new Set()).add("apiKey");
+    if (c._envSource === void 0) c._envSource = /* @__PURE__ */ new Set();
+    c._envSource.add("apiKey");
   },
   WRONGSTACK_BASE_URL: (c, v) => {
     c.baseUrl = v;
-    (c._envSource ??= /* @__PURE__ */ new Set()).add("baseUrl");
+    if (c._envSource === void 0) c._envSource = /* @__PURE__ */ new Set();
+    c._envSource.add("baseUrl");
   },
   WRONGSTACK_LOG_LEVEL: (c, v) => {
     if (!c.log) c.log = { level: "info" };
@@ -6521,7 +6655,8 @@ var IntelligentCompactor = class {
     } catch {
       const toolNames = /* @__PURE__ */ new Set();
       const filePaths = /* @__PURE__ */ new Set();
-      let userTurns = 0, assistantTurns = 0;
+      let userTurns = 0;
+      let assistantTurns = 0;
       for (const m of toSummarize) {
         if (m.role === "user") userTurns++;
         else if (m.role === "assistant") {
@@ -7079,12 +7214,12 @@ Summarize the following message range:`;
     return total;
   }
   roughTokenEstimate(text) {
-    return Math.max(1, Math.ceil(text.length / 4));
+    return Math.max(1, Math.ceil(text.length / 3.5));
   }
 };
 
 // src/execution/auto-compaction-middleware.ts
-var AutoCompactionMiddleware = class {
+var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
   estimator;
@@ -7097,6 +7232,13 @@ var AutoCompactionMiddleware = class {
   events;
   failureMode;
   policyProvider;
+  /**
+   * Overhead factor applied to the rough message-token estimate to produce a
+   * figure comparable to the real API request size (system prompt + tool defs).
+   * Without this factor, raw message tokens undercount real load by 15-50% in
+   * short conversations, causing premature compaction triggers.
+   */
+  static OVERHEAD_FACTOR = 1.3;
   /**
    * @param compactor        Compactor to use for compaction.
    * @param maxContext       Provider's max context window in tokens.
@@ -7128,7 +7270,8 @@ var AutoCompactionMiddleware = class {
   }
   handler() {
     return async (ctx, next) => {
-      const tokens = this.estimator(ctx);
+      const rawTokens = this.estimator(ctx);
+      const tokens = Math.ceil(rawTokens * _AutoCompactionMiddleware.OVERHEAD_FACTOR);
       const load = tokens / this._maxContext;
       const policy = this.policyProvider?.(ctx);
       const thresholds = policy?.thresholds ?? {
@@ -7158,6 +7301,7 @@ var AutoCompactionMiddleware = class {
         report,
         aggressive
       });
+      ctx.clearFileTracking();
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
       const fatal = this.failureMode === "throw" || this.failureMode === "throw_on_hard" && pressure.level === "hard";
@@ -7173,7 +7317,7 @@ var AutoCompactionMiddleware = class {
       if (fatal) {
         throw new AgentError({
           message: `Auto-compaction failed at ${pressure.level} threshold`,
-          code: "AGENT_CONTEXT_OVERFLOW",
+          code: ERROR_CODES.AGENT_CONTEXT_OVERFLOW,
           recoverable: true,
           context: {
             level: pressure.level,
@@ -7376,7 +7520,16 @@ async function loadGoal(filePath) {
   }
 }
 async function saveGoal(filePath, goal) {
-  await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+  try {
+    await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+  } catch (err) {
+    throw new FsError({
+      message: err instanceof Error ? err.message : String(err),
+      code: ERROR_CODES.FS_ATOMIC_WRITE_FAILED,
+      path: filePath,
+      cause: err
+    });
+  }
 }
 function emptyGoal(goal) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -7591,7 +7744,7 @@ var EternalAutonomyEngine = class {
           // Cap the inner loop so a runaway agent.run can't burn through
           // the iteration timeout — the engine's own outer loop is the
           // long-running thing, each tick should be bounded.
-          maxIterations: this.opts.iterationMaxAgentSteps ?? 50
+          maxIterations: this.opts.iterationMaxAgentSteps ?? 500
         }
       );
       if (result.status === "aborted") {
@@ -7927,7 +8080,7 @@ ${recentJournal}` : "No prior iterations.",
     const cap = this.opts.transientBackoffMaxMs ?? 6e4;
     if (base <= 0) return 0;
     const exponent = Math.max(0, this.consecutiveTransientRetries - 1);
-    return Math.min(cap, base * Math.pow(2, exponent));
+    return Math.min(cap, base * 2 ** exponent);
   }
   /**
    * Sleep that wakes early if `stopRequested` flips. Polls every 250 ms
@@ -8096,7 +8249,7 @@ var SubagentBudget = class _SubagentBudget {
     this._onThreshold = fn;
   }
   constructor(limits = {}) {
-    this.limits = Object.freeze({ ...limits });
+    this.limits = { ...limits };
   }
   start() {
     this.startTime = Date.now();
@@ -8122,7 +8275,7 @@ var SubagentBudget = class _SubagentBudget {
       throw new BudgetExceededError(kind, limit, used);
     }
     const bus = this._events;
-    if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
       throw new BudgetExceededError(kind, limit, used);
     }
     if (this.pendingExtensions.has(kind)) return;
@@ -8153,7 +8306,7 @@ var SubagentBudget = class _SubagentBudget {
         // Director would leave the budget permanently in "asking" state.
         requestDecision: () => {
           const bus = this._events;
-          if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+          if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
             return Promise.resolve("stop");
           }
           return new Promise((resolve5) => {
@@ -8393,47 +8546,2345 @@ function makeAgentSubagentRunner(opts) {
         }
       }
     }
-    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 (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/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"
+      ]
     }
-    if (result.status === "failed") {
-      throw result.error instanceof Error ? result.error : new Error(String(result.error ?? "agent failed"));
+  },
+  {
+    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"
+      ]
     }
-    if (result.status === "aborted") {
-      throw new Error("agent aborted");
+  },
+  {
+    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"
+      ]
     }
-    if (result.status === "max_iterations") {
-      throw new Error("agent exhausted iteration limit");
+  },
+  {
+    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"
+      ]
     }
-    const usage = ctx.budget.usage();
-    const finalText = (result.finalText ?? "").trim();
-    if (finalText.length === 0 && usage.toolCalls === 0) {
-      throw new Error("empty response");
+  },
+  {
+    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"
+      ]
     }
-    if (finalText.length === 0 && lastToolFailed !== null) {
-      throw new Error(`tool failed: ${lastToolFailed}`);
+  }
+];
+
+// 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
+];
+var AGENTS_BY_PHASE = {
+  discovery: DISCOVERY_AGENTS,
+  planning: PLANNING_AGENTS,
+  build: BUILD_AGENTS,
+  verify: VERIFY_AGENTS,
+  review: REVIEW_AGENTS,
+  domain: DOMAIN_AGENTS,
+  knowledge: KNOWLEDGE_AGENTS,
+  delivery: DELIVERY_AGENTS,
+  meta: META_AGENTS
+};
+var AGENT_CATALOG = (() => {
+  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;
+})();
+function getAgentDefinition(role) {
+  return AGENT_CATALOG[role];
+}
+
+// src/coordination/dispatcher.ts
+var DEFAULT_DISPATCH_ROLE = "executor";
+function normalize2(text) {
+  return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
+}
+function scoreAgents(task, catalog = AGENT_CATALOG) {
+  const hay = normalize2(task);
+  const out = [];
+  for (const def of Object.values(catalog)) {
+    const role = def.config.role;
+    if (!role) continue;
+    let score = 0;
+    const matched = [];
+    for (const kw of def.capability.keywords) {
+      const needle = normalize2(kw);
+      if (hay.includes(needle.trimEnd() + " ") || hay.includes(" " + needle.trimStart())) {
+        const words = kw.trim().split(/\s+/).length;
+        score += words;
+        matched.push(kw);
+      }
+    }
+    if (score > 0) {
+      out.push({ role, name: def.config.name, score, matched });
+    }
+  }
+  out.sort((a, b) => b.score - a.score);
+  return out;
+}
+function heuristicConfidence(candidates) {
+  if (candidates.length === 0) return 0;
+  const top = candidates[0].score;
+  const second = candidates[1]?.score ?? 0;
+  const strength = Math.min(1, top / 3);
+  const margin = (top - second + 1) / (top + 1);
+  return Math.min(1, strength * margin);
+}
+async function dispatchAgent(task, opts = {}) {
+  const catalog = opts.catalog ?? AGENT_CATALOG;
+  const threshold = opts.confidenceThreshold ?? 0.4;
+  const maxCandidates = opts.maxCandidates ?? 6;
+  const candidates = scoreAgents(task, catalog);
+  const confidence = heuristicConfidence(candidates);
+  const top = candidates[0];
+  if (top && confidence >= threshold) {
     return {
-      result: result.finalText,
-      iterations: result.iterations,
-      toolCalls: usage.toolCalls
+      role: top.role,
+      definition: catalog[top.role],
+      confidence,
+      method: "heuristic",
+      reason: `Matched keywords: ${top.matched.slice(0, 4).join(", ")}`,
+      alternatives: candidates.slice(1, maxCandidates)
+    };
+  }
+  if (opts.classifier) {
+    const pool = (candidates.length > 0 ? candidates.slice(0, maxCandidates).map((c) => catalog[c.role]) : ALL_AGENT_DEFINITIONS).map((d) => ({
+      role: d.config.role,
+      name: d.config.name,
+      summary: d.capability.summary
+    }));
+    try {
+      const choice = await opts.classifier(task, pool);
+      if (choice && catalog[choice.role]) {
+        return {
+          role: choice.role,
+          definition: catalog[choice.role],
+          confidence: 1,
+          method: "llm",
+          reason: choice.reason ?? "Selected by LLM classifier",
+          alternatives: candidates.slice(0, maxCandidates).filter((c) => c.role !== choice.role)
+        };
+      }
+    } catch {
+    }
+  }
+  if (top) {
+    return {
+      role: top.role,
+      definition: catalog[top.role],
+      confidence,
+      method: "heuristic",
+      reason: `Weak match (${top.matched.slice(0, 3).join(", ") || "low signal"})`,
+      alternatives: candidates.slice(1, maxCandidates)
     };
+  }
+  const fallbackRole = catalog[DEFAULT_DISPATCH_ROLE] ? DEFAULT_DISPATCH_ROLE : Object.keys(catalog)[0];
+  return {
+    role: fallbackRole,
+    definition: catalog[fallbackRole],
+    confidence: 0,
+    method: "fallback",
+    reason: "No keyword signal; defaulting to the generalist Executor",
+    alternatives: []
   };
 }
-function defaultFormatTaskInput(task) {
-  return task.description ?? "";
+function makeLLMClassifier(complete) {
+  return async (task, candidates) => {
+    const list = candidates.map((c, i) => `${i + 1}. ${c.role} \u2014 ${c.summary}`).join("\n");
+    const prompt = `You are an agent router. Pick the single best agent for the task.
+
+Task:
+${task}
+
+Agents:
+${list}
+
+Reply with ONLY a compact JSON object: {"role":"<one role id from the list>","reason":"<short why>"}.
+Do not add prose, markdown, or code fences.`;
+    const raw = (await complete(prompt)).trim();
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) return null;
+    try {
+      const parsed = JSON.parse(match[0]);
+      if (typeof parsed.role !== "string") return null;
+      const role = parsed.role.trim();
+      const valid = candidates.some((c) => c.role === role);
+      if (!valid) return null;
+      return { role, reason: typeof parsed.reason === "string" ? parsed.reason : void 0 };
+    } catch {
+      return null;
+    }
+  };
 }
 
 // src/coordination/fleet.ts
@@ -8606,13 +11057,19 @@ var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
   "bug-hunter": BUG_HUNTER_AGENT,
   "refactor-planner": REFACTOR_PLANNER_AGENT,
-  "security-scanner": SECURITY_SCANNER_AGENT
+  "security-scanner": SECURITY_SCANNER_AGENT,
+  ...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 }
+  "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,
@@ -8633,6 +11090,67 @@ function applyRosterBudget(cfg) {
   };
 }
 var ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
+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 };
+({
+  ...FLEET_ROSTER,
+  ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
+});
 
 // src/coordination/multi-agent-coordinator.ts
 var DefaultMultiAgentCoordinator = class extends EventEmitter {
@@ -8739,6 +11257,32 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     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,
@@ -9187,6 +11731,8 @@ var ParallelEternalEngine = class {
     this.goalPath = goalFilePath(opts.projectRoot);
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
     this.timeoutMs = opts.iterationTimeoutMs ?? 3e5;
+    this.dispatchEnabled = opts.dispatch !== false;
+    this.dispatchClassifier = opts.dispatchClassifier;
     this.agentFactory = opts.subagentFactory ?? (async (config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
@@ -9203,9 +11749,17 @@ var ParallelEternalEngine = class {
   timeoutMs;
   coordinator = null;
   agentFactory;
+  dispatchEnabled;
+  dispatchClassifier;
   get currentState() {
     return this.state;
   }
+  /**
+   * Get the underlying coordinator for stats/monitoring.
+   */
+  getCoordinator() {
+    return this.coordinator;
+  }
   stop() {
     this.stopRequested = true;
     void this.persistState("stopped").catch(() => {
@@ -9285,9 +11839,10 @@ var ParallelEternalEngine = class {
       fanOut.goalComplete ? "[GOAL_COMPLETE]" : "",
       fanOut.partialOutput ? `Output: ${fanOut.partialOutput.slice(0, 120)}` : ""
     ].filter(Boolean).join(" | ");
+    const routeSummary = fanOut.routes.length > 0 ? fanOut.routes.slice(0, 3).map((r) => `${r.role}\u2192${r.task.slice(0, 28)}`).join(", ") : tasks.slice(0, 3).join(", ");
     await this.appendIterationEntry({
       source: "parallel",
-      task: `parallel:${tasks.length} slots \u2014 ${tasks.slice(0, 3).join(", ")}${tasks.length > 3 ? "..." : ""}`,
+      task: `parallel:${tasks.length} slots \u2014 ${routeSummary}${tasks.length > 3 ? "..." : ""}`,
       status,
       note
     });
@@ -9304,6 +11859,11 @@ var ParallelEternalEngine = class {
   async fanOut(goal, tasks) {
     const coordinator = this.coordinator;
     const slotCount = Math.min(this.slots, tasks.length);
+    const routes = this.dispatchEnabled ? await Promise.all(
+      tasks.slice(0, slotCount).map(
+        (t2) => dispatchAgent(t2, { classifier: this.dispatchClassifier }).catch(() => null)
+      )
+    ) : [];
     const recentJournal = goal.journal.slice(-5).map((e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`).join("\n");
     const directivePreamble = [
       "\u2550\u2550\u2550 ETERNAL AUTONOMY \u2014 parallel task slot \u2550\u2550\u2550",
@@ -9323,29 +11883,48 @@ ${recentJournal}` : "No prior iterations.",
     ].join("\n");
     const taskIds = [];
     const subagentIds = [];
+    const routeInfo = [];
     const spawnPromises = [];
     for (let i = 0; i < slotCount; i++) {
       const task = tasks[i];
+      const route = routes[i] ?? null;
       const subagentId = `parallel-${this.iterations}-${i}`;
       const taskId = randomUUID();
+      const personaLine = route ? `Acting agent: ${route.definition.config.name} \u2014 ${route.definition.capability.summary}
+` : "";
       const spec = {
         id: taskId,
         description: `${directivePreamble}
 
 \u2500\u2500 SLOT ${i + 1}/${slotCount} \u2500\u2500
-Task: ${task}
+${personaLine}Task: ${task}
 `,
         subagentId
       };
+      routeInfo.push({
+        slot: i,
+        task,
+        role: route?.role ?? "generic",
+        method: route?.method ?? "none"
+      });
       spawnPromises.push((async () => {
         try {
-          await coordinator.spawn({
-            id: subagentId,
-            name: `slot-${subagentId.slice(-6)}`,
-            maxIterations: 50,
-            maxToolCalls: 200,
-            timeoutMs: this.timeoutMs
-          });
+          await coordinator.spawn(
+            route ? {
+              id: subagentId,
+              name: route.definition.config.name,
+              role: route.role,
+              tools: route.definition.config.tools,
+              systemPromptOverride: route.definition.config.prompt,
+              timeoutMs: this.timeoutMs
+            } : {
+              id: subagentId,
+              name: `slot-${subagentId.slice(-6)}`,
+              // Let the coordinator apply its default budget (roster or generic).
+              // Hardcoding low limits here defeats the x10 budget improvement.
+              timeoutMs: this.timeoutMs
+            }
+          );
           subagentIds.push(subagentId);
           taskIds.push(taskId);
           await coordinator.assign(spec);
@@ -9355,12 +11934,12 @@ Task: ${task}
     }
     await Promise.all(spawnPromises);
     if (taskIds.length === 0) {
-      return { results: [], allSuccessful: false, goalComplete: false, partialOutput: "" };
+      return { results: [], allSuccessful: false, goalComplete: false, partialOutput: "", routes: routeInfo };
     }
     let results = [];
     try {
       const ctrl = new AbortController();
-      const timer = setTimeout(() => ctrl.abort(), this.timeoutMs + 6e4);
+      const timer = setTimeout(() => ctrl.abort(), Math.max(this.timeoutMs * 2, 72e5));
       try {
         results = await coordinator.awaitTasks(taskIds);
       } finally {
@@ -9374,7 +11953,7 @@ Task: ${task}
       (r) => r.status === "success" && typeof r.result === "string" && GOAL_COMPLETE_MARKER2.test(r.result)
     );
     const partialOutput = results.map((r) => typeof r.result === "string" ? r.result : "").filter(Boolean).join("\n\n");
-    return { results, allSuccessful, goalComplete, partialOutput };
+    return { results, allSuccessful, goalComplete, partialOutput, routes: routeInfo };
   }
   // -------------------------------------------------------------------------
   // Goal decomposition
@@ -10246,6 +12825,9 @@ var Director = class {
   /** Snapshot of which subagent owns each task — drives state-checkpoint
    *  status updates without re-walking the manifest. */
   taskOwners = /* @__PURE__ */ new Map();
+  /** Cumulative auto-extension grants per subagent (all budget kinds). Lets
+   *  /fleet render "⚡ extended ×N" without replaying the event stream. */
+  extendTotals = /* @__PURE__ */ new Map();
   /**
    * Handle to the coordinator-side `task.completed` listener so we can
    * unsubscribe in `shutdown()`. Without this, repeated Director
@@ -10341,8 +12923,28 @@ var Director = class {
     };
     this.coordinator.on("task.completed", this.taskCompletedListener);
     const extendCounts = /* @__PURE__ */ new Map();
+    const progressBySubagent = /* @__PURE__ */ new Map();
+    const lastTimeoutProgress = /* @__PURE__ */ new Map();
+    this.fleet.filter("tool.executed", (e) => {
+      progressBySubagent.set(e.subagentId, (progressBySubagent.get(e.subagentId) ?? 0) + 1);
+    });
     this.fleet.filter("budget.threshold_reached", (e) => {
       const payload = e.payload;
+      if (payload.kind === "timeout") {
+        const progress = progressBySubagent.get(e.subagentId) ?? 0;
+        const lastProgress = lastTimeoutProgress.get(e.subagentId) ?? -1;
+        if (progress <= lastProgress) {
+          payload.deny();
+          return;
+        }
+        lastTimeoutProgress.set(e.subagentId, progress);
+        setImmediate(() => {
+          const newLimit = Math.min(Math.ceil(payload.limit * 2), 24 * 60 * 6e4);
+          this.recordExtension(e.subagentId, e.taskId, "timeout", newLimit);
+          payload.extend({ timeoutMs: newLimit });
+        });
+        return;
+      }
       const guardKey = `${e.subagentId}:${payload.kind}`;
       const prior = extendCounts.get(guardKey) ?? 0;
       if (prior >= this.maxBudgetExtensions) {
@@ -10353,27 +12955,52 @@ var Director = class {
       extendCounts.set(guardKey, prior + 1);
       setImmediate(() => {
         const extra = {};
+        const base = Math.max(payload.limit, payload.used);
+        const grow = (ceiling) => Math.min(Math.ceil(base * 1.5), ceiling);
+        let newLimit = base;
         switch (payload.kind) {
           case "iterations":
-            extra.maxIterations = Math.min(payload.used + 100, 800);
+            newLimit = grow(5e4);
+            extra.maxIterations = newLimit;
             break;
           case "tool_calls":
-            extra.maxToolCalls = Math.min(Math.ceil(payload.limit * 2), 1500);
+            newLimit = grow(1e5);
+            extra.maxToolCalls = newLimit;
             break;
           case "tokens":
-            extra.maxTokens = Math.min(Math.ceil(payload.limit * 2), 8e5);
+            newLimit = grow(5e6);
+            extra.maxTokens = newLimit;
             break;
           case "cost":
-            extra.maxCostUsd = Math.min(payload.limit * 2, 25);
-            break;
-          case "timeout":
-            extra.timeoutMs = Math.min(Math.ceil(payload.limit * 2), 2 * 60 * 6e4);
+            newLimit = Math.min(base * 1.5, 100);
+            extra.maxCostUsd = newLimit;
             break;
         }
+        this.recordExtension(e.subagentId, e.taskId, payload.kind, newLimit);
         payload.extend(extra);
       });
     });
   }
+  /**
+   * Record a granted budget extension and broadcast it on the FleetBus so
+   * the host can re-emit `subagent.budget_extended` for live UI badges.
+   * Called from both the timeout heartbeat path and the per-kind grant path.
+   */
+  recordExtension(subagentId, taskId, kind, newLimit) {
+    const total = (this.extendTotals.get(subagentId) ?? 0) + 1;
+    this.extendTotals.set(subagentId, total);
+    this.fleet.emit({
+      subagentId,
+      taskId,
+      ts: Date.now(),
+      type: "budget.extended",
+      payload: { kind, newLimit, totalExtensions: total }
+    });
+  }
+  /** Cumulative auto-extension count for one subagent (0 when never extended). */
+  extensionsFor(subagentId) {
+    return this.extendTotals.get(subagentId) ?? 0;
+  }
   /** Best-effort session-writer append. Swallows failures — the director
    *  must not break a fleet run because the session JSONL handle closed. */
   async appendSessionEvent(event) {
@@ -10427,11 +13054,7 @@ var Director = class {
       }
     }
     let result;
-    try {
-      result = await this.coordinator.spawn(config);
-    } catch (err) {
-      throw err;
-    }
+    result = await this.coordinator.spawn(config);
     if (this.fleetManager) {
       this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
     } else {
@@ -10699,8 +13322,18 @@ var Director = class {
   async terminateAll() {
     await this.coordinator.stopAll();
   }
+  async remove(subagentId) {
+    await this.coordinator.remove(subagentId);
+  }
   status() {
-    return this.coordinator.getStatus();
+    const base = this.coordinator.getStatus();
+    return {
+      ...base,
+      subagents: base.subagents.map((s) => ({
+        ...s,
+        extensions: this.extendTotals.get(s.id) ?? 0
+      }))
+    };
   }
   /**
    * Subscribe to coordinator events. Currently only `task.completed` is
@@ -10984,9 +13617,8 @@ function createDelegateTool(opts) {
           cfg.maxToolCalls = i.maxToolCalls;
         }
         const SUBAGENT_TIMEOUT_BUFFER_MS = opts.subagentTimeoutBufferMs ?? 6e4;
-        const desiredSubTimeout = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
-        if (!cfg.timeoutMs || cfg.timeoutMs > desiredSubTimeout) {
-          cfg.timeoutMs = desiredSubTimeout;
+        if (!cfg.timeoutMs) {
+          cfg.timeoutMs = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
         }
         const subagentId = await director.spawn(cfg);
         const taskId = await director.assign({
@@ -10994,15 +13626,30 @@ function createDelegateTool(opts) {
           description: i.task,
           subagentId
         });
-        const result = await Promise.race([
-          director.awaitTasks([taskId]).then((r) => {
-            if (!r[0]) throw new Error(`Task "${taskId}" not found in completed results`);
-            return r[0];
-          }),
-          new Promise(
-            (resolve5) => setTimeout(() => resolve5({ __timeout: true }), timeoutMs)
-          )
-        ]);
+        const dir = director;
+        const result = await new Promise((resolve5) => {
+          let settled = false;
+          let timer;
+          const finish = (value) => {
+            if (settled) return;
+            settled = true;
+            if (timer) clearTimeout(timer);
+            offTool();
+            offIter();
+            resolve5(value);
+          };
+          const arm = () => {
+            if (timer) clearTimeout(timer);
+            timer = setTimeout(() => finish({ __timeout: true }), timeoutMs);
+          };
+          const bump = (e) => {
+            if (e.subagentId === subagentId) arm();
+          };
+          const offTool = dir.fleet.filter("tool.executed", bump);
+          const offIter = dir.fleet.filter("iteration.started", bump);
+          arm();
+          dir.awaitTasks([taskId]).then((r) => finish(r[0] ?? { __timeout: true })).catch(() => finish({ __timeout: true }));
+        });
         if ("__timeout" in result) {
           const partial2 = await readSubagentPartial(opts, subagentId);
           return {
@@ -11206,6 +13853,64 @@ function makeDirectorSessionFactory(opts) {
   };
 }
 
+// src/coordination/auto-extend.ts
+var DEFAULT_CEILING = {
+  maxIterations: 5e4,
+  maxToolCalls: 1e5,
+  maxTokens: 5e6,
+  maxCostUsd: 100,
+  timeoutMs: 24 * 60 * 60 * 1e3
+};
+var FIELD_BY_KIND = {
+  iterations: "maxIterations",
+  tool_calls: "maxToolCalls",
+  tokens: "maxTokens",
+  cost: "maxCostUsd",
+  timeout: "timeoutMs"
+};
+function attachAutoExtend(events, policy = {}) {
+  const factor = policy.factor ?? 0.5;
+  const maxPerKind = policy.maxExtensionsPerKind ?? 8;
+  const ceiling = { ...DEFAULT_CEILING, ...policy.ceiling };
+  const extendCounts = /* @__PURE__ */ new Map();
+  let progress = 0;
+  let lastTimeoutProgress = -1;
+  const unsubs = [
+    events.on("tool.executed", () => {
+      progress++;
+    }),
+    events.on("iteration.started", () => {
+      progress++;
+    }),
+    events.on("budget.threshold_reached", (e) => {
+      const { kind, limit, extend, deny } = e;
+      if (kind === "timeout") {
+        if (progress > lastTimeoutProgress) {
+          lastTimeoutProgress = progress;
+          const next2 = Math.min(Math.ceil(limit * (1 + factor)), ceiling.timeoutMs);
+          extend({ timeoutMs: next2 });
+        } else {
+          deny();
+        }
+        return;
+      }
+      const count = extendCounts.get(kind) ?? 0;
+      if (count >= maxPerKind) {
+        deny();
+        return;
+      }
+      extendCounts.set(kind, count + 1);
+      const field = FIELD_BY_KIND[kind];
+      const cap = ceiling[field];
+      const next = Math.min(Math.ceil(limit * (1 + factor)), cap);
+      extend({ [field]: next });
+    })
+  ];
+  return () => {
+    for (const u of unsubs) u();
+  };
+}
+
 // src/coordination/null-fleet-bus.ts
 var NULL_FLEET_BUS = new FleetBus();
 
@@ -14445,6 +17150,7 @@ function createContextManagerTool(opts = {}) {
             };
           }
           const report = await opts.compactor.compact(ctx);
+          ctx.clearFileTracking();
           const repair = applyMessages([...ctx.messages]);
           const afterTokens = repair.changed ? roughEstimate(ctx.messages) : report.after;
           const repaired = report.repaired ?? (repair.changed ? repair : void 0);
@@ -14473,6 +17179,7 @@ function createContextManagerTool(opts = {}) {
           }
           const copy = [...messages];
           const removed = copy.splice(from, to - from + 1);
+          ctx.clearFileTracking();
           const repair = applyMessages(copy);
           const afterTokens = roughEstimate(ctx.messages);
           return {
@@ -14530,6 +17237,7 @@ function createContextManagerTool(opts = {}) {
           };
           const copy = [...messages];
           copy.splice(from, to - from + 1, summaryMsg);
+          ctx.clearFileTracking();
           const repair = applyMessages(copy);
           const afterTokens = roughEstimate(ctx.messages);
           return {
@@ -15527,7 +18235,7 @@ var TechStackDetector = class {
     }
     for (const stack of stacks) {
       const indicators = MONOREPO_INDICATORS[stack.packageManager];
-      if (indicators && indicators.some((ind) => files.includes(ind) || dirs.includes(ind))) {
+      if (indicators?.some((ind) => files.includes(ind) || dirs.includes(ind))) {
         return true;
       }
     }
@@ -16284,8 +18992,10 @@ var ReportGenerator = class {
   groupByCategory(findings) {
     const groups = {};
     for (const finding of findings) {
-      const group = groups[finding.category] ?? (groups[finding.category] = []);
-      group.push(finding);
+      if (groups[finding.category] === void 0) {
+        groups[finding.category] = [];
+      }
+      groups[finding.category].push(finding);
     }
     return groups;
   }
@@ -16425,7 +19135,6 @@ var defaultGitignoreUpdater = new GitignoreUpdater();
 
 // src/security-scanner/orchestrator.ts
 init_atomic_write();
-var NETWORK_ERR_RE2 = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
 var SecurityScannerOrchestrator = class {
   constructor(retryPolicy, errorHandler) {
     this.retryPolicy = retryPolicy;
@@ -16448,7 +19157,7 @@ var SecurityScannerOrchestrator = class {
       const isProviderErr = err instanceof ProviderError;
       const policy = this.retryPolicy;
       const errAsErr = isProviderErr ? err : err instanceof Error ? err : new Error(String(err));
-      if (!policy || !isProviderErr && !NETWORK_ERR_RE2.test(errAsErr.message)) {
+      if (!policy || !isProviderErr && !NETWORK_ERR_RE.test(errAsErr.message)) {
         throw err;
       }
       const canRetry = policy.shouldRetry(errAsErr, attempt);
@@ -17104,8 +19813,8 @@ ${list}
 
 Use \`/security report <number>\` to view a specific report.` };
     }
-    const index = parseInt(reportId, 10) - 1;
-    if (!isNaN(index) && reports[index]) {
+    const index = Number.parseInt(reportId, 10) - 1;
+    if (!Number.isNaN(index) && reports[index]) {
       const { readFile: readFile30 } = await import('fs/promises');
       const content = await readFile30(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
@@ -17645,7 +20354,7 @@ var ExtensionRegistry = class {
     if (this.extensions.some((e) => e.name === ext.name)) {
       throw new WrongStackError({
         message: `Extension "${ext.name}" already registered`,
-        code: "REGISTRY_DUPLICATE",
+        code: ERROR_CODES.REGISTRY_DUPLICATE,
         subsystem: "container",
         context: { extension: ext.name }
       });
@@ -18651,6 +21360,13 @@ var Context = class {
     this.readFiles.add(absPath);
     this.fileMtimes.set(absPath, mtimeMs);
   }
+  /** Clear accumulated file-read metadata after compaction or at boundaries
+   *  where stale read history could cause tools to skip legitimate re-reads.
+   *  The agent re-populates this naturally on the next file access. */
+  clearFileTracking() {
+    this.readFiles.clear();
+    this.fileMtimes.clear();
+  }
   hasRead(absPath) {
     return this.readFiles.has(absPath);
   }
@@ -18743,6 +21459,16 @@ var InputBuilder = class {
     this.refs.push(ref);
     return placeholder;
   }
+  /**
+   * Whether `appendPaste(text)` would collapse the text to a placeholder
+   * (rather than inlining it). Lets a frontend decide where to route a paste
+   * — e.g. collapsed pastes become a pill, while inlined ones can be shown
+   * in the editable input row — without calling `appendPaste` first (which
+   * mutates the display buffer).
+   */
+  wouldCollapse(text) {
+    return this.shouldCollapse(text);
+  }
   /** Reset display and ref list. Does NOT clear the store itself. */
   reset() {
     this.display = "";
@@ -19210,7 +21936,7 @@ var ToolRegistry = class _ToolRegistry {
     if (this.tools.has(tool.name)) {
       throw new WrongStackError({
         message: `Tool "${tool.name}" already registered`,
-        code: "REGISTRY_DUPLICATE",
+        code: ERROR_CODES.REGISTRY_DUPLICATE,
         subsystem: "container",
         context: { tool: tool.name }
       });
@@ -19262,7 +21988,7 @@ var ToolRegistry = class _ToolRegistry {
     if (!this.tools.has(name)) {
       throw new WrongStackError({
         message: `Tool "${name}" not registered; cannot override`,
-        code: "REGISTRY_NOT_FOUND",
+        code: ERROR_CODES.REGISTRY_NOT_FOUND,
         subsystem: "container",
         context: { tool: name }
       });
@@ -19285,7 +22011,7 @@ var ToolRegistry = class _ToolRegistry {
     if (!entry) {
       throw new WrongStackError({
         message: `Tool "${name}" not registered; cannot wrap`,
-        code: "REGISTRY_NOT_FOUND",
+        code: ERROR_CODES.REGISTRY_NOT_FOUND,
         subsystem: "container",
         context: { tool: name }
       });
@@ -19667,7 +22393,7 @@ function topoSort(plugins) {
     if (visiting.has(p.name)) {
       throw new PluginError({
         message: `Plugin dependency cycle: ${[...stack, p.name].join(" -> ")}`,
-        code: "PLUGIN_LOAD_FAILED",
+        code: ERROR_CODES.PLUGIN_LOAD_FAILED,
         pluginName: p.name
       });
     }
@@ -19678,7 +22404,7 @@ function topoSort(plugins) {
       if (!d) {
         throw new PluginError({
           message: `Plugin "${p.name}" depends on missing plugin "${dep.name}"`,
-          code: "PLUGIN_MISSING_DEPENDENCY",
+          code: ERROR_CODES.PLUGIN_MISSING_DEPENDENCY,
           pluginName: p.name,
           context: { dependency: dep.name }
         });
@@ -19686,7 +22412,7 @@ function topoSort(plugins) {
       if (dep.version && d.version && !satisfies(dep.version, d.version)) {
         throw new PluginError({
           message: `Plugin "${p.name}" requires "${dep.name}@${dep.version}", found ${d.version}`,
-          code: "PLUGIN_LOAD_FAILED",
+          code: ERROR_CODES.PLUGIN_LOAD_FAILED,
           pluginName: p.name,
           context: { dependency: dep.name, required: dep.version, found: d.version }
         });
@@ -19700,7 +22426,7 @@ function topoSort(plugins) {
         if (dep.version && d.version && !satisfies(dep.version, d.version)) {
           throw new PluginError({
             message: `Plugin "${p.name}" optional dep "${dep.name}@${dep.version}" found ${d.version}`,
-            code: "PLUGIN_LOAD_FAILED",
+            code: ERROR_CODES.PLUGIN_LOAD_FAILED,
             pluginName: p.name,
             context: { dependency: dep.name, required: dep.version, found: d.version }
           });
@@ -19725,7 +22451,7 @@ async function loadPlugins(plugins, opts) {
       if (names.has(c)) {
         throw new PluginError({
           message: `Plugin "${p.name}" conflicts with loaded plugin "${c}"`,
-          code: "PLUGIN_LOAD_FAILED",
+          code: ERROR_CODES.PLUGIN_LOAD_FAILED,
           pluginName: p.name,
           context: { conflictsWith: c }
         });
@@ -19743,7 +22469,7 @@ async function loadPlugins(plugins, opts) {
     if (!satisfies(plugin.apiVersion, kernelVersion)) {
       const err = new PluginError({
         message: `Plugin "${plugin.name}" requires apiVersion ${plugin.apiVersion}; kernel is ${kernelVersion}`,
-        code: "PLUGIN_API_MISMATCH",
+        code: ERROR_CODES.PLUGIN_API_MISMATCH,
         pluginName: plugin.name,
         context: { required: plugin.apiVersion, kernel: kernelVersion }
       });
@@ -19765,7 +22491,7 @@ async function loadPlugins(plugins, opts) {
           const detail = firstErr ? `${firstErr.path}: ${firstErr.message}` : "config invalid";
           const err = new PluginError({
             message: `Plugin "${plugin.name}" config invalid \u2014 ${detail}`,
-            code: "PLUGIN_LOAD_FAILED",
+            code: ERROR_CODES.PLUGIN_LOAD_FAILED,
             pluginName: plugin.name,
             context: { errors: result.errors }
           });
@@ -19815,7 +22541,7 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
     if (enforce) {
       throw new PluginError({
         message: msg,
-        code: "PLUGIN_LOAD_FAILED",
+        code: ERROR_CODES.PLUGIN_LOAD_FAILED,
         pluginName: plugin.name,
         context: { subsystem, detail }
       });
@@ -19888,6 +22614,6 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   });
 }
 
-export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMcpControlTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, securitySlashCommand, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMcpControlTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeLLMClassifier, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map