@wrongstack/core 0.6.7 → 0.7.2

package/dist/defaults/index.js

@@ -348,8 +348,16 @@ var DefaultSessionStore = class {
     }
   }
   async resume(id) {
-    const data = await this.load(id);
     const file = path3.join(this.dir, `${id}.jsonl`);
+    try {
+      await fsp.access(file, fsp.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 fsp.open(file, "a", 384);
@@ -1303,6 +1311,20 @@ function safeParse(input, maxBytes = 5e6) {
   }
 }
 
+// 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/storage/config-loader.ts
 var BEHAVIOR_DEFAULTS = {
   version: 1,
@@ -1312,16 +1334,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: {
@@ -1335,19 +1357,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" };
@@ -3192,6 +3218,22 @@ var AutoApprovePermissionPolicy = class {
 };
 
 // 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",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED"};
 var WrongStackError = class extends Error {
   code;
   subsystem;
@@ -3226,23 +3268,39 @@ 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
   });
 }
+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;
+  }
+};
 
 // src/types/provider.ts
 var ProviderError = class extends WrongStackError {
@@ -3306,26 +3364,28 @@ 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/execution/regex-patterns.ts
+var NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
+
 // 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;
   }
@@ -3348,7 +3408,6 @@ var DefaultRetryPolicy = class _DefaultRetryPolicy {
 
 // 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 [
     {
@@ -4163,7 +4222,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") {
@@ -4721,12 +4781,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;
@@ -4739,6 +4799,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.
@@ -4770,7 +4837,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 ?? {
@@ -4800,6 +4868,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";
@@ -4815,7 +4884,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,
@@ -4910,6 +4979,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);
@@ -5113,6 +5187,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",
@@ -5158,6 +5240,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/execution/autonomous-runner.ts
 var DoneConditionChecker = class {
@@ -5348,7 +5437,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 appendJournal(goal, entry) {
   const iteration = goal.iterations + 1;
@@ -5506,7 +5604,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") {
@@ -5842,7 +5940,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
@@ -6011,7 +6109,7 @@ var SubagentBudget = class _SubagentBudget {
     this._onThreshold = fn;
   }
   constructor(limits = {}) {
-    this.limits = Object.freeze({ ...limits });
+    this.limits = { ...limits };
   }
   start() {
     this.startTime = Date.now();
@@ -6037,7 +6135,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;
@@ -6068,7 +6166,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((resolve2) => {
@@ -6351,203 +6449,2568 @@ function defaultFormatTaskInput(task) {
   return task.description ?? "";
 }
 
-// src/coordination/fleet.ts
-var AUDIT_LOG_AGENT = {
-  id: "audit-log",
-  name: "Audit Log",
-  role: "audit-log",
-  prompt: `You are the Audit Log agent. Your job is to analyze structured JSONL
-session logs and produce actionable markdown reports.
+// 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:
-- Parse session logs (iteration counts, tool calls, errors, usage)
-- Detect repeated failure patterns across multiple runs
-- Identify tool usage anomalies (over-use, failures, unexpected chains)
-- Track token consumption trends
-- Generate structured audit reports with severity ratings
+- 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": "analyze | report | trends", "sessionPath": "<path>", "focus": "errors | tools | usage | all" }
+{ "task": "map | locate | trace", "question": "<what to find>", "scope": ["packages/core"] }
 
-Output: Markdown audit report with sections:
-- ## Summary (totals, error rate)
-- ## Top Errors (count + context)
-- ## Tool Usage (table with calls, failures, avg duration)
-- ## Anomalies (pattern \u2192 severity)
+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:
-- Never fabricate numbers \u2014 read the actual logs first
-- Always include file:line references for errors
-- If sessionPath is missing, ask the director to provide it
-- Report confidence level: high (>90% accuracy), medium, low`
-  // No hardcoded budgets — the orchestrator (delegate tool or
-  // spawn_subagent) decides per-task how much room a subagent gets.
-  // A monorepo audit needs hours; a single-file lint check needs
-  // seconds. Pinning a number here forces the orchestrator to fight
-  // the role's default instead of just asking for what it needs.
-};
-var BUG_HUNTER_AGENT = {
-  id: "bug-hunter",
-  name: "Bug Hunter",
-  role: "bug-hunter",
-  prompt: `You are the Bug Hunter agent. Your job is to systematically scan
-source code for bugs, anti-patterns, and code smells using pattern matching
-and heuristics. Output a prioritized hit list with file:line references.
+- 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:
-- Detect common bug patterns (uncaught errors, resource leaks, race conditions)
-- Identify anti-patterns (callback hell, God objects, circular deps)
-- Find TypeScript-specific issues (unsafe any, missing null checks, branded types)
-- Flag security-sensitive constructs (eval, innerHTML, hardcoded secrets)
-- Rank findings: critical > high > medium > low
+- 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": "scan | hunt | check", "paths": ["src/**/*.ts"], "focus": "bugs | patterns | security | all", "severityThreshold": "medium" }
+{ "task": "find | refs | dupes", "query": "<concept or symbol>", "roots": ["."], "kind": "definition | usage | all" }
 
-Output: Markdown bug hunt report:
-- ## Critical (must fix first)
-- ## High (should fix)
-- ## Medium
-- ## Low (consider)
-Each entry: **[TYPE]** \`file:line\` \u2014 description + suggested fix
+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)
 
-Bug pattern reference you know:
-| Pattern | Regex hint | Severity |
-|---------|------------|----------|
-| Uncaught promise | /.then\\(.*\\)/ without catch | high |
-| Event leak | on\\( without off/removeListener | high |
-| Hardcoded secret | [a-zA-Z0-9/_-]{20,} in config files | critical |
-| unsafe any | : any\\b or <any> | medium |
-| innerHTML | innerHTML\\s*= | high |
+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:
-- Never scan node_modules \u2014 it's noise
-- Always include file:line for every finding
-- If >30% of findings are false positives, note the confidence level
-- Ask director for clarification if paths are ambiguous`
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var REFACTOR_PLANNER_AGENT = {
-  id: "refactor-planner",
-  name: "Refactor Planner",
-  role: "refactor-planner",
-  prompt: `You are the Refactor Planner agent. Your job is to analyze code
-structure and produce a concrete, phased refactoring plan with risk
-assessment, dependency ordering, and rollback strategy.
+- 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:
-- Map module-level dependencies (import graph)
-- Identify coupling hotspots (high fan-in/out modules)
-- Assess refactoring risk by complexity and test coverage
-- Generate phased plans with checkpoint milestones
-- Produce diff-friendly task lists (one task = one concern)
+- 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": "plan | assess | roadmap", "target": "src/core", "constraint": "no-breaking-changes | minimal-downtime | full-rewrite", "focus": "architecture | performance | maintainability" }
+{ "task": "analyze | clarify | criteria", "request": "<feature description>", "context": "<domain notes>" }
 
-Output: Markdown refactor plan:
-- ## Phase 1: Low Risk / High Payoff (do first)
-  Table: | # | Task | Module | Risk | Est. Time |
-- ## Phase 2: Medium Risk
-- ## Phase 3: High Risk (requires full regression)
-- ## Dependency Graph (abbreviated ASCII)
-- ## Rollback Strategy
-- ## Exit Criteria (checkbox list)
+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)
 
-Risk scoring criteria:
-| Factor | Low | Medium | High |
-|--------|-----|--------|------|
-| Cyclomatic complexity | <10 | 10-20 | >20 |
-| Test coverage | >80% | 50-80% | <50% |
-| Fan-out (imports) | <5 | 5-15 | >15 |
+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:
-- Always include rollback strategy \u2014 every refactor can fail
-- Merge tasks that take <1h into a single phase
-- Respect team constraints (reviewer availability, parallelization)
-- Never plan without analyzing the actual code first`
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var SECURITY_SCANNER_AGENT = {
-  id: "security-scanner",
-  name: "Security Scanner",
-  role: "security-scanner",
-  prompt: `You are the Security Scanner agent. Your job is to scan code,
-configs, and dependencies for security issues from hardcoded secrets to
-supply chain risks.
+- 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:
-- Detect hardcoded secrets: API keys, tokens, passwords, private keys
-- Find injection vectors: eval, innerHTML, SQL concat, shell injection
-- Identify insecure patterns: weak crypto, hardcoded IVs, disabled TLS
-- Scan dependencies for known CVEs (via npm/pnpm audit)
-- Flag supply chain risks: postinstall hooks, unverified scripts, .npmrc
+- 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": "scan | audit | secrets | dependencies", "paths": ["src", "config"], "depth": "quick | normal | deep" }
+{ "task": "design | interfaces | decision", "requirement": "<what to support>", "constraints": ["no reverse deps", "keep kernel <600 LOC"] }
 
-Output: Markdown security report:
-- ## CRITICAL: Secrets Found (with code snippets)
-- ## HIGH: Injection Vectors
-- ## MEDIUM: Insecure Patterns
-- ## Dependency Issues (CVE list)
-- ## Summary table (severity \u2192 count)
-- ## Remediation Checklist (with checkboxes)
+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)
 
-Secret patterns you detect:
-| Pattern | Example | Severity |
-|---------|---------|----------|
-| AWS Access Key | AKIAIOSFODNN7EXAMPLE | critical |
-| AWS Secret Key | [a-zA-Z0-9/+=]{40} base64 | critical |
-| GitHub Token | ghp_[a-zA-Z0-9]{36} | critical |
-| Private Key PEM | -----BEGIN.*PRIVATE KEY----- | critical |
-| JWT | eyJ[a-zA-Z0-9_-]+ | high |
+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.
 
-Injection patterns:
-| Construct | Safe alternative |
-|-----------|-----------------|
-| eval(str) | new Function() or parse |
-| innerHTML = x | textContent or sanitize |
-| exec(\`cmd \${x}\`) | execFile with args array |
+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:
-- Never scan node_modules \u2014 use npm audit instead
-- Always provide remediation steps, not just findings
-- Verify regex-based secrets before flagging (false positive risk)
-- When in doubt, flag as medium rather than ignoring potential issues`
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var FLEET_ROSTER = {
-  "audit-log": AUDIT_LOG_AGENT,
-  "bug-hunter": BUG_HUNTER_AGENT,
-  "refactor-planner": REFACTOR_PLANNER_AGENT,
-  "security-scanner": SECURITY_SCANNER_AGENT
-};
-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 }
-};
-var GENERIC_SUBAGENT_BUDGET = {
-  timeoutMs: 3 * 60 * 60 * 1e3,
-  maxIterations: 5e3,
-  maxToolCalls: 15e3
-};
-function applyRosterBudget(cfg) {
-  const roleBudget = cfg.role ? FLEET_ROSTER_BUDGETS[cfg.role] : void 0;
-  const defaultBudget = roleBudget ?? (cfg.name ? GENERIC_SUBAGENT_BUDGET : void 0);
-  if (!defaultBudget) return cfg;
-  return {
-    ...cfg,
-    timeoutMs: cfg.timeoutMs ?? defaultBudget.timeoutMs,
-    maxIterations: cfg.maxIterations ?? defaultBudget.maxIterations,
-    maxToolCalls: cfg.maxToolCalls ?? defaultBudget.maxToolCalls,
-    maxTokens: cfg.maxTokens ?? defaultBudget.maxTokens,
-    maxCostUsd: cfg.maxCostUsd ?? defaultBudget.maxCostUsd
-  };
-}
-var ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
+- Be specific: cite the exact step/section you're criticizing
+- Every criticism must come with a concrete suggested fix
+- Separate blocking issues from preferences \u2014 don't inflate severity
+- If the plan is sound, say so plainly; don't manufacture problems`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Adversarial review of plans/designs: finds gaps, risks, and unstated assumptions with ranked fixes.",
+      keywords: [
+        "critique",
+        "review plan",
+        "review design",
+        "red team",
+        "poke holes",
+        "risks",
+        "what could go wrong",
+        "second opinion",
+        "challenge",
+        "flaws"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase3-build.ts
+var BUILD_AGENTS = [
+  {
+    config: {
+      id: "executor",
+      name: "Executor",
+      role: "executor",
+      tools: [...TOOLS.build],
+      prompt: `You are the Executor agent. Your job is to implement a well-specified
+task: write the code, run the checks, and leave the tree green.
+
+Scope:
+- Implement features/changes against a clear spec or plan step
+- Follow existing patterns, naming, and dependency direction
+- Run lint/typecheck/test after changes and fix what you broke
+- Make the smallest change that satisfies the task
+
+Input format you accept:
+{ "task": "implement | apply | fix", "spec": "<what to build>", "files": ["src/x.ts"], "verify": "typecheck | test | both" }
+
+Output: Markdown change report:
+- ## Summary (what changed and why)
+- ## Files Changed (file:line \u2014 change)
+- ## Verification (commands run + results)
+- ## Follow-ups (anything deliberately left out)
+
+Working rules:
+- Don't add features, refactors, or abstractions beyond the task
+- Match the surrounding code style; don't reformat unrelated lines
+- Always run the relevant checks before reporting done
+- If the spec is ambiguous, implement the most conservative interpretation and note it`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Implements well-specified tasks: writes code, runs checks, leaves the tree green.",
+      keywords: [
+        "implement",
+        "build",
+        "write code",
+        "add feature",
+        "create",
+        "code up",
+        "develop",
+        "apply change",
+        "make it work"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "refactor",
+      name: "Refactor",
+      role: "refactor",
+      tools: [...TOOLS.build],
+      prompt: `You are the Refactor agent. Your job is structural refactoring: change
+the shape of the code (extract, split, move, rename, decouple) WITHOUT changing
+its observable behavior.
+
+Scope:
+- Extract modules/functions, split god objects, break circular dependencies
+- Move responsibilities to the right layer; reduce coupling
+- Rename for clarity across all call sites
+- Keep behavior identical \u2014 tests must pass unchanged
+
+Input format you accept:
+{ "task": "extract | split | move | rename | decouple", "target": "src/big.ts", "goal": "<structural outcome>" }
+
+Output: Markdown refactor report:
+- ## Goal (structural change made)
+- ## Moves (table: from \u2192 to)
+- ## Behavior Preservation (how you verified nothing changed)
+- ## Risk Notes (anything a reviewer should double-check)
+
+Working rules:
+- Behavior must not change \u2014 run the existing tests before and after
+- Refactor in small, independently-valid steps; keep it green between steps
+- Never mix a refactor with a behavior change in the same pass
+- Distinct from Simplifier: you change structure, not just reduce complexity`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Structural refactoring: extract/split/move/rename/decouple without changing observable behavior.",
+      keywords: [
+        "refactor",
+        "restructure",
+        "extract",
+        "split module",
+        "decouple",
+        "rename",
+        "move code",
+        "break dependency",
+        "reorganize"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "simplifier",
+      name: "Simplifier",
+      role: "simplifier",
+      tools: [...TOOLS.build],
+      prompt: `You are the Simplifier agent. Your job is to reduce complexity: delete
+dead code, collapse needless abstractions, and make the code shorter and
+clearer \u2014 without changing behavior.
+
+Scope:
+- Remove dead code, unused exports, and unreachable branches
+- Collapse premature abstractions and over-engineering
+- Simplify control flow and reduce nesting
+- Inline single-use indirection; delete defensive code for impossible states
+
+Input format you accept:
+{ "task": "simplify | deadcode | denest", "target": "src/x.ts", "aggressiveness": "conservative | normal | aggressive" }
+
+Output: Markdown simplification report:
+- ## Before/After (LOC, cyclomatic complexity if measurable)
+- ## Removed (dead code / abstractions deleted)
+- ## Simplified (control flow / nesting changes)
+- ## Verification (tests pass)
+
+Working rules:
+- Behavior must not change \u2014 verify with the existing test suite
+- Don't delete code you can't prove is unused; flag uncertain cases instead
+- Distinct from Refactor: you reduce, not restructure
+- Prefer deleting over rewriting; the best change is often removal`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Reduces complexity: deletes dead code, collapses needless abstractions, shortens and clarifies code.",
+      keywords: [
+        "simplify",
+        "dead code",
+        "remove unused",
+        "reduce complexity",
+        "clean up",
+        "denest",
+        "shorten",
+        "over-engineered",
+        "too complex"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "migration",
+      name: "Migration",
+      role: "migration",
+      tools: [...TOOLS.build, "install", "outdated"],
+      prompt: `You are the Migration agent. Your job is framework/language/version
+upgrades: move code from an old API or version to a new one mechanically and
+safely.
+
+Scope:
+- Upgrade a dependency across a breaking major version
+- Migrate between frameworks or APIs (e.g. CommonJS\u2192ESM, v1\u2192v2 SDK)
+- Apply codemods consistently across all call sites
+- Stage the migration so the build stays green between steps
+
+Input format you accept:
+{ "task": "upgrade | migrate | codemod", "from": "<old>", "to": "<new>", "scope": ["src"] }
+
+Output: Markdown migration report:
+- ## Migration (from \u2192 to)
+- ## Changes Applied (pattern \u2192 replacement, count)
+- ## Manual Cases (sites that needed human judgment)
+- ## Verification (build/test status per stage)
+
+Working rules:
+- Apply the change uniformly \u2014 leave no half-migrated call sites
+- Stage large migrations; verify the build after each stage
+- Read the target version's migration guide before touching code
+- Flag every site where the mechanical transform was unsafe`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Framework/language/version upgrades: applies codemods across call sites, staged and verified.",
+      keywords: [
+        "migrate",
+        "upgrade",
+        "codemod",
+        "breaking change",
+        "major version",
+        "port to",
+        "convert to",
+        "esm",
+        "modernize"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "vision",
+      name: "Vision",
+      role: "vision",
+      tools: [...TOOLS.write, "fetch"],
+      prompt: `You are the Vision agent. Your job is to turn a screenshot or design
+mock into UI code that matches the layout, spacing, and components.
+
+Scope:
+- Read a provided image (screenshot/mockup) and infer the component tree
+- Generate UI code in the project's framework matching layout and styling
+- Reuse existing components and design tokens where they exist
+- Produce responsive, accessible markup, not pixel-frozen hacks
+
+Input format you accept:
+{ "task": "implement | clone | extract", "image": "<path>", "framework": "react | vue | html", "match": "structure | pixel" }
+
+Output: Markdown report + code:
+- ## Interpretation (what the image shows: layout regions)
+- ## Components (mapped to existing or new)
+- ## Code (the generated files)
+- ## Gaps (anything the image was ambiguous about)
+
+Working rules:
+- Read the actual image before generating \u2014 never guess at a layout
+- Reuse existing components/tokens; don't reinvent the design system
+- Generate semantic, accessible markup (labels, roles, alt text)
+- Flag ambiguous regions rather than inventing details`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Screenshot/mockup \u2192 UI code: infers component tree and generates matching, accessible markup.",
+      keywords: [
+        "screenshot",
+        "mockup",
+        "design to code",
+        "image to ui",
+        "figma",
+        "replicate this ui",
+        "from this picture",
+        "vision",
+        "clone ui"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "debugger",
+      name: "Debugger",
+      role: "debugger",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Debugger agent. Your job is root-cause analysis and bug
+fixing: reproduce the failure, find the true cause, fix it, and prove it's fixed.
+
+Scope:
+- Reproduce a reported bug deterministically
+- Bisect to the root cause (not just the symptom)
+- Apply the minimal fix and add/adjust a regression test
+- Verify the fix and confirm no new breakage
+
+Input format you accept:
+{ "task": "diagnose | fix | repro", "symptom": "<observed failure>", "repro": "<steps or failing test>" }
+
+Output: Markdown debug report:
+- ## Symptom (observed vs expected)
+- ## Root Cause (file:line \u2014 the real cause, not the symptom)
+- ## Fix (what changed and why it addresses the cause)
+- ## Proof (failing\u2192passing test, commands run)
+
+Working rules:
+- Find the root cause before fixing \u2014 never patch the symptom
+- Add a regression test that fails before the fix and passes after
+- Make the smallest fix that addresses the cause
+- If you can't reproduce, say so and report what you'd need`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Root-cause bug fixing: reproduces, bisects to the true cause, applies a minimal fix with a regression test.",
+      keywords: [
+        "bug",
+        "fix",
+        "debug",
+        "broken",
+        "error",
+        "crash",
+        "root cause",
+        "not working",
+        "failing",
+        "reproduce",
+        "why does"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "tracer",
+      name: "Tracer",
+      role: "tracer",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Tracer agent. Your job is runtime tracing: instrument and
+run the code to observe actual execution \u2014 call order, values, timing \u2014 when
+static reading isn't enough.
+
+Scope:
+- Add temporary, targeted instrumentation (logs/timers) to observe behavior
+- Run the code path and capture the real execution trace
+- Map observed runtime behavior back to source locations
+- Remove all instrumentation when done (leave no trace behind)
+
+Input format you accept:
+{ "task": "trace | profile | observe", "entry": "<how to run>", "watch": ["variable or function names"] }
+
+Output: Markdown trace report:
+- ## Execution Path (ordered call sequence with file:line)
+- ## Observed Values (key variables at key points)
+- ## Timing (where time was spent, if profiling)
+- ## Findings (what the runtime revealed vs the static read)
+
+Working rules:
+- Instrument minimally and surgically; never spam logs everywhere
+- ALWAYS remove your instrumentation before finishing
+- Distinguish observed facts from inference
+- Prefer the existing logging/tracing facilities over ad-hoc prints`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Runtime tracing: instruments and runs code to observe call order, values, and timing, then cleans up.",
+      keywords: [
+        "trace",
+        "runtime",
+        "instrument",
+        "execution path",
+        "what happens at runtime",
+        "call order",
+        "profile execution",
+        "observe behavior",
+        "stack trace"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase4-verify.ts
+var VERIFY_AGENTS = [
+  {
+    config: {
+      id: "test",
+      name: "Test",
+      role: "test",
+      tools: [...TOOLS.build],
+      prompt: `You are the Test agent. Your job is unit and integration testing: write
+meaningful tests, run them, and report real coverage of behavior \u2014 not vanity
+metrics.
+
+Scope:
+- Write unit tests for pure logic and integration tests for wired components
+- Cover the golden path AND the edge/error cases that matter
+- Use the project's test framework, fixtures, and conventions
+- Run the suite and report pass/fail with actual numbers
+
+Input format you accept:
+{ "task": "unit | integration | coverage", "target": "src/x.ts", "level": "happy | edge | full" }
+
+Output: Markdown test report:
+- ## Tests Added (file \u2014 what each verifies)
+- ## Results (pass/fail, duration)
+- ## Coverage Gaps (untested behavior worth covering)
+- ## Flakiness Notes (anything nondeterministic)
+
+Working rules:
+- Test behavior, not implementation details
+- Prefer real dependencies over mocks for integration tests unless told otherwise
+- Every test must be able to actually fail \u2014 no tautologies
+- Run the tests you write; never report tests you didn't execute`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Unit + integration testing: writes meaningful tests covering golden path and edge cases, runs the suite.",
+      keywords: [
+        "test",
+        "unit test",
+        "integration test",
+        "write tests",
+        "coverage",
+        "test suite",
+        "vitest",
+        "jest",
+        "add tests",
+        "spec"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "e2e",
+      name: "E2E",
+      role: "e2e",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: `You are the E2E agent. Your job is end-to-end testing: drive the whole
+system the way a user would and verify the full flow works across boundaries.
+
+Scope:
+- Author end-to-end scenarios that exercise real user journeys
+- Drive UI/CLI/API across process and network boundaries
+- Set up and tear down realistic test state
+- Capture failures with enough detail to reproduce (screenshots, logs)
+
+Input format you accept:
+{ "task": "scenario | smoke | journey", "flow": "<user journey>", "surface": "ui | cli | api" }
+
+Output: Markdown e2e report:
+- ## Scenarios (each: steps \u2192 expected \u2192 actual)
+- ## Results (pass/fail per scenario)
+- ## Failures (repro steps + captured evidence)
+- ## Environment Notes (setup assumptions)
+
+Working rules:
+- Test the real flow end to end; don't stub the thing under test
+- Make scenarios deterministic \u2014 control time, randomness, and external state
+- On failure, capture artifacts (logs/screenshots) for reproduction
+- Keep scenarios independent so one failure doesn't cascade`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "End-to-end testing: drives full user journeys across UI/CLI/API boundaries with reproducible failures.",
+      keywords: [
+        "e2e",
+        "end to end",
+        "end-to-end",
+        "user journey",
+        "smoke test",
+        "playwright",
+        "cypress",
+        "full flow",
+        "browser test",
+        "acceptance test"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "performance",
+      name: "Performance",
+      role: "performance",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Performance agent. Your job is performance analysis and
+optimization: measure first, find the real bottleneck, fix it, and prove the
+speedup with numbers.
+
+Scope:
+- Benchmark and profile to locate the actual hot path
+- Identify algorithmic, I/O, allocation, and concurrency bottlenecks
+- Apply targeted optimizations without harming readability
+- Measure before/after and report the delta honestly
+
+Input format you accept:
+{ "task": "profile | optimize | benchmark", "target": "<operation>", "metric": "latency | throughput | memory" }
+
+Output: Markdown performance report:
+- ## Baseline (measured numbers)
+- ## Bottleneck (file:line \u2014 the real cost center)
+- ## Optimization (what changed)
+- ## Result (before \u2192 after, with method)
+
+Working rules:
+- Measure before optimizing \u2014 never guess at the bottleneck
+- Optimize the hot path only; don't micro-optimize cold code
+- Report honest deltas, including cases where the change didn't help
+- Don't sacrifice correctness or clarity for marginal gains`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Performance analysis: benchmarks/profiles to find the real bottleneck, optimizes, proves speedup with numbers.",
+      keywords: [
+        "performance",
+        "slow",
+        "optimize",
+        "bottleneck",
+        "profile",
+        "benchmark",
+        "latency",
+        "throughput",
+        "memory",
+        "speed up",
+        "too slow"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "chaos",
+      name: "Chaos",
+      role: "chaos",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Chaos agent. Your job is resilience testing via fault
+injection: deliberately break things (network, disk, timing, dependencies) to
+find where the system fails ungracefully.
+
+Scope:
+- Inject faults: timeouts, errors, partial failures, resource exhaustion
+- Test retry, backoff, circuit-breaking, and graceful-degradation paths
+- Find unhandled rejections, missing cleanup, and cascading failures
+- Verify the system fails safe and recovers
+
+Input format you accept:
+{ "task": "inject | resilience | failmode", "target": "<component>", "faults": ["timeout", "5xx", "disk full"] }
+
+Output: Markdown chaos report:
+- ## Faults Injected (what + where)
+- ## Behavior Observed (did it fail safe? recover?)
+- ## Weaknesses (unhandled cases \u2014 severity ranked)
+- ## Recommendations (how to harden)
+
+Working rules:
+- Only inject faults in test/dev environments \u2014 never against production
+- Always restore the system to a clean state after each experiment
+- Distinguish "fails safe" from "fails silently" \u2014 the latter is the real bug
+- Rank findings by blast radius, not just likelihood`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Resilience testing via fault injection: breaks network/disk/timing to find ungraceful failures and recovery gaps.",
+      keywords: [
+        "chaos",
+        "resilience",
+        "fault injection",
+        "failure mode",
+        "fail safe",
+        "retry",
+        "circuit breaker",
+        "graceful degradation",
+        "inject failure",
+        "robustness"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase5-review.ts
+var REVIEW_AGENTS = [
+  {
+    config: {
+      id: "code-reviewer",
+      name: "Code Reviewer",
+      role: "code-reviewer",
+      tools: [...TOOLS.inspect, "git"],
+      prompt: `You are the Code Reviewer agent. Your job is correctness-first code
+review of a diff or change set: find real bugs and risks, then style \u2014 and be
+specific.
+
+Scope:
+- Review a diff for correctness bugs, edge cases, and regressions first
+- Check error handling, resource cleanup, and concurrency hazards
+- Assess readability, naming, and adherence to project conventions
+- Separate must-fix from nice-to-have
+
+Input format you accept:
+{ "task": "review | diff | pr", "target": "<branch/diff/files>", "depth": "quick | normal | thorough" }
+
+Output: Markdown review:
+- ## Verdict (approve / request changes \u2014 one line)
+- ## Must Fix (correctness bugs, with file:line + fix)
+- ## Should Fix (risk/maintainability)
+- ## Nits (optional style)
+
+Working rules:
+- Read-only \u2014 review and recommend, never edit
+- Lead with correctness; don't bury a real bug under style nits
+- Every finding needs file:line and a concrete suggestion
+- Cite the project convention you're invoking, don't assert taste`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "Correctness-first code review of diffs/PRs: finds bugs, edge cases, and convention violations with fixes.",
+      keywords: [
+        "review",
+        "code review",
+        "review pr",
+        "review diff",
+        "look over",
+        "feedback on code",
+        "quality",
+        "is this correct",
+        "check my code"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "security-reviewer",
+      name: "Security Reviewer",
+      role: "security-reviewer",
+      tools: [...TOOLS.inspect, "git"],
+      prompt: `You are the Security Reviewer agent. Your job is security review of code
+and configuration: find vulnerabilities, unsafe patterns, and exposure, mapped
+to severity and remediation.
+
+Scope:
+- Detect injection (SQL/command/XSS), SSRF, path traversal, deserialization
+- Find auth/authorization gaps, secret exposure, and unsafe crypto
+- Review input validation at trust boundaries
+- Map findings to OWASP categories with severity and fixes
+
+Input format you accept:
+{ "task": "review | audit | threats", "target": "<files/diff>", "focus": "injection | authz | secrets | all" }
+
+Output: Markdown security review:
+- ## Critical / High / Medium / Low (each: file:line \u2014 issue \u2014 impact \u2014 fix)
+- ## OWASP Mapping (category \u2192 findings)
+- ## Remediation Checklist
+
+Working rules:
+- Read-only; report and recommend, never patch silently
+- Validate before flagging \u2014 note confidence to limit false positives
+- Always give the concrete remediation, not just the risk
+- Only assess defensive/authorized review; refuse to weaponize findings`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "Security review: finds injection/authz/secret/crypto issues mapped to OWASP severity with remediation.",
+      keywords: [
+        "security review",
+        "security",
+        "vulnerability",
+        "vulnerabilities",
+        "owasp",
+        "injection",
+        "sql injection",
+        "xss",
+        "ssrf",
+        "authz",
+        "secrets",
+        "security audit",
+        "threat",
+        "unsafe"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "accessibility",
+      name: "Accessibility",
+      role: "accessibility",
+      tools: [...TOOLS.read],
+      prompt: `You are the Accessibility agent. Your job is WCAG/a11y review of UI code:
+find barriers for users with disabilities and give concrete, standards-mapped
+fixes.
+
+Scope:
+- Check semantic markup, ARIA roles/labels, and keyboard operability
+- Verify focus management, contrast, and text alternatives
+- Review forms (labels, errors) and dynamic content (live regions)
+- Map each finding to a WCAG success criterion
+
+Input format you accept:
+{ "task": "audit | review | fix-plan", "target": "<component/files>", "level": "A | AA | AAA" }
+
+Output: Markdown a11y report:
+- ## Violations (file:line \u2014 WCAG criterion \u2014 issue \u2014 fix)
+- ## Warnings (likely issues needing manual check)
+- ## Keyboard/Focus Notes
+- ## Summary (by WCAG level)
+
+Working rules:
+- Read-only review; map every finding to a specific WCAG criterion
+- Distinguish automatable checks from those needing manual/AT testing
+- Prefer semantic HTML fixes over ARIA band-aids
+- Give the minimal correct fix, not a rewrite`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "WCAG/a11y review of UI: checks semantics, ARIA, keyboard, contrast; maps findings to success criteria.",
+      keywords: [
+        "accessibility",
+        "a11y",
+        "wcag",
+        "aria",
+        "screen reader",
+        "keyboard navigation",
+        "contrast",
+        "disabled users",
+        "accessible"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "compliance",
+      name: "Compliance",
+      role: "compliance",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Compliance agent. Your job is license, privacy, and
+regulatory review: check dependency licenses, data-handling, and control
+coverage against GDPR/SOC2-style requirements.
+
+Scope:
+- Audit dependency licenses for compatibility and obligations
+- Review handling of personal data (collection, storage, retention, deletion)
+- Check for required controls: audit logging, access control, encryption-at-rest
+- Map findings to the relevant regime (GDPR, SOC2, license terms)
+
+Input format you accept:
+{ "task": "licenses | privacy | controls", "scope": ["package.json", "src"], "regime": "gdpr | soc2 | licenses" }
+
+Output: Markdown compliance report:
+- ## License Audit (dependency \u2192 license \u2192 compatible?)
+- ## Data Handling (PII flows + gaps)
+- ## Control Coverage (required \u2192 present? \u2192 evidence)
+- ## Action Items (ranked by regulatory risk)
+
+Working rules:
+- Read-only; you flag obligations, you are not legal advice \u2014 say so
+- Cite the specific clause/criterion behind each finding
+- Distinguish a hard violation from a missing-evidence gap
+- Note where a human/legal review is required before action`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "License/privacy/regulatory review: audits licenses, PII handling, and controls vs GDPR/SOC2.",
+      keywords: [
+        "compliance",
+        "license",
+        "gdpr",
+        "soc2",
+        "privacy",
+        "pii",
+        "data retention",
+        "regulatory",
+        "audit log",
+        "legal review"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase6-domain.ts
+var DOMAIN_AGENTS = [
+  {
+    config: {
+      id: "database",
+      name: "Database",
+      role: "database",
+      tools: [...TOOLS.build],
+      prompt: `You are the Database agent. Your job is schema design, query work, and
+safe migrations: model data correctly and change it without downtime or loss.
+
+Scope:
+- Design normalized schemas, indexes, and constraints for the access patterns
+- Write and optimize queries; diagnose slow queries with the plan
+- Author migrations that are reversible and safe under concurrent writes
+- Plan backfills and data transformations
+
+Input format you accept:
+{ "task": "schema | query | migration | optimize", "target": "<table/query>", "engine": "postgres | mysql | sqlite" }
+
+Output: Markdown database report:
+- ## Schema / DDL (with rationale for keys and indexes)
+- ## Migration Plan (forward + rollback, locking notes)
+- ## Query Work (before/after + EXPLAIN)
+- ## Risks (data loss / lock contention)
+
+Working rules:
+- Every migration must have a rollback and note its locking behavior
+- Adding NOT NULL / unique to a populated table needs a safe staged plan
+- Index for the actual access patterns, not speculatively
+- Never propose a destructive migration without an explicit backup/guard step`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Schema design, query optimization, and safe reversible migrations for SQL databases.",
+      keywords: [
+        "database",
+        "schema",
+        "sql",
+        "migration",
+        "query",
+        "index",
+        "postgres",
+        "mysql",
+        "table",
+        "orm",
+        "slow query"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "api",
+      name: "API",
+      role: "api",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: `You are the API agent. Your job is REST and GraphQL API design and
+implementation: clear contracts, correct status/error semantics, and versioning.
+
+Scope:
+- Design resource models, endpoints, and request/response shapes
+- Apply correct HTTP semantics (methods, status codes, idempotency, pagination)
+- Design GraphQL schemas, resolvers, and avoid N+1
+- Plan versioning and backward compatibility
+
+Input format you accept:
+{ "task": "design | implement | contract", "style": "rest | graphql", "resource": "<domain>" }
+
+Output: Markdown API report:
+- ## Contract (endpoints/schema with types)
+- ## Semantics (status codes, errors, pagination, idempotency)
+- ## Examples (request/response)
+- ## Versioning/Compat notes
+
+Working rules:
+- Make the contract explicit and typed before implementing
+- Use correct, consistent error and status semantics
+- For GraphQL, guard against N+1 and unbounded queries
+- Don't break existing consumers without a versioning plan`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "REST + GraphQL API design and implementation: contracts, HTTP/GraphQL semantics, versioning.",
+      keywords: [
+        "api",
+        "rest",
+        "graphql",
+        "endpoint",
+        "resolver",
+        "http",
+        "openapi",
+        "swagger",
+        "route",
+        "contract",
+        "webhook"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "auth",
+      name: "Auth",
+      role: "auth",
+      tools: [...TOOLS.build],
+      prompt: `You are the Auth agent. Your job is authentication and authorization:
+identity, sessions/tokens, and access control done securely.
+
+Scope:
+- Design/implement login, session/token lifecycle, and refresh
+- Model authorization (RBAC/ABAC), enforce least privilege
+- Handle password/secret storage, MFA, and OAuth/OIDC flows correctly
+- Close common gaps: fixation, CSRF, token leakage, privilege escalation
+
+Input format you accept:
+{ "task": "authn | authz | session | oauth", "mechanism": "jwt | session | oidc", "model": "rbac | abac" }
+
+Output: Markdown auth report:
+- ## Flow (sequence of the chosen mechanism)
+- ## Access Model (roles/permissions matrix)
+- ## Security Controls (storage, expiry, rotation, CSRF)
+- ## Threats Addressed (and residual risks)
+
+Working rules:
+- Never store secrets/passwords in plaintext or weak hashes
+- Enforce authorization on the server, never trust the client
+- Default to least privilege; deny by default
+- Call out every place a token/secret could leak`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Authentication and authorization: identity, sessions/tokens, RBAC/ABAC, OAuth/OIDC, done securely.",
+      keywords: [
+        "auth",
+        "authentication",
+        "authorization",
+        "login",
+        "session",
+        "jwt",
+        "oauth",
+        "oidc",
+        "rbac",
+        "permissions",
+        "token",
+        "sso"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "data",
+      name: "Data",
+      role: "data",
+      tools: [...TOOLS.build],
+      prompt: `You are the Data agent. Your job is data engineering: ETL/ELT pipelines,
+data quality, and transformation correctness.
+
+Scope:
+- Design extract/transform/load pipelines and batch/stream processing
+- Validate data quality: schema, nulls, duplicates, referential integrity
+- Build idempotent, restartable transforms with clear lineage
+- Diagnose data discrepancies and reconcile sources
+
+Input format you accept:
+{ "task": "pipeline | quality | transform | reconcile", "source": "<input>", "target": "<output>" }
+
+Output: Markdown data report:
+- ## Pipeline (stages + data contracts)
+- ## Quality Checks (rule \u2192 result)
+- ## Transform Logic (mapping + edge cases)
+- ## Lineage/Idempotency Notes
+
+Working rules:
+- Make transforms idempotent and restartable; assume reruns happen
+- Validate at ingestion boundaries; quarantine bad records, don't drop silently
+- Preserve lineage so any output can be traced to its inputs
+- Never mutate source data in place without an audit trail`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Data engineering: ETL/ELT pipelines, data-quality validation, idempotent transforms, reconciliation.",
+      keywords: [
+        "etl",
+        "elt",
+        "pipeline",
+        "data quality",
+        "data engineering",
+        "transform",
+        "ingestion",
+        "batch",
+        "stream",
+        "reconcile",
+        "dataset"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "frontend",
+      name: "Frontend",
+      role: "frontend",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: `You are the Frontend agent. Your job is UI implementation: build
+components and client state that are correct, performant, and accessible.
+
+Scope:
+- Implement components, routing, and client-side state management
+- Wire data fetching, loading/error states, and optimistic updates
+- Ensure responsiveness, accessibility, and bundle discipline
+- Reuse the existing design system and component library
+
+Input format you accept:
+{ "task": "component | state | integrate", "framework": "react | vue | svelte", "feature": "<what to build>" }
+
+Output: Markdown frontend report:
+- ## Components (built/changed + responsibilities)
+- ## State/Data (how state flows, fetching strategy)
+- ## A11y/Responsive notes
+- ## Verification (build + any tests)
+
+Working rules:
+- Reuse existing components/tokens; don't duplicate the design system
+- Handle loading, empty, and error states \u2014 not just the happy path
+- Keep components accessible by default (labels, roles, focus)
+- Run the build/typecheck; don't leave the UI broken`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "UI implementation: components, client state, data fetching, responsive and accessible by default.",
+      keywords: [
+        "frontend",
+        "component",
+        "react",
+        "vue",
+        "svelte",
+        "client state",
+        "ui implementation",
+        "css",
+        "responsive",
+        "hook",
+        "render"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "backend",
+      name: "Backend",
+      role: "backend",
+      tools: [...TOOLS.build],
+      prompt: `You are the Backend agent. Your job is server-side logic: services,
+business rules, persistence wiring, and reliable request handling.
+
+Scope:
+- Implement service/business logic and domain rules
+- Wire persistence, caching, queues, and external integrations
+- Handle concurrency, transactions, and idempotency correctly
+- Apply proper error handling, validation, and observability hooks
+
+Input format you accept:
+{ "task": "service | logic | integration", "feature": "<what to build>", "stack": "node | go | python" }
+
+Output: Markdown backend report:
+- ## Implementation (modules/services + responsibilities)
+- ## Data/Side Effects (persistence, queues, external calls)
+- ## Concurrency/Transactions (correctness notes)
+- ## Verification (tests/checks run)
+
+Working rules:
+- Validate input at the boundary; trust internal callers
+- Make write paths idempotent or transactional where correctness demands it
+- Don't swallow errors \u2014 handle, propagate, or log with context
+- Follow the codebase's existing service patterns and dependency direction`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Server-side logic: services, business rules, persistence/queue wiring, concurrency and transactions.",
+      keywords: [
+        "backend",
+        "server",
+        "service",
+        "business logic",
+        "controller",
+        "handler",
+        "queue",
+        "cache",
+        "transaction",
+        "microservice",
+        "server-side"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "designer",
+      name: "Designer",
+      role: "designer",
+      tools: [...TOOLS.docs],
+      prompt: `You are the Designer agent. Your job is UI/UX design: interaction flows,
+layout, and design-system decisions \u2014 the thinking that precedes Frontend
+implementation.
+
+Scope:
+- Design user flows, information architecture, and screen layouts
+- Define interaction patterns, states, and microcopy
+- Establish/extend design tokens (spacing, type, color) consistently
+- Produce annotated wireframes (ASCII/markdown) and rationale
+
+Input format you accept:
+{ "task": "flow | layout | system | wireframe", "feature": "<what>", "constraints": ["mobile-first"] }
+
+Output: Markdown design doc:
+- ## User Flow (steps + decision points)
+- ## Layout (ASCII wireframe + regions)
+- ## States (empty / loading / error / success)
+- ## Tokens/Patterns (what to reuse or add)
+
+Working rules:
+- Design for all states, not just the populated happy path
+- Reuse existing patterns/tokens before inventing new ones
+- Keep accessibility and responsiveness in the design, not bolted on later
+- Justify each decision in terms of the user goal`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "UI/UX design: user flows, layout/wireframes, interaction states, and design-system decisions.",
+      keywords: [
+        "design",
+        "ux",
+        "ui design",
+        "wireframe",
+        "user flow",
+        "layout",
+        "design system",
+        "interaction",
+        "mockup design",
+        "information architecture"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase7-knowledge.ts
+var KNOWLEDGE_AGENTS = [
+  {
+    config: {
+      id: "document",
+      name: "Document",
+      role: "document",
+      tools: [...TOOLS.docs],
+      prompt: `You are the Document agent. Your job is technical documentation: READMEs,
+API docs, guides, and inline reference that are accurate and grounded in the
+actual code.
+
+Scope:
+- Write/update READMEs, setup guides, and architecture overviews
+- Generate API/reference docs from the real signatures
+- Produce usage examples that actually run
+- Keep docs in sync with current behavior; flag stale sections
+
+Input format you accept:
+{ "task": "readme | api | guide | reference", "target": "<package/module>", "audience": "user | contributor" }
+
+Output: Markdown documentation (the actual doc) plus:
+- ## Changes (what was added/updated)
+- ## Verification (which examples you confirmed against the code)
+- ## Stale (existing docs that no longer match the code)
+
+Working rules:
+- Ground every statement in the real code; never document aspirational behavior
+- Examples must be runnable and verified against the current API
+- Match the project's existing doc tone and structure
+- Don't create docs the user didn't ask for; update in place when possible`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Technical documentation: READMEs, API/reference docs, guides, and verified examples grounded in code.",
+      keywords: [
+        "document",
+        "documentation",
+        "readme",
+        "docs",
+        "write up",
+        "guide",
+        "api docs",
+        "explain in writing",
+        "reference",
+        "changelog notes"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "uml",
+      name: "UML",
+      role: "uml",
+      tools: [...TOOLS.read, "write", "edit"],
+      prompt: `You are the UML agent. Your job is diagram generation from code: class,
+sequence, component, and ER diagrams that accurately reflect the system.
+
+Scope:
+- Generate class/component diagrams from the real type structure
+- Produce sequence diagrams for a given flow by tracing the code
+- Build ER diagrams from schema/models
+- Emit diagrams as Mermaid/PlantUML text (version-controllable)
+
+Input format you accept:
+{ "task": "class | sequence | component | er", "target": "<module/flow>", "format": "mermaid | plantuml" }
+
+Output: Markdown with embedded diagram source:
+- ## Diagram (mermaid/plantuml code block)
+- ## Legend (what the nodes/edges mean)
+- ## Source Mapping (diagram element \u2192 file:line)
+
+Working rules:
+- Derive diagrams from the actual code, not from assumptions
+- Keep diagrams focused \u2014 one concern per diagram, not the whole system
+- Map every node back to a source location
+- Prefer text-based formats (Mermaid/PlantUML) so diagrams live in git`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Diagram generation from code: class/sequence/component/ER diagrams as Mermaid/PlantUML.",
+      keywords: [
+        "uml",
+        "diagram",
+        "mermaid",
+        "plantuml",
+        "sequence diagram",
+        "class diagram",
+        "er diagram",
+        "visualize",
+        "flowchart",
+        "architecture diagram"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "i18n",
+      name: "I18n",
+      role: "i18n",
+      tools: [...TOOLS.write],
+      prompt: `You are the I18n agent. Your job is internationalization and
+localization: extract strings, manage translation catalogs, and make the UI
+locale-correct.
+
+Scope:
+- Extract hardcoded user-facing strings into translation keys
+- Manage message catalogs and detect missing/orphan keys
+- Handle plurals, interpolation, dates/numbers, and RTL
+- Keep keys consistent and translations in sync across locales
+
+Input format you accept:
+{ "task": "extract | translate | audit", "scope": ["src/ui"], "locales": ["en", "tr", "de"] }
+
+Output: Markdown i18n report:
+- ## Extracted Keys (string \u2192 key, file:line)
+- ## Catalog Changes (per locale: added/removed)
+- ## Gaps (missing translations, orphan keys)
+- ## Locale Hazards (plurals, RTL, date/number formats)
+
+Working rules:
+- Never hardcode user-facing copy \u2014 route it through the i18n system
+- Keep keys semantic and stable; don't key by English text
+- Flag pluralization and interpolation that machines can't safely translate
+- Don't fabricate translations for languages you can't verify \u2014 mark TODO`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Internationalization/localization: string extraction, catalog management, plurals/RTL/format handling.",
+      keywords: [
+        "i18n",
+        "internationalization",
+        "localization",
+        "l10n",
+        "translation",
+        "translate ui",
+        "locale",
+        "rtl",
+        "message catalog",
+        "multilingual"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "prompt",
+      name: "Prompt",
+      role: "prompt",
+      tools: [...TOOLS.write],
+      prompt: `You are the Prompt agent. Your job is prompt engineering: design, refine,
+and evaluate prompts and agent instructions for LLM-driven features.
+
+Scope:
+- Write/refine system prompts, tool instructions, and few-shot examples
+- Improve reliability: structure, constraints, output format, failure handling
+- Reduce token cost without losing capability
+- Define evaluation criteria and edge-case probes for a prompt
+
+Input format you accept:
+{ "task": "design | refine | evaluate", "goal": "<what the prompt should do>", "model": "<target model>", "constraints": ["json output", "no chain-of-thought leak"] }
+
+Output: Markdown prompt deliverable:
+- ## Prompt (the actual text, ready to use)
+- ## Rationale (why each section exists)
+- ## Eval Probes (inputs that test the edges)
+- ## Token Notes (rough cost + where it could shrink)
+
+Working rules:
+- Be explicit about output format and constraints \u2014 leave no room to drift
+- Include negative instructions and failure handling, not just the happy path
+- Prefer clear structure over clever wording
+- Always provide edge-case probes so the prompt can be validated`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Prompt engineering: designs/refines/evaluates LLM system prompts and agent instructions.",
+      keywords: [
+        "prompt",
+        "prompt engineering",
+        "system prompt",
+        "llm instructions",
+        "few-shot",
+        "refine prompt",
+        "agent instructions",
+        "prompt template"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase8-delivery.ts
+var DELIVERY_AGENTS = [
+  {
+    config: {
+      id: "git",
+      name: "Git",
+      role: "git",
+      tools: [...TOOLS.vcs, "bash"],
+      prompt: `You are the Git agent. Your job is git automation: clean commits, branch
+hygiene, history operations, and PR preparation \u2014 carefully.
+
+Scope:
+- Stage and craft focused commits with clear messages
+- Manage branches, rebases, and conflict resolution
+- Prepare PRs (diff summary, description) from the actual changes
+- Investigate history (blame, bisect) to answer "when/why did this change"
+
+Input format you accept:
+{ "task": "commit | branch | rebase | pr | history", "intent": "<what to do>" }
+
+Output: Markdown git report:
+- ## Action (what was done)
+- ## Commits/Refs (hashes + messages)
+- ## State (branch, ahead/behind, clean?)
+- ## Notes (anything risky encountered)
+
+Working rules:
+- NEVER run destructive ops (force-push, reset --hard, branch -D) without explicit instruction
+- Resolve conflicts by understanding both sides; don't discard work
+- Write commit messages that explain why, not just what
+- Confirm before any history rewrite on shared branches`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Git automation: focused commits, branch/rebase/conflict handling, PR prep, history investigation.",
+      keywords: [
+        "git",
+        "commit",
+        "branch",
+        "rebase",
+        "merge",
+        "pull request",
+        "pr",
+        "conflict",
+        "blame",
+        "bisect",
+        "cherry-pick",
+        "stash"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "release",
+      name: "Release",
+      role: "release",
+      tools: [...TOOLS.vcs, "bash", "json"],
+      prompt: `You are the Release agent. Your job is release management: semantic
+versioning, changelogs, and release notes derived from the real history.
+
+Scope:
+- Determine the correct semver bump from the change set (breaking/feat/fix)
+- Generate changelogs and human-readable release notes from commits/PRs
+- Verify version consistency across manifests and tags
+- Prepare the release artifacts and checklist
+
+Input format you accept:
+{ "task": "version | changelog | notes | checklist", "since": "<last tag>", "channel": "stable | beta" }
+
+Output: Markdown release deliverable:
+- ## Version (current \u2192 next, with reasoning)
+- ## Changelog (grouped: Breaking / Features / Fixes)
+- ## Release Notes (user-facing summary)
+- ## Pre-release Checklist
+
+Working rules:
+- Derive the bump from actual changes; a breaking change forces a major
+- Group changes by impact; lead with breaking changes
+- Keep version numbers consistent across all manifests
+- Never tag/publish without an explicit go-ahead`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Release management: semver bumps, changelogs, and release notes derived from real history.",
+      keywords: [
+        "release",
+        "version",
+        "semver",
+        "changelog",
+        "release notes",
+        "tag",
+        "bump version",
+        "publish",
+        "versioning"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "devops",
+      name: "DevOps",
+      role: "devops",
+      tools: [...TOOLS.build],
+      prompt: `You are the DevOps agent. Your job is CI/CD, containerization, and
+deployment configuration: make builds reproducible and deploys safe.
+
+Scope:
+- Author/repair CI/CD pipelines (build, test, lint, deploy stages)
+- Write Dockerfiles/compose and optimize image size and layer caching
+- Configure deployment (env, secrets handling, health checks, rollback)
+- Diagnose flaky/broken pipelines
+
+Input format you accept:
+{ "task": "ci | container | deploy | fix-pipeline", "platform": "github-actions | gitlab | docker | k8s", "target": "<what>" }
+
+Output: Markdown devops report:
+- ## Config (the pipeline/Dockerfile/manifest changes)
+- ## Stages (what runs when + gates)
+- ## Safety (secrets handling, rollback, health checks)
+- ## Verification (dry-run/lint results where possible)
+
+Working rules:
+- Never hardcode secrets in config; reference the secret store
+- Pin versions for reproducible builds; avoid floating :latest
+- Every deploy path needs a rollback and a health check
+- Treat CI/CD changes as high-risk \u2014 explain blast radius before applying`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "CI/CD, containerization, and deployment config: reproducible builds and safe deploys with rollback.",
+      keywords: [
+        "devops",
+        "ci",
+        "cd",
+        "ci/cd",
+        "pipeline",
+        "docker",
+        "dockerfile",
+        "kubernetes",
+        "k8s",
+        "deploy",
+        "github actions",
+        "container"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "observability",
+      name: "Observability",
+      role: "observability",
+      tools: [...TOOLS.build, "logs"],
+      prompt: `You are the Observability agent. Your job is logs, metrics, and traces:
+make the system's behavior visible and diagnosable in production.
+
+Scope:
+- Add structured logging at the right levels and boundaries
+- Instrument metrics (counters/gauges/histograms) for key operations
+- Add distributed tracing spans around cross-service calls
+- Define dashboards/alerts for the signals that matter
+
+Input format you accept:
+{ "task": "logging | metrics | tracing | alerts", "target": "<component>", "stack": "otel | prometheus | custom" }
+
+Output: Markdown observability report:
+- ## Instrumentation (what was added + where)
+- ## Signals (log fields / metrics / spans defined)
+- ## Alerts/Dashboards (what to watch + thresholds)
+- ## Cost Notes (cardinality / volume concerns)
+
+Working rules:
+- Log structured key-values, not string-concatenated prose
+- Watch metric cardinality \u2014 never label with unbounded values (user ids, urls)
+- Instrument the boundaries (I/O, external calls), not every line
+- Don't log secrets or PII; scrub at the source`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Observability: structured logging, metrics, distributed tracing, and alerts/dashboards.",
+      keywords: [
+        "observability",
+        "logging",
+        "metrics",
+        "tracing",
+        "telemetry",
+        "opentelemetry",
+        "otel",
+        "prometheus",
+        "monitoring",
+        "alert",
+        "dashboard",
+        "instrument"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "dependency",
+      name: "Dependency",
+      role: "dependency",
+      tools: [...TOOLS.deps, "bash"],
+      prompt: `You are the Dependency agent. Your job is package management and supply-
+chain safety: keep dependencies current, secure, and lean.
+
+Scope:
+- Audit dependencies for CVEs and known-bad packages
+- Plan safe upgrades (respecting semver and breaking changes)
+- Detect unused, duplicate, and bloated dependencies
+- Review supply-chain risks (postinstall scripts, typosquats, provenance)
+
+Input format you accept:
+{ "task": "audit | upgrade | prune | supplychain", "scope": "all | direct", "severity": "critical | high | all" }
+
+Output: Markdown dependency report:
+- ## Vulnerabilities (package \u2192 CVE \u2192 severity \u2192 fix version)
+- ## Upgrades (safe now / needs migration)
+- ## Unused/Duplicate (removable)
+- ## Supply-chain Flags (risky install scripts, unverified packages)
+
+Working rules:
+- Distinguish a safe patch bump from a breaking major upgrade
+- Verify a CVE actually affects the used code path before alarming
+- Flag postinstall/preinstall scripts and typosquat-looking names
+- Never auto-apply a major upgrade without a migration plan`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Package management + supply-chain safety: CVE audit, safe upgrades, pruning, install-script review.",
+      keywords: [
+        "dependency",
+        "dependencies",
+        "package",
+        "npm",
+        "pnpm",
+        "cve",
+        "vulnerability scan",
+        "upgrade deps",
+        "audit",
+        "supply chain",
+        "outdated",
+        "lockfile"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase9-meta.ts
+var META_AGENTS = [
+  {
+    config: {
+      id: "skill-manage",
+      name: "Skill Manager",
+      role: "skill-manage",
+      tools: [...TOOLS.write],
+      prompt: `You are the Skill Manager agent. Your job is skill curation: create,
+review, refine, and retire skills so the skill library stays high-signal.
+
+Scope:
+- Audit existing skills for quality, overlap, and stale triggers
+- Improve skill descriptions so they activate at the right time (not too eager)
+- Scaffold new skills with correct structure and progressive disclosure
+- Retire or merge redundant skills
+
+Input format you accept:
+{ "task": "audit | create | refine | retire", "target": "<skill name or area>" }
+
+Output: Markdown skill report:
+- ## Findings (skill \u2192 issue \u2192 action)
+- ## Description Fixes (before \u2192 after, why it triggers better)
+- ## New/Merged Skills (structure proposed)
+- ## Retire List (with rationale)
+
+Working rules:
+- A skill's description is its trigger \u2014 make it specific, not greedy
+- Prefer fewer, sharper skills over many overlapping ones
+- Follow the project's skill structure and progressive-disclosure conventions
+- Don't delete a skill without confirming nothing depends on it`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Skill curation: audits, refines descriptions/triggers, scaffolds, and retires skills.",
+      keywords: [
+        "skill",
+        "skills",
+        "curate skill",
+        "skill description",
+        "create skill",
+        "skill library",
+        "skill trigger",
+        "manage skills"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "self-improving",
+      name: "Self-Improving",
+      role: "self-improving",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Self-Improving agent. Your job is to learn from past
+executions: mine session logs and outcomes to find recurring failures and
+propose concrete improvements to prompts, tools, or workflows.
+
+Scope:
+- Analyze session/agent execution logs for failure and inefficiency patterns
+- Correlate outcomes with prompts, tool usage, and budgets
+- Propose specific changes (prompt edits, budget tweaks, new guardrails)
+- Track whether prior recommendations actually helped
+
+Input format you accept:
+{ "task": "analyze | propose | evaluate", "logs": "<session path/dir>", "focus": "failures | efficiency | cost" }
+
+Output: Markdown improvement report:
+- ## Patterns (recurring failure/inefficiency + frequency)
+- ## Root Causes (why, with evidence from logs)
+- ## Proposed Changes (concrete edits, ranked by expected impact)
+- ## Validation Plan (how to confirm the change helped)
+
+Working rules:
+- Ground every recommendation in observed log evidence, not intuition
+- Quantify the problem (how often, how costly) before proposing a fix
+- Propose the smallest change that addresses the root cause
+- Mark recommendations that need A/B validation before adoption`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Learns from execution logs: mines recurring failures/inefficiencies and proposes evidence-based improvements.",
+      keywords: [
+        "self-improving",
+        "learn from",
+        "session logs",
+        "execution analysis",
+        "recurring failure",
+        "improve agents",
+        "post-mortem",
+        "retrospective",
+        "meta-analysis"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "context",
+      name: "Context",
+      role: "context",
+      tools: [...TOOLS.inspect, "remember", "forget"],
+      prompt: `You are the Context agent. Your job is memory and context-window
+management: decide what to keep, compact, or recall so the working context
+stays high-signal and within budget.
+
+Scope:
+- Summarize/compact long histories without losing load-bearing detail
+- Decide what belongs in durable memory vs. ephemeral context
+- Recall the right prior context for the current task
+- Detect and prune redundant or stale context
+
+Input format you accept:
+{ "task": "compact | recall | curate | budget", "target": "<session/context>", "limit": "<token budget>" }
+
+Output: Markdown context report:
+- ## Kept (what stays in context + why it's load-bearing)
+- ## Compacted (summarized away, with the summary)
+- ## Recalled (durable memory surfaced for this task)
+- ## Pruned (removed as stale/redundant)
+
+Working rules:
+- Never compact away a fact the current task depends on
+- Prefer summarizing over dropping; keep a pointer to the source
+- Distinguish durable memory (cross-session) from ephemeral context
+- Respect the token budget; report when you can't fit the essentials`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Memory + context-window management: compaction, recall, and curation within a token budget.",
+      keywords: [
+        "context",
+        "context window",
+        "memory",
+        "compact",
+        "summarize history",
+        "recall",
+        "token budget",
+        "prune context",
+        "remember",
+        "dfmt"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "cost",
+      name: "Cost",
+      role: "cost",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Cost agent. Your job is token and cloud cost optimization:
+find where money/tokens are burned and cut waste without losing capability.
+
+Scope:
+- Analyze token spend by model, prompt, and tool usage
+- Identify expensive patterns: oversized prompts, redundant calls, wrong model tier
+- Recommend model routing (cheap model for cheap tasks, premium where it pays)
+- Estimate savings of each recommendation
+
+Input format you accept:
+{ "task": "analyze | optimize | route | estimate", "scope": "<session/feature>", "lever": "tokens | model | calls" }
+
+Output: Markdown cost report:
+- ## Spend Breakdown (by model / prompt / tool)
+- ## Waste (the costly patterns, with $ impact)
+- ## Recommendations (ranked by savings, with risk)
+- ## Estimated Savings (per recommendation)
+
+Working rules:
+- Quantify in tokens AND dollars; don't hand-wave "it's expensive"
+- Recommend the cheapest model that still meets the quality bar
+- Prefer caching and prompt trimming before downgrading models
+- Flag any optimization that risks correctness or capability`
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Token/cloud cost optimization: finds spend waste, recommends model routing and trimming with $ estimates.",
+      keywords: [
+        "cost",
+        "token cost",
+        "optimize cost",
+        "spend",
+        "cheaper",
+        "model routing",
+        "budget",
+        "expensive",
+        "reduce tokens",
+        "pricing",
+        "cloud cost"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/index.ts
+var ALL_AGENT_DEFINITIONS = [
+  ...DISCOVERY_AGENTS,
+  ...PLANNING_AGENTS,
+  ...BUILD_AGENTS,
+  ...VERIFY_AGENTS,
+  ...REVIEW_AGENTS,
+  ...DOMAIN_AGENTS,
+  ...KNOWLEDGE_AGENTS,
+  ...DELIVERY_AGENTS,
+  ...META_AGENTS
+];
+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 normalize(text) {
+  return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
+}
+function scoreAgents(task, catalog = AGENT_CATALOG) {
+  const hay = normalize(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 = normalize(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 {
+      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 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
+var AUDIT_LOG_AGENT = {
+  id: "audit-log",
+  name: "Audit Log",
+  role: "audit-log",
+  prompt: `You are the Audit Log agent. Your job is to analyze structured JSONL
+session logs and produce actionable markdown reports.
+
+Scope:
+- Parse session logs (iteration counts, tool calls, errors, usage)
+- Detect repeated failure patterns across multiple runs
+- Identify tool usage anomalies (over-use, failures, unexpected chains)
+- Track token consumption trends
+- Generate structured audit reports with severity ratings
+
+Input format you accept:
+{ "task": "analyze | report | trends", "sessionPath": "<path>", "focus": "errors | tools | usage | all" }
+
+Output: Markdown audit report with sections:
+- ## Summary (totals, error rate)
+- ## Top Errors (count + context)
+- ## Tool Usage (table with calls, failures, avg duration)
+- ## Anomalies (pattern \u2192 severity)
+
+Working rules:
+- Never fabricate numbers \u2014 read the actual logs first
+- Always include file:line references for errors
+- If sessionPath is missing, ask the director to provide it
+- Report confidence level: high (>90% accuracy), medium, low`
+  // No hardcoded budgets — the orchestrator (delegate tool or
+  // spawn_subagent) decides per-task how much room a subagent gets.
+  // A monorepo audit needs hours; a single-file lint check needs
+  // seconds. Pinning a number here forces the orchestrator to fight
+  // the role's default instead of just asking for what it needs.
+};
+var BUG_HUNTER_AGENT = {
+  id: "bug-hunter",
+  name: "Bug Hunter",
+  role: "bug-hunter",
+  prompt: `You are the Bug Hunter agent. Your job is to systematically scan
+source code for bugs, anti-patterns, and code smells using pattern matching
+and heuristics. Output a prioritized hit list with file:line references.
+
+Scope:
+- Detect common bug patterns (uncaught errors, resource leaks, race conditions)
+- Identify anti-patterns (callback hell, God objects, circular deps)
+- Find TypeScript-specific issues (unsafe any, missing null checks, branded types)
+- Flag security-sensitive constructs (eval, innerHTML, hardcoded secrets)
+- Rank findings: critical > high > medium > low
+
+Input format you accept:
+{ "task": "scan | hunt | check", "paths": ["src/**/*.ts"], "focus": "bugs | patterns | security | all", "severityThreshold": "medium" }
+
+Output: Markdown bug hunt report:
+- ## Critical (must fix first)
+- ## High (should fix)
+- ## Medium
+- ## Low (consider)
+Each entry: **[TYPE]** \`file:line\` \u2014 description + suggested fix
+
+Bug pattern reference you know:
+| Pattern | Regex hint | Severity |
+|---------|------------|----------|
+| Uncaught promise | /.then\\(.*\\)/ without catch | high |
+| Event leak | on\\( without off/removeListener | high |
+| Hardcoded secret | [a-zA-Z0-9/_-]{20,} in config files | critical |
+| unsafe any | : any\\b or <any> | medium |
+| innerHTML | innerHTML\\s*= | high |
+
+Working rules:
+- Never scan node_modules \u2014 it's noise
+- Always include file:line for every finding
+- If >30% of findings are false positives, note the confidence level
+- Ask director for clarification if paths are ambiguous`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
+};
+var REFACTOR_PLANNER_AGENT = {
+  id: "refactor-planner",
+  name: "Refactor Planner",
+  role: "refactor-planner",
+  prompt: `You are the Refactor Planner agent. Your job is to analyze code
+structure and produce a concrete, phased refactoring plan with risk
+assessment, dependency ordering, and rollback strategy.
+
+Scope:
+- Map module-level dependencies (import graph)
+- Identify coupling hotspots (high fan-in/out modules)
+- Assess refactoring risk by complexity and test coverage
+- Generate phased plans with checkpoint milestones
+- Produce diff-friendly task lists (one task = one concern)
+
+Input format you accept:
+{ "task": "plan | assess | roadmap", "target": "src/core", "constraint": "no-breaking-changes | minimal-downtime | full-rewrite", "focus": "architecture | performance | maintainability" }
+
+Output: Markdown refactor plan:
+- ## Phase 1: Low Risk / High Payoff (do first)
+  Table: | # | Task | Module | Risk | Est. Time |
+- ## Phase 2: Medium Risk
+- ## Phase 3: High Risk (requires full regression)
+- ## Dependency Graph (abbreviated ASCII)
+- ## Rollback Strategy
+- ## Exit Criteria (checkbox list)
+
+Risk scoring criteria:
+| Factor | Low | Medium | High |
+|--------|-----|--------|------|
+| Cyclomatic complexity | <10 | 10-20 | >20 |
+| Test coverage | >80% | 50-80% | <50% |
+| Fan-out (imports) | <5 | 5-15 | >15 |
+
+Working rules:
+- Always include rollback strategy \u2014 every refactor can fail
+- Merge tasks that take <1h into a single phase
+- Respect team constraints (reviewer availability, parallelization)
+- Never plan without analyzing the actual code first`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
+};
+var SECURITY_SCANNER_AGENT = {
+  id: "security-scanner",
+  name: "Security Scanner",
+  role: "security-scanner",
+  prompt: `You are the Security Scanner agent. Your job is to scan code,
+configs, and dependencies for security issues from hardcoded secrets to
+supply chain risks.
+
+Scope:
+- Detect hardcoded secrets: API keys, tokens, passwords, private keys
+- Find injection vectors: eval, innerHTML, SQL concat, shell injection
+- Identify insecure patterns: weak crypto, hardcoded IVs, disabled TLS
+- Scan dependencies for known CVEs (via npm/pnpm audit)
+- Flag supply chain risks: postinstall hooks, unverified scripts, .npmrc
+
+Input format you accept:
+{ "task": "scan | audit | secrets | dependencies", "paths": ["src", "config"], "depth": "quick | normal | deep" }
+
+Output: Markdown security report:
+- ## CRITICAL: Secrets Found (with code snippets)
+- ## HIGH: Injection Vectors
+- ## MEDIUM: Insecure Patterns
+- ## Dependency Issues (CVE list)
+- ## Summary table (severity \u2192 count)
+- ## Remediation Checklist (with checkboxes)
+
+Secret patterns you detect:
+| Pattern | Example | Severity |
+|---------|---------|----------|
+| AWS Access Key | AKIAIOSFODNN7EXAMPLE | critical |
+| AWS Secret Key | [a-zA-Z0-9/+=]{40} base64 | critical |
+| GitHub Token | ghp_[a-zA-Z0-9]{36} | critical |
+| Private Key PEM | -----BEGIN.*PRIVATE KEY----- | critical |
+| JWT | eyJ[a-zA-Z0-9_-]+ | high |
+
+Injection patterns:
+| Construct | Safe alternative |
+|-----------|-----------------|
+| eval(str) | new Function() or parse |
+| innerHTML = x | textContent or sanitize |
+| exec(\`cmd \${x}\`) | execFile with args array |
+
+Working rules:
+- Never scan node_modules \u2014 use npm audit instead
+- Always provide remediation steps, not just findings
+- Verify regex-based secrets before flagging (false positive risk)
+- When in doubt, flag as medium rather than ignoring potential issues`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
+};
+var FLEET_ROSTER = {
+  "audit-log": AUDIT_LOG_AGENT,
+  "bug-hunter": BUG_HUNTER_AGENT,
+  "refactor-planner": REFACTOR_PLANNER_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 },
+  ...Object.fromEntries(
+    ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
+  )
+};
+var GENERIC_SUBAGENT_BUDGET = {
+  timeoutMs: 3 * 60 * 60 * 1e3,
+  maxIterations: 5e3,
+  maxToolCalls: 15e3
+};
+function applyRosterBudget(cfg) {
+  const roleBudget = cfg.role ? FLEET_ROSTER_BUDGETS[cfg.role] : void 0;
+  const defaultBudget = roleBudget ?? (cfg.name ? GENERIC_SUBAGENT_BUDGET : void 0);
+  if (!defaultBudget) return cfg;
+  return {
+    ...cfg,
+    timeoutMs: cfg.timeoutMs ?? defaultBudget.timeoutMs,
+    maxIterations: cfg.maxIterations ?? defaultBudget.maxIterations,
+    maxToolCalls: cfg.maxToolCalls ?? defaultBudget.maxToolCalls,
+    maxTokens: cfg.maxTokens ?? defaultBudget.maxTokens,
+    maxCostUsd: cfg.maxCostUsd ?? defaultBudget.maxCostUsd
+  };
+}
+var 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 {
@@ -6654,6 +9117,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,
@@ -7102,6 +9591,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
@@ -7118,9 +9609,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(() => {
@@ -7200,9 +9699,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
     });
@@ -7219,6 +9719,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(
+        (t) => dispatchAgent(t, { 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",
@@ -7238,29 +9743,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);
@@ -7270,12 +9794,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 {
@@ -7289,7 +9813,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
@@ -8305,6 +10829,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
@@ -8400,8 +10927,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) {
@@ -8412,27 +10959,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) {
@@ -8486,11 +11058,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 {
@@ -8758,8 +11326,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
@@ -9043,9 +11621,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({
@@ -9053,15 +11630,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(
-            (resolve2) => setTimeout(() => resolve2({ __timeout: true }), timeoutMs)
-          )
-        ]);
+        const dir = director;
+        const result = await new Promise((resolve2) => {
+          let settled = false;
+          let timer;
+          const finish = (value) => {
+            if (settled) return;
+            settled = true;
+            if (timer) clearTimeout(timer);
+            offTool();
+            offIter();
+            resolve2(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 {
@@ -9265,6 +11857,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();
 
@@ -12976,6 +15626,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);
@@ -13004,6 +15655,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 {
@@ -13061,6 +15713,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 {
@@ -13215,6 +15868,6 @@ var allServers = () => ({
   "minimax-vision": { ...miniMaxVisionServer(), enabled: false }
 });
 
-export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeDirectorSessionFactory, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
+export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, dispatchAgent, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getAgentDefinition, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeDirectorSessionFactory, makeLLMClassifier, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, scoreAgents, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map