@wrongstack/core 0.4.1 → 0.5.0

package/dist/coordination/index.js

@@ -450,7 +450,9 @@ var FleetBus = class {
       "session.damaged",
       "compaction.fired",
       "compaction.failed",
-      "token.threshold"
+      "token.threshold",
+      // Subagent hit a soft budget limit — coordinator can extend or stop.
+      "budget.threshold_reached"
     ];
     const offs = [];
     for (const t of FORWARDED_TYPES) {
@@ -713,6 +715,21 @@ var BudgetExceededError = class extends Error {
     this.observed = observed;
   }
 };
+var BudgetThresholdSignal = class extends Error {
+  kind;
+  limit;
+  used;
+  /** Resolves to 'extend' (with optional new limits) or 'stop' */
+  decision;
+  constructor(kind, limit, used, decision) {
+    super(`Budget soft limit: ${kind} (limit=${limit}, used=${used})`);
+    this.name = "BudgetThresholdSignal";
+    this.kind = kind;
+    this.limit = limit;
+    this.used = used;
+    this.decision = decision;
+  }
+};
 var SubagentBudget = class {
   limits;
   iterations = 0;
@@ -721,22 +738,111 @@ var SubagentBudget = class {
   tokenOutput = 0;
   costUsd = 0;
   startTime = null;
+  _onThreshold;
+  /**
+   * Injected by the runner when wiring the budget to its EventBus.
+   * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
+   */
+  _events;
+  /**
+   * Optional callback for soft-limit handling. When set, the budget will
+   * call this instead of throwing when a limit is first reached. The
+   * handler decides whether to throw, continue, or ask the coordinator.
+   */
+  get onThreshold() {
+    return this._onThreshold;
+  }
+  set onThreshold(fn) {
+    this._onThreshold = fn;
+  }
   constructor(limits = {}) {
     this.limits = Object.freeze({ ...limits });
   }
   start() {
     this.startTime = Date.now();
   }
+  /** Returns true if we're within 10% of any limit — useful for pre-flight checks. */
+  isNearLimit() {
+    const { maxIterations, maxToolCalls, maxTokens, maxCostUsd } = this.limits;
+    if (maxIterations && this.iterations >= maxIterations * 0.9) return true;
+    if (maxToolCalls && this.toolCalls >= maxToolCalls * 0.9) return true;
+    if (maxTokens && this.tokenInput + this.tokenOutput >= maxTokens * 0.9) return true;
+    if (maxCostUsd && this.costUsd >= maxCostUsd * 0.9) return true;
+    return false;
+  }
+  /**
+   * Synchronous budget check — always throws synchronously so callers
+   * (especially test event handlers using `expect().toThrow()`) get an
+   * unhandled rejection when the budget is exceeded without a handler.
+   * When `onThreshold` IS configured, the actual async threshold-handling
+   * is dispatched as a fire-and-forget promise.
+   */
+  checkLimit(kind, used, limit) {
+    if (kind === "timeout" || !this._onThreshold) {
+      throw new BudgetExceededError(kind, limit, used);
+    }
+    void this.checkLimitAsync(kind, used, limit);
+  }
+  /**
+   * Async threshold negotiation with the coordinator. Fire-and-forget —
+   * any error thrown here becomes an unhandled rejection in the test environment
+   * because the runner's catch only handles the synchronous throw from `checkLimit`.
+   */
+  async checkLimitAsync(kind, used, limit) {
+    const result = this._onThreshold({
+      kind,
+      used,
+      limit,
+      // Inject a requestDecision helper the handler can call to emit the
+      // budget.threshold_reached event and wait for the coordinator's verdict.
+      // The runner wires this by injecting its EventBus into ctx.budget._events.
+      requestDecision: () => {
+        return new Promise((resolve) => {
+          this._events?.emit("budget.threshold_reached", {
+            kind,
+            used,
+            limit,
+            timeoutMs: 3e4,
+            extend: (extra) => resolve({ extend: extra }),
+            deny: () => resolve("stop")
+          });
+        });
+      }
+    });
+    if (result === "throw") {
+      throw new BudgetExceededError(kind, limit, used);
+    }
+    if (result === "continue") {
+      return;
+    }
+    const decision = await result;
+    if (decision === "stop") {
+      throw new BudgetExceededError(kind, limit, used);
+    }
+    const ext = decision.extend;
+    if (ext.maxIterations !== void 0) {
+      this.limits.maxIterations = ext.maxIterations;
+    }
+    if (ext.maxToolCalls !== void 0) {
+      this.limits.maxToolCalls = ext.maxToolCalls;
+    }
+    if (ext.maxTokens !== void 0) {
+      this.limits.maxTokens = ext.maxTokens;
+    }
+    if (ext.maxCostUsd !== void 0) {
+      this.limits.maxCostUsd = ext.maxCostUsd;
+    }
+  }
   recordIteration() {
     this.iterations++;
     if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
-      throw new BudgetExceededError("iterations", this.limits.maxIterations, this.iterations);
+      void this.checkLimit("iterations", this.iterations, this.limits.maxIterations);
     }
   }
   recordToolCall() {
     this.toolCalls++;
     if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
-      throw new BudgetExceededError("tool_calls", this.limits.maxToolCalls, this.toolCalls);
+      void this.checkLimit("tool_calls", this.toolCalls, this.limits.maxToolCalls);
     }
   }
   recordUsage(usage, costUsd = 0) {
@@ -745,10 +851,10 @@ var SubagentBudget = class {
     this.costUsd += costUsd;
     const totalTokens = this.tokenInput + this.tokenOutput;
     if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
-      throw new BudgetExceededError("tokens", this.limits.maxTokens, totalTokens);
+      void this.checkLimit("tokens", totalTokens, this.limits.maxTokens);
     }
     if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
-      throw new BudgetExceededError("cost", this.limits.maxCostUsd, this.costUsd);
+      void this.checkLimit("cost", this.costUsd, this.limits.maxCostUsd);
     }
   }
   /**
@@ -782,6 +888,198 @@ var SubagentBudget = class {
   }
 };
 
+// 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
+};
+var FLEET_ROSTER_BUDGETS = {
+  "audit-log": { timeoutMs: 5 * 60 * 1e3, maxIterations: 80, maxToolCalls: 300 },
+  "bug-hunter": { timeoutMs: 10 * 60 * 1e3, maxIterations: 120, maxToolCalls: 400 },
+  "refactor-planner": { timeoutMs: 8 * 60 * 1e3, maxIterations: 100, maxToolCalls: 350 },
+  "security-scanner": { timeoutMs: 10 * 60 * 1e3, maxIterations: 120, maxToolCalls: 400 }
+};
+function applyRosterBudget(cfg) {
+  const defaultBudget = FLEET_ROSTER_BUDGETS[cfg.role ?? ""];
+  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);
+
 // src/coordination/multi-agent-coordinator.ts
 var DefaultMultiAgentCoordinator = class extends EventEmitter {
   coordinatorId;
@@ -1022,12 +1320,13 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     task.subagentId = subagentId;
     subagent.context.tasks.push(task);
     this.emit("task.assigned", { task, subagentId });
+    const configWithRosterDefaults = applyRosterBudget(subagent.config);
     const budget = new SubagentBudget({
-      maxIterations: subagent.config.maxIterations ?? this.config.defaultBudget?.maxIterations,
-      maxToolCalls: task.maxToolCalls ?? subagent.config.maxToolCalls ?? this.config.defaultBudget?.maxToolCalls,
-      maxTokens: subagent.config.maxTokens ?? this.config.defaultBudget?.maxTokens,
-      maxCostUsd: subagent.config.maxCostUsd ?? this.config.defaultBudget?.maxCostUsd,
-      timeoutMs: task.timeoutMs ?? subagent.config.timeoutMs ?? this.config.defaultBudget?.timeoutMs
+      maxIterations: configWithRosterDefaults.maxIterations ?? this.config.defaultBudget?.maxIterations,
+      maxToolCalls: task.maxToolCalls ?? configWithRosterDefaults.maxToolCalls ?? this.config.defaultBudget?.maxToolCalls,
+      maxTokens: configWithRosterDefaults.maxTokens ?? this.config.defaultBudget?.maxTokens,
+      maxCostUsd: configWithRosterDefaults.maxCostUsd ?? this.config.defaultBudget?.maxCostUsd,
+      timeoutMs: task.timeoutMs ?? configWithRosterDefaults.timeoutMs ?? this.config.defaultBudget?.timeoutMs
     });
     subagent.activeBudget = budget;
     if (!this.runner) {
@@ -1565,6 +1864,36 @@ var Director = class {
       this.scheduleManifest();
     };
     this.coordinator.on("task.completed", this.taskCompletedListener);
+    const extendCounts = /* @__PURE__ */ new Map();
+    this.fleet.filter("budget.threshold_reached", (e) => {
+      const payload = e.payload;
+      const guardKey = `${e.subagentId}:${payload.kind}`;
+      const prior = extendCounts.get(guardKey) ?? 0;
+      if (prior >= 2) {
+        payload.deny();
+        extendCounts.delete(guardKey);
+        return;
+      }
+      extendCounts.set(guardKey, prior + 1);
+      setTimeout(() => {
+        const extra = {};
+        switch (payload.kind) {
+          case "iterations":
+            extra.maxIterations = Math.min(payload.used + 50, 500);
+            break;
+          case "tool_calls":
+            extra.maxToolCalls = Math.min(Math.ceil(payload.limit * 1.5), 1e3);
+            break;
+          case "tokens":
+            extra.maxTokens = Math.min(Math.ceil(payload.limit * 1.5), 5e5);
+            break;
+          case "cost":
+            extra.maxCostUsd = Math.min(payload.limit * 1.5, 10);
+            break;
+        }
+        payload.extend(extra);
+      }, Math.min(payload.timeoutMs, 3e4));
+    });
   }
   /** Best-effort session-writer append. Swallows failures — the director
    *  must not break a fleet run because the session JSONL handle closed. */
@@ -2024,65 +2353,68 @@ function createDelegateTool(opts) {
       if (typeof i.task !== "string" || !i.task.trim()) {
         return { ok: false, error: "`task` is required." };
       }
-      let director = await opts.host.ensureDirector();
-      if (!director) {
-        director = await opts.host.promoteToDirector();
-      }
-      if (!director) {
-        const reason = opts.host.getPromotionBlockReason?.();
-        return {
-          ok: false,
-          error: reason ?? "Director could not be activated \u2014 multi-agent host already running in legacy non-director mode. Restart with `--director` for fleet support."
-        };
-      }
-      const timeoutMs = i.timeoutMs ?? defaultTimeoutMs;
-      let cfg;
-      if (i.role) {
-        const base = opts.roster?.[i.role];
-        if (!base) {
+      try {
+        let director = await opts.host.ensureDirector();
+        if (!director) {
+          director = await opts.host.promoteToDirector();
+        }
+        if (!director) {
+          const reason = opts.host.getPromotionBlockReason?.();
           return {
             ok: false,
-            error: `Unknown role "${i.role}". Available: ${rosterIds.join(", ") || "(no roster configured)"}.`
+            error: reason ?? "Director could not be activated \u2014 multi-agent host already running in legacy non-director mode. Restart with `--director` for fleet support."
           };
         }
-        cfg = instantiateRosterConfig2(i.role, base);
-        if (i.systemPromptOverride) cfg.systemPromptOverride = i.systemPromptOverride;
-        if (i.provider) cfg.provider = i.provider;
-        if (i.model) cfg.model = i.model;
-      } else {
-        if (!i.name) {
-          return {
-            ok: false,
-            error: "Either `role` (from the roster) or `name` is required."
+        const timeoutMs = i.timeoutMs ?? defaultTimeoutMs;
+        let cfg;
+        if (i.role) {
+          const base = opts.roster?.[i.role];
+          if (!base) {
+            return {
+              ok: false,
+              error: `Unknown role "${i.role}". Available: ${rosterIds.join(", ") || "(no roster configured)"}.`
+            };
+          }
+          cfg = instantiateRosterConfig2(i.role, base);
+          if (i.systemPromptOverride) cfg.systemPromptOverride = i.systemPromptOverride;
+          if (i.provider) cfg.provider = i.provider;
+          if (i.model) cfg.model = i.model;
+        } else {
+          if (!i.name) {
+            return {
+              ok: false,
+              error: "Either `role` (from the roster) or `name` is required."
+            };
+          }
+          cfg = {
+            name: i.name,
+            provider: i.provider,
+            model: i.model,
+            systemPromptOverride: i.systemPromptOverride
           };
         }
-        cfg = {
-          name: i.name,
-          provider: i.provider,
-          model: i.model,
-          systemPromptOverride: i.systemPromptOverride
-        };
-      }
-      if (typeof i.maxIterations === "number" && i.maxIterations > 0) {
-        cfg.maxIterations = i.maxIterations;
-      }
-      if (typeof i.maxToolCalls === "number" && i.maxToolCalls > 0) {
-        cfg.maxToolCalls = i.maxToolCalls;
-      }
-      const SUBAGENT_TIMEOUT_BUFFER_MS = 3e4;
-      const desiredSubTimeout = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
-      if (!cfg.timeoutMs || cfg.timeoutMs > desiredSubTimeout) {
-        cfg.timeoutMs = desiredSubTimeout;
-      }
-      try {
+        if (typeof i.maxIterations === "number" && i.maxIterations > 0) {
+          cfg.maxIterations = i.maxIterations;
+        }
+        if (typeof i.maxToolCalls === "number" && i.maxToolCalls > 0) {
+          cfg.maxToolCalls = i.maxToolCalls;
+        }
+        const SUBAGENT_TIMEOUT_BUFFER_MS = 3e4;
+        const desiredSubTimeout = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
+        if (!cfg.timeoutMs || cfg.timeoutMs > desiredSubTimeout) {
+          cfg.timeoutMs = desiredSubTimeout;
+        }
         const subagentId = await director.spawn(cfg);
         const taskId = await director.assign({
-          id: "",
+          id: `${randomUUID()}`,
           description: i.task,
           subagentId
         });
         const result = await Promise.race([
-          director.awaitTasks([taskId]).then((r) => r[0]),
+          director.awaitTasks([taskId]).then((r) => {
+            if (!r[0]) throw new Error(`Task "${taskId}" not found in completed results`);
+            return r[0];
+          }),
           new Promise(
             (resolve) => setTimeout(() => resolve({ __timeout: true }), timeoutMs)
           )
@@ -2156,7 +2488,7 @@ function hintForKind(kind, retryable, backoffMs) {
     case "budget_tool_calls":
     case "budget_tokens":
     case "budget_cost":
-      return "Subagent exhausted its budget. Raise the matching `max*` field on the next delegate or narrow task scope.";
+      return "Subagent exhausted its budget. The coordinator may auto-extend; otherwise raise the matching `max*` field (e.g. maxToolCalls: 600) on the next delegate, or split the task.";
     case "budget_timeout":
       return "Subagent hit its wall-clock budget. Raise `timeoutMs` on the next delegate or split the task.";
     case "aborted_by_parent":
@@ -2229,8 +2561,21 @@ function makeAgentSubagentRunner(opts) {
     const { agent, events } = factoryResult;
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
+    ctx.budget._events = events;
     let budgetError = null;
     const onBudgetError = (err) => {
+      if (err instanceof BudgetThresholdSignal) {
+        err.decision.then((decision) => {
+          if (decision === "stop") {
+            budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
+            aborter.abort();
+          }
+        }).catch(() => {
+          budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
+          aborter.abort();
+        });
+        return;
+      }
       aborter.abort();
       budgetError = err instanceof BudgetExceededError ? err : new BudgetExceededError(
         "tool_calls",
@@ -2260,7 +2605,7 @@ function makeAgentSubagentRunner(opts) {
         try {
           ctx.budget.recordUsage(e.usage);
         } catch (e2) {
-          onBudgetError(e2);
+          void onBudgetError(e2);
         }
       }),
       events.on("iteration.started", () => {
@@ -2268,7 +2613,7 @@ function makeAgentSubagentRunner(opts) {
           ctx.budget.recordIteration();
           ctx.budget.checkTimeout();
         } catch (e) {
-          onBudgetError(e);
+          void onBudgetError(e);
         }
       }),
       // D3: cooperative timeout enforcement DURING a long tool call.
@@ -2288,7 +2633,7 @@ function makeAgentSubagentRunner(opts) {
         try {
           ctx.budget.checkTimeout();
         } catch (e) {
-          onBudgetError(e);
+          void onBudgetError(e);
         }
       })
     );
@@ -2793,180 +3138,6 @@ function makeDirectorSessionFactory(opts) {
   };
 }
 
-// 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
-};
-var ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
-
-export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BudgetExceededError, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultMultiAgentCoordinator, Director, DirectorBudgetError, FLEET_ROSTER, FleetBus, FleetUsageAggregator, InMemoryAgentBridge, InMemoryBridgeTransport, REFACTOR_PLANNER_AGENT, SECURITY_SCANNER_AGENT, SubagentBudget, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMessage, makeAgentSubagentRunner, makeDirectorSessionFactory, rosterSummaryFromConfigs };
+export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BudgetExceededError, BudgetThresholdSignal, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultMultiAgentCoordinator, Director, DirectorBudgetError, FLEET_ROSTER, FleetBus, FleetUsageAggregator, InMemoryAgentBridge, InMemoryBridgeTransport, REFACTOR_PLANNER_AGENT, SECURITY_SCANNER_AGENT, SubagentBudget, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMessage, makeAgentSubagentRunner, makeDirectorSessionFactory, rosterSummaryFromConfigs };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map