@wrongstack/core 0.7.8 → 0.8.2

package/dist/defaults/index.d.ts

@@ -1,18 +1,18 @@
 export { D as DefaultLogger, a as DefaultLoggerOptions } from '../logger-bOzkF5LL.js';
-export { A as AbandonedSession, a as AttachmentStoreOptions, C as ConfigLoaderOptions, b as ConfigMigration, c as ConfigMigrationError, d as ConfigSource, D as DEFAULT_CONFIG_MIGRATIONS, e as DefaultAttachmentStore, f as DefaultConfigLoader, g as DefaultConfigStore, h as DefaultMemoryStore, i as DefaultSessionStore, M as MemoryStoreOptions, j as MigrationContext, k as MigrationResult, P as PersistedQueueItem, l as PlanFile, m as PlanItem, n as PlanTemplate, Q as QueueStore, R as RecoveryLock, o as RecoveryLockOptions, S as SessionAnalyzer, p as SessionStoreOptions, T as TodosCheckpointFile, q as addPlanItem, r as attachPlanCheckpoint, s as attachTodosCheckpoint, t as clearPlan, u as deriveTodosFromPlanItem, v as emptyPlan, w as formatPlan, x as formatPlanTemplates, y as getPlanTemplate, z as listPlanTemplates, B as loadPlan, E as loadTodosCheckpoint, F as removePlanItem, G as runConfigMigrations, H as savePlan, I as saveTodosCheckpoint, J as setPlanItemStatus } from '../plan-templates-C-IOLJ8Q.js';
+export { A as AbandonedSession, a as AttachmentStoreOptions, C as ConfigLoaderOptions, b as ConfigMigration, c as ConfigMigrationError, d as ConfigSource, D as DEFAULT_CONFIG_MIGRATIONS, e as DefaultAttachmentStore, f as DefaultConfigLoader, g as DefaultConfigStore, h as DefaultMemoryStore, i as DefaultSessionStore, M as MemoryStoreOptions, j as MigrationContext, k as MigrationResult, P as PersistedQueueItem, l as PlanFile, m as PlanItem, n as PlanTemplate, Q as QueueStore, R as RecoveryLock, o as RecoveryLockOptions, S as SessionAnalyzer, p as SessionStoreOptions, T as TodosCheckpointFile, q as addPlanItem, r as attachPlanCheckpoint, s as attachTodosCheckpoint, t as clearPlan, u as deriveTodosFromPlanItem, v as emptyPlan, w as formatPlan, x as formatPlanTemplates, y as getPlanTemplate, z as listPlanTemplates, B as loadPlan, E as loadTodosCheckpoint, F as removePlanItem, G as runConfigMigrations, H as savePlan, I as saveTodosCheckpoint, J as setPlanItemStatus } from '../plan-templates-BnlpEkX8.js';
 export { D as DefaultSessionReader } from '../session-reader-DsadjyF9.js';
 export { D as DirectorStateCheckpoint, a as DirectorStateSnapshot, b as DirectorSubagentState, c as DirectorTaskState, l as loadDirectorState } from '../director-state-BmYi3DGA.js';
-export { D as DefaultSecretScrubber, a as DefaultSecretVault, S as SecretVaultOptions, d as decryptConfigSecrets, e as encryptConfigSecrets, m as migratePlaintextSecrets, r as rewriteConfigEncrypted } from '../secret-scrubber-DXkhwuka.js';
-export { A as AutoApprovePermissionPolicy, D as DefaultPermissionPolicy, P as PermissionPolicyOptions } from '../permission-policy-D5Gj1o2K.js';
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-CSwXjifK.js';
+export { D as DefaultSecretScrubber, a as DefaultSecretVault, S as SecretVaultOptions, d as decryptConfigSecrets, e as encryptConfigSecrets, m as migratePlaintextSecrets, r as rewriteConfigEncrypted } from '../secret-scrubber-C0n1EqrC.js';
+export { A as AutoApprovePermissionPolicy, D as DefaultPermissionPolicy, P as PermissionPolicyOptions } from '../permission-policy-BBa1M1xc.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-QwfWnQZ8.js';
 export { AutoCompactionMiddleware, AutonomousRunner, AutonomousRunnerOptions, AutonomyPromptContributorOptions, DefaultSkillLoader, DoneCheckResult, DoneConditionChecker, EternalAutonomyEngine, EternalAutonomyOptions, EternalEngineState, IntelligentCompactor, IntelligentCompactorOptions, ParallelEngineState, ParallelEternalEngine, ParallelEternalOptions, SelectiveCompactor, SelectiveCompactorOptions, SkillLoaderOptions, buildGoalPreamble, makeAutonomyPromptContributor } from '../execution/index.js';
-import { P as ProviderRunner, R as RunProviderOptions } from '../provider-runner-iST8U3ni.js';
+import { P as ProviderRunner, R as RunProviderOptions } from '../provider-runner-BrA0XR-l.js';
 import { q as Response } from '../context-z2x5gv_V.js';
-export { a as AGENTS_BY_PHASE, b as AGENT_CATALOG, c as ALL_AGENT_DEFINITIONS, d as ALL_FLEET_AGENTS, e as AUDIT_LOG_AGENT, f as AutoExtendCeiling, g as AutoExtendPolicy, B as BUG_HUNTER_AGENT, C as CreateDelegateToolOptions, D as DEFAULT_DIRECTOR_PREAMBLE, h as DEFAULT_SUBAGENT_BASELINE, i as DelegateHost, j as Director, k as DirectorPromptParts, l as DirectorSessionFactory, m as DirectorSessionFactoryOptions, F as FLEET_ROSTER, n as FLEET_ROSTER_BUDGETS, s as FleetRosterBudget, t as FleetSpawnBudgetError, I as ICoordinator, u as IFleetManager, N as NULL_FLEET_BUS, R as REFACTOR_PLANNER_AGENT, S as SECURITY_SCANNER_AGENT, v as SubagentPromptParts, w as applyRosterBudget, x as attachAutoExtend, y as composeDirectorPrompt, z as composeSubagentPrompt, E as createDelegateTool, G as getAgentDefinition, H as makeDirectorSessionFactory, J as rosterSummaryFromConfigs } from '../null-fleet-bus-BZUrXVcd.js';
-export { A as AgentBudgetTier, a as AgentCapability, b as AgentDefinition, c as AgentPhase, D as DEFAULT_DISPATCH_ROLE, d as DefaultMultiAgentCoordinator, e as DispatchCandidate, f as DispatchClassifier, g as DispatchMethod, h as DispatchOptions, i as DispatchResult, j as MultiAgentCoordinatorOptions, k as dispatchAgent, m as makeLLMClassifier, s as scoreAgents } from '../multi-agent-coordinator-3Ypfg-hr.js';
-export { c as BudgetExceededError, d as BudgetKind, e as BudgetLimits, i as BudgetUsage, l as SubagentBudget } from '../multi-agent-7OK4pEKW.js';
-export { A as AgentFactory, a as AgentFactoryResult, b as AgentRunnerOptions, F as FleetBus, c as FleetEvent, d as FleetHandler, e as FleetUsage, f as FleetUsageAggregator, S as SubagentUsageSnapshot, m as makeAgentSubagentRunner } from '../agent-subagent-runner-B2zguWzh.js';
-export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-hXRN-GO_.js';
+export { a as AGENTS_BY_PHASE, b as AGENT_CATALOG, c as ALL_AGENT_DEFINITIONS, d as ALL_FLEET_AGENTS, e as AUDIT_LOG_AGENT, f as AutoExtendCeiling, g as AutoExtendPolicy, B as BUG_HUNTER_AGENT, C as CreateDelegateToolOptions, D as DEFAULT_DIRECTOR_PREAMBLE, h as DEFAULT_SUBAGENT_BASELINE, i as DelegateHost, j as Director, k as DirectorPromptParts, l as DirectorSessionFactory, m as DirectorSessionFactoryOptions, F as FLEET_ROSTER, n as FLEET_ROSTER_BUDGETS, s as FleetRosterBudget, t as FleetSpawnBudgetError, I as ICoordinator, u as IFleetManager, N as NULL_FLEET_BUS, R as REFACTOR_PLANNER_AGENT, S as SECURITY_SCANNER_AGENT, v as SubagentPromptParts, w as applyRosterBudget, x as attachAutoExtend, y as composeDirectorPrompt, z as composeSubagentPrompt, E as createDelegateTool, G as getAgentDefinition, H as makeDirectorSessionFactory, J as rosterSummaryFromConfigs } from '../null-fleet-bus-sKnVwEd8.js';
+export { A as AgentBudgetTier, a as AgentCapability, b as AgentDefinition, c as AgentPhase, D as DEFAULT_DISPATCH_ROLE, d as DefaultMultiAgentCoordinator, e as DispatchCandidate, f as DispatchClassifier, g as DispatchMethod, h as DispatchOptions, i as DispatchResult, j as MultiAgentCoordinatorOptions, k as dispatchAgent, m as makeLLMClassifier, s as scoreAgents } from '../multi-agent-coordinator-IQKrMfXz.js';
+export { c as BudgetExceededError, d as BudgetKind, e as BudgetLimits, j as BudgetUsage, m as SubagentBudget } from '../multi-agent-CRMznZmf.js';
+export { A as AgentFactory, a as AgentFactoryResult, b as AgentRunnerOptions, F as FleetBus, c as FleetEvent, d as FleetHandler, e as FleetUsage, f as FleetUsageAggregator, S as SubagentUsageSnapshot, m as makeAgentSubagentRunner } from '../agent-subagent-runner-Cav3yEJM.js';
+export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-DPxcUVkn.js';
 export { D as DefaultModelsRegistry, a as DefaultModelsRegistryOptions, c as classifyFamily } from '../models-registry-OG_30xqZ.js';
 export { DefaultModeStore, LLMSelector, LLMSelectorOptions, ModeLoaderOptions, loadProjectModes, loadUserModes } from '../models/index.js';
 export { AISpecBuilder, AISpecBuilderOptions, AISpecPhase, AISpecSession, AutoExecutor, AutoExecutorOptions, BottleneckTask, CollectedAnswer, CriticalPathAnalysis, DefaultTaskStore, ExecutionSummary, GeneratedTask, RunResult, SPEC_TEMPLATES, SddParallelRun, SddParallelRunOptions, SddProgress, SddTaskDecomposer, SddTaskDecomposerOptions, SpecDiff, SpecDrivenDev, SpecDrivenDevOptions, SpecIndexEntry, SpecParser, SpecStore, SpecStoreOptions, SpecVersion, SpecVersioning, TaskBatch, TaskExecutionContext, TaskExecutionResult, TaskFlow, TaskFlowEventMap, TaskFlowEventName, TaskFlowExecutionContext, TaskFlowOptions, TaskFlowPhase, TaskGenerator, TaskGeneratorOptions, TaskGraphIndexEntry, TaskGraphStore, TaskGraphStoreOptions, TaskStore, TaskTracker, TaskTrackerOptions, TaskTransition, WaveResult, analyzeCriticalPath, createAutoExecutor, getTemplate, listTemplates, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, templateToMarkdown } from '../sdd/index.js';
@@ -20,17 +20,17 @@ export { DefaultHealthRegistry, InMemoryMetricsSink, MetricsServerHandle, Metric
 export { C as ContextManagerAction, a as ContextManagerInput, b as ContextManagerResult, c as ContextManagerToolOptions, d as allServers, e as awsServer, f as blockServer, g as braveSearchServer, h as context7Server, i as contextManagerTool, j as createContextManagerTool, k as everArtServer, l as filesystemServer, m as githubServer, n as googleMapsServer, o as miniMaxVisionServer, s as sentinelServer, p as slackServer, z as zaiVisionServer } from '../mcp-servers-n2L9ohMX.js';
 export { D as DEFAULT_CONTEXT_CONFIG, a as DEFAULT_TOOLS_CONFIG } from '../default-config-DvRSTELf.js';
 import '../logger-DDd5C--Z.js';
-import '../events-D4pGukpI.js';
+import '../events-DyhxkstG.js';
 import '../memory-CEXuo7sz.js';
 import '../wstack-paths-gCrJ631C.js';
 import '../config-Bi4Q0fnz.js';
 import '../models-registry-BcYJDKLm.js';
 import '../secret-vault-DoISxaKO.js';
-import '../secret-scrubber-nI8qjaqW.js';
+import '../secret-scrubber-CyE1-EMG.js';
 import '../input-reader-E-ffP2ee.js';
 import '../compactor-Mw7-rNyb.js';
 import '../retry-policy-OwtKNxo8.js';
-import '../index-BtNRyJft.js';
+import '../index-oYZeWsuJ.js';
 import '../system-prompt-CWA6ml-d.js';
 import '../observability-BhnVLBLS.js';
 import '../selector-DkvgYVS4.js';

package/dist/defaults/index.js

@@ -3213,10 +3213,36 @@ var DefaultPermissionPolicy = class {
     return void 0;
   }
 };
-var AutoApprovePermissionPolicy = class {
+var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
+  /**
+   * Tools that are too dangerous to auto-approve even in a delegated
+   * subagent context. Subagents run non-interactively under a director
+   * and cannot answer prompts, but inherited authorization does not
+   * imply blanket permission for destructive or privilege-escalating
+   * operations. These tools remain at their declared `permission`
+   * level so the leader must explicitly allow them per-spawn.
+   */
+  static DENY = /* @__PURE__ */ new Set([
+    "bash",
+    // arbitrary shell — use exec for constrained shell
+    "write",
+    // arbitrary file write
+    "scaffold",
+    // arbitrary file generation outside project root
+    "patch",
+    // arbitrary diff application
+    "install",
+    // installs from arbitrary package sources
+    "exec"
+    // restricted shell but with arbitrary command args
+  ]);
   async evaluate(tool) {
-    if (tool.permission === "deny") {
-      return { permission: "deny", source: "default", reason: "tool default deny" };
+    if (tool.permission === "deny" || _AutoApprovePermissionPolicy.DENY.has(tool.name)) {
+      return {
+        permission: "deny",
+        source: "subagent_guard",
+        reason: _AutoApprovePermissionPolicy.DENY.has(tool.name) ? `tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny"
+      };
     }
     return { permission: "auto", source: "yolo" };
   }
@@ -4801,6 +4827,7 @@ Summarize the following message range:`;
 };
 
 // src/execution/auto-compaction-middleware.ts
+var LEVEL_RANK2 = { warn: 0, soft: 1, hard: 2 };
 var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
@@ -4821,6 +4848,16 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
    * short conversations, causing premature compaction triggers.
    */
   static OVERHEAD_FACTOR = 1.3;
+  /**
+   * Once a compaction attempt reduces nothing (preserveK protects everything,
+   * no oversized tool_results remain to elide), retrying on every iteration
+   * just spams `compaction.fired` events without making progress. We remember
+   * the no-op and skip until either the pressure level escalates or context
+   * has grown by at least this many tokens since the failed attempt.
+   */
+  static NOOP_RETRY_DELTA_TOKENS = 2e3;
+  /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
+  lastNoopAttempt = null;
   /**
    * @param compactor        Compactor to use for compaction.
    * @param maxContext       Provider's max context window in tokens.
@@ -4862,19 +4899,44 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         hard: this.hardThreshold
       };
       const aggressiveOn = policy?.aggressiveOn ?? this.aggressiveOn;
-      if (load >= thresholds.hard) {
-        await this.compact(ctx, true, { level: "hard", tokens, load });
-      } else if (load >= thresholds.soft) {
-        await this.compact(ctx, aggressiveOn !== "hard", { level: "soft", tokens, load });
-      } else if (load >= thresholds.warn) {
-        await this.compact(ctx, aggressiveOn === "warn", { level: "warn", tokens, load });
+      const level = load >= thresholds.hard ? "hard" : load >= thresholds.soft ? "soft" : load >= thresholds.warn ? "warn" : null;
+      if (!level) {
+        this.lastNoopAttempt = null;
+        return next(ctx);
+      }
+      if (this.shouldSkipNoopRetry(level, tokens)) {
+        return next(ctx);
       }
+      const aggressive = level === "hard" ? true : level === "soft" ? aggressiveOn !== "hard" : aggressiveOn === "warn";
+      await this.compact(ctx, aggressive, { level, tokens, load });
       return next(ctx);
     };
   }
+  /**
+   * Returns true when the previous compaction at the same or higher pressure
+   * level reduced nothing and context has not grown materially since. Prevents
+   * a stuck preserveK window from spamming compaction events every iteration.
+   */
+  shouldSkipNoopRetry(level, tokens) {
+    const stuck = this.lastNoopAttempt;
+    if (!stuck) return false;
+    if (LEVEL_RANK2[level] > LEVEL_RANK2[stuck.level]) return false;
+    const delta = tokens - stuck.tokens;
+    return delta < _AutoCompactionMiddleware.NOOP_RETRY_DELTA_TOKENS;
+  }
+  recordAttempt(level, tokens, report) {
+    const reduced = report.before > report.after;
+    const repaired = !!report.repaired;
+    if (reduced || repaired) {
+      this.lastNoopAttempt = null;
+    } else {
+      this.lastNoopAttempt = { level, tokens };
+    }
+  }
   async compact(ctx, aggressive, pressure) {
     try {
       const report = await this.compactor.compact(ctx, { aggressive });
+      this.recordAttempt(pressure.level, pressure.tokens, report);
       this.events?.emit("compaction.fired", {
         level: pressure.level,
         tokens: pressure.tokens,
@@ -6094,29 +6156,35 @@ var SubagentBudget = class _SubagentBudget {
    * same kind are no-ops — without this dedup, every `recordIteration`
    * after the limit is reached spawns a fresh decision Promise (until
    * the first one lands and patches limits), flooding the FleetBus
-   * with redundant threshold events. Cleared in `checkLimitAsync`'s
+   * with redundant threshold events. Cleared in `negotiateExtension`'s
    * `finally`.
    */
   pendingExtensions = /* @__PURE__ */ new Set();
   /**
-   * Hard cap on how long `checkLimitAsync` waits for the coordinator to
+   * Hard cap on how long `negotiateExtension` waits for the coordinator to
    * respond before defaulting to 'stop'. Without this fallback an absent
    * or hung listener (Director not built / event filter detached mid-run)
-   * leaves the budget over-limit and never enforces anything, since
-   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
-   * Raised from 30s to 60s to give subagents more headroom before
-   * the threshold negotiation times out and triggers a hard stop.
+   * leaves the budget over-limit and never enforces anything.
    */
   static DECISION_TIMEOUT_MS = 6e4;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
-   * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
+   * Used to emit `budget.threshold_reached` events in `'auto'` mode.
    */
   _events;
+  /**
+   * Negotiation mode — controls whether a threshold hit tries to emit
+   * `budget.threshold_reached` and wait for a coordinator decision, or
+   * falls straight through to a synchronous hard stop.
+   *
+   * `'auto'` (default) — emit on the EventBus and wait; times out to 'stop'.
+   * `'sync'` — throw `BudgetExceededError` immediately regardless of listeners.
+   */
+  _mode;
   /**
    * 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.
+   * invoke it rather than throw immediately. The handler decides whether to
+   * throw synchronously, continue, or ask the coordinator for an extension.
    */
   get onThreshold() {
     return this._onThreshold;
@@ -6124,7 +6192,12 @@ var SubagentBudget = class _SubagentBudget {
   set onThreshold(fn) {
     this._onThreshold = fn;
   }
-  constructor(limits = {}) {
+  /** Returns the current negotiation mode. */
+  get mode() {
+    return this._mode;
+  }
+  constructor(limits = {}, mode = "auto") {
+    this._mode = mode;
     this.limits = { ...limits };
   }
   start() {
@@ -6140,16 +6213,23 @@ var SubagentBudget = class _SubagentBudget {
     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.
+   * 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.
+   *
+   * Decision table:
+   * - no `onThreshold` handler         → throw `BudgetExceededError` (hard stop, always)
+   * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop, always)
+   * - `mode === 'auto'` + no listener  → throw `BudgetExceededError` (hard stop; no one to ask)
+   * - `mode === 'auto'` + listener     → throw `BudgetThresholdSignal` with async decision promise
    */
   checkLimit(kind, used, limit) {
     if (!this._onThreshold) {
       throw new BudgetExceededError(kind, limit, used);
     }
+    if (this._mode === "sync") {
+      throw new BudgetExceededError(kind, limit, used);
+    }
     const bus = this._events;
     if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
       throw new BudgetExceededError(kind, limit, used);
@@ -6166,8 +6246,8 @@ var SubagentBudget = class _SubagentBudget {
    * `pendingExtensions` slot in `finally`.
    *
    * The 'continue' return from a sync handler is treated as
-   * `{ extend: {} }` — keep going without patching, next overrun will
-   * fire a fresh signal.
+   * `{ extend: {} }` — keep going without patching; next overrun fires
+   * a fresh signal.
    */
   async negotiateExtension(kind, used, limit) {
     try {
@@ -6175,11 +6255,6 @@ var SubagentBudget = class _SubagentBudget {
         kind,
         used,
         limit,
-        // Inject a requestDecision helper the handler can call to emit the
-        // budget.threshold_reached event and wait for the coordinator's verdict.
-        // A hard fallback timer guarantees the promise eventually resolves
-        // even if no listener responds — without it, an absent/detached
-        // Director would leave the budget permanently in "asking" state.
         requestDecision: () => {
           const bus = this._events;
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
@@ -6263,12 +6338,12 @@ var SubagentBudget = class _SubagentBudget {
     }
   }
   /**
-   * Wall-clock budget check. Unlike other limits, timeout is treated as a
-   * warning-only event — it NEVER hard-stops the subagent. When the
-   * elapsed time exceeds timeoutMs, emits `budget.threshold_reached` with
-   * kind='timeout' so the Director can decide whether to extend or warn.
-   * Call this from the iteration loop so a hung tool gets a chance to
-   * negotiate more time before the coordinator's Promise.race kills it.
+   * Wall-clock budget check. Unlike other limits, timeout check passes through
+   * `checkLimit` and is subject to the same negotiation-mode decision table.
+   * In practice, `'sync'` mode (the usual test configuration) means a timeout
+   * immediately throws `BudgetExceededError`. In production with a coordinator,
+   * a timeout emits `budget.threshold_reached` so the Director can decide whether
+   * to extend or abort.
    */
   checkTimeout() {
     if (this.startTime === null || this.limits.timeoutMs === void 0) return;
@@ -8649,8 +8724,7 @@ 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;
+    if (!def?.config?.role) continue;
     let score = 0;
     const matched = [];
     for (const kw of def.capability.keywords) {
@@ -8662,7 +8736,7 @@ function scoreAgents(task, catalog = AGENT_CATALOG) {
       }
     }
     if (score > 0) {
-      out.push({ role, name: def.config.name, score, matched });
+      out.push({ role: def.config.role, name: def.config.name, score, matched });
     }
   }
   out.sort((a, b) => b.score - a.score);
@@ -9033,6 +9107,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   coordinatorId;
   config;
   runner;
+  fleetBus;
   subagents = /* @__PURE__ */ new Map();
   pendingTasks = [];
   completedResults = [];
@@ -9061,6 +9136,14 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   setRunner(runner) {
     this.runner = runner;
   }
+  /**
+   * Wire a FleetBus for director-mode event emission. Call after the
+   * FleetManager is constructed so the coordinator can emit lifecycle
+   * events the TUI and monitoring tools subscribe to.
+   */
+  setFleetBus(fleet) {
+    this.fleetBus = fleet;
+  }
   /**
    * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
    * preempt running tasks — already-dispatched subagents finish their
@@ -9096,6 +9179,18 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       abortController: new AbortController()
     });
     this.emit("subagent.started", { subagent: { ...subagent, id } });
+    this.fleetBus?.emit({
+      subagentId: id,
+      ts: Date.now(),
+      type: "subagent.assigned",
+      payload: {
+        subagentId: id,
+        name: subagent.name,
+        provider: subagent.provider,
+        model: subagent.model
+      }
+    });
+    this.emitCoordinatorStats();
     return { subagentId: id, agentId: id };
   }
   async assign(task) {
@@ -9128,6 +9223,13 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     subagent.currentTask = void 0;
     subagent.context.parentBridge = null;
     this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
+    this.fleetBus?.emit({
+      subagentId,
+      ts: Date.now(),
+      type: "subagent.stopped",
+      payload: { subagentId, reason: "stopped by coordinator" }
+    });
+    this.emitCoordinatorStats();
   }
   async stopAll() {
     this.drainPendingAsAborted("Coordinator stopAll() drained the pending queue");
@@ -9159,6 +9261,22 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       completed: this.completedResults.length
     };
   }
+  /** Emit a reactive coordinator.stats event on FleetBus so the TUI can subscribe. */
+  emitCoordinatorStats() {
+    const stats = this.getStats();
+    const subagentStatuses = Array.from(this.subagents.entries()).map(([id, s]) => ({
+      subagentId: id,
+      taskId: s.currentTask ?? "",
+      status: s.status,
+      assigned: s.context.parentBridge !== null
+    }));
+    this.fleetBus?.emit({
+      subagentId: this.coordinatorId,
+      ts: Date.now(),
+      type: "coordinator.stats",
+      payload: { ...stats, subagentStatuses }
+    });
+  }
   getStatus() {
     return {
       coordinatorId: this.coordinatorId,
@@ -9333,7 +9451,15 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     subagent.currentTask = task.id;
     task.subagentId = subagentId;
     subagent.context.tasks.push(task);
+    this.fleetBus?.emit({
+      subagentId,
+      taskId: task.id,
+      ts: Date.now(),
+      type: "subagent.running",
+      payload: { subagentId, taskId: task.id }
+    });
     this.emit("task.assigned", { task, subagentId });
+    this.emitCoordinatorStats();
     const rawMaxIterations = subagent.config.maxIterations;
     const rawMaxToolCalls = subagent.config.maxToolCalls;
     const rawMaxTokens = subagent.config.maxTokens;
@@ -9477,13 +9603,34 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       if (subagent.abortController.signal.aborted) {
         subagent.abortController = new AbortController();
       }
+      this.fleetBus?.emit({
+        subagentId: result.subagentId,
+        ts: Date.now(),
+        type: "subagent.idle",
+        payload: { subagentId: result.subagentId }
+      });
     }
     this.terminating.delete(result.subagentId);
     this.emit("task.completed", {
       task: subagent?.context.tasks.find((t) => t.id === result.taskId) ?? { id: result.taskId },
       result
     });
+    this.fleetBus?.emit({
+      subagentId: result.subagentId,
+      taskId: result.taskId,
+      ts: Date.now(),
+      type: "subagent.completed",
+      payload: {
+        subagentId: result.subagentId,
+        taskId: result.taskId,
+        status: result.status,
+        iterations: result.iterations,
+        toolCalls: result.toolCalls,
+        durationMs: result.durationMs
+      }
+    });
     this.tryDispatchNext();
+    this.emitCoordinatorStats();
     if (this.isDone()) {
       this.emit("done", {
         results: this.completedResults,
@@ -10334,18 +10481,17 @@ var FleetBus = class {
   byType = /* @__PURE__ */ new Map();
   any = /* @__PURE__ */ new Set();
   /**
-   * Hook a subagent's EventBus into the fleet. EventBus is strongly
-   * typed and doesn't expose an `onAny` hook, so we subscribe to the
-   * canonical set of event types a subagent emits during a run. New
-   * event types added to the kernel must be added here too — but the
-   * cost is a tiny single line per type, and the explicit list keeps
-   * the wire format clear.
+   * Hook a subagent's EventBus into the fleet. Uses `onAny()` (an alias for
+   * `onPattern('*')`) to forward all events with subagent attribution, so
+   * new kernel event types are automatically forwarded without any manual
+   * registration. `subagent.*` events are excluded because they originate
+   * from MultiAgentHost on the parent bus, not the subagent's own bus.
    *
    * Returns a disposer that detaches every subscription; call on
    * subagent teardown so the listeners don't outlive the run.
    */
   attach(subagentId, bus, taskId) {
-    const off = bus.onPattern("*", (type, payload) => {
+    const off = bus.onAny((type, payload) => {
       if (type.startsWith("subagent.")) return;
       this.emit({ subagentId, taskId, ts: Date.now(), type, payload });
     });
@@ -10467,7 +10613,7 @@ var FleetUsageAggregator = class {
     this.total.output += usage.output ?? 0;
     this.total.cacheRead += usage.cacheRead ?? 0;
     this.total.cacheWrite += usage.cacheWrite ?? 0;
-    const price = this.priceLookup?.(e.subagentId);
+    const price = this.priceLookup?.(e.subagentId, snap.provider, snap.model);
     if (price) {
       const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
       snap.cost += delta;
@@ -10490,8 +10636,9 @@ function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
     properties: {
-      role: { type: "string", description: "Roster role id (preferred). When set, the spawn uses the matching config from the roster and ignores other fields." },
-      name: { type: "string", description: "Display name for the subagent. Required when not using roster." },
+      role: { type: "string", description: "Roster role id. When set, the spawn uses the matching config from the roster and ignores other fields." },
+      description: { type: "string", description: "Free-form task description. When `role` is not set, the director uses the smart dispatcher to route this to the best-matching catalog agent. Use this when you don't know the exact role name." },
+      name: { type: "string", description: "Display name for the subagent. Used as a fallback when description-based dispatch does not resolve a role." },
       provider: { type: "string", description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.' },
       model: { type: "string", description: "Model id within the provider. Defaults to the leader model when omitted." },
       systemPromptOverride: { type: "string", description: "Extra prompt text appended after the role-base prompt." },
@@ -10504,18 +10651,38 @@ function makeSpawnTool(director, roster) {
   return {
     name: "spawn_subagent",
     description: "Create a new subagent under this director. Returns the subagent id.",
-    usageHint: "Either pass `role` (matches the roster) OR pass `name` + optional `provider`/`model`. Returns `{ subagentId }`.",
+    usageHint: "Pass `role` (matches the roster), `description` (smart dispatch to best agent), or `name` + `provider`/`model`. Returns `{ subagentId }`.",
     permission: "auto",
     mutating: false,
     inputSchema,
     async execute(input) {
       const i = input ?? {};
       const role = typeof i.role === "string" ? i.role : void 0;
-      const base = role && roster ? roster[role] : void 0;
-      if (role && !base) {
-        return { error: `unknown role "${role}". roster has: ${roster ? Object.keys(roster).join(", ") : "(empty)"}` };
+      const description = typeof i.description === "string" ? i.description : void 0;
+      let cfg;
+      if (role && roster) {
+        const base = roster[role];
+        if (!base) return { error: `unknown role "${role}". roster has: ${Object.keys(roster).join(", ")}` };
+        cfg = instantiateRosterConfig(role, base);
+      } else if (description && !role) {
+        const dispatchResult = await dispatchAgent(description, {
+          classifier: director.dispatchClassifier,
+          catalog: roster
+        });
+        const dispatchRole = dispatchResult.role;
+        if (roster && roster[dispatchRole]) {
+          cfg = instantiateRosterConfig(dispatchRole, roster[dispatchRole]);
+        } else {
+          const def = dispatchResult.definition;
+          cfg = {
+            name: def.config.name ?? dispatchRole,
+            role: dispatchRole,
+            provider: def.config.provider,
+            model: def.config.model
+          };
+        }
       }
-      const cfg = base ? instantiateRosterConfig(role, base) : { name: i.name ?? "subagent" };
+      cfg ??= { name: i.name ?? "subagent" };
       if (typeof i.name === "string") cfg.name = i.name;
       if (typeof i.provider === "string") cfg.provider = i.provider;
       if (typeof i.model === "string") cfg.model = i.model;
@@ -10525,7 +10692,7 @@ function makeSpawnTool(director, roster) {
       if (typeof i.maxCostUsd === "number") cfg.maxCostUsd = i.maxCostUsd;
       try {
         const subagentId = await director.spawn(cfg);
-        return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name };
+        return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name, role: cfg.role };
       } catch (err) {
         if (err instanceof FleetSpawnBudgetError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
@@ -10649,12 +10816,21 @@ function makeTerminateTool(director) {
 function makeFleetStatusTool(director) {
   return {
     name: "fleet_status",
-    description: "Snapshot of the fleet \u2014 every subagent's current status, pending vs. completed task counts.",
+    description: "Snapshot of the fleet \u2014 every subagent's current status, coordinator counts (total/running/idle/stopped), pending task descriptions, and usage rollup.",
     permission: "auto",
     mutating: false,
     inputSchema: { type: "object", properties: {}, required: [] },
     async execute() {
-      return director.status();
+      const base = director.status();
+      const fm = director.fleetManager;
+      const stats = fm?.getFleetStats();
+      const fleetStatus = fm?.getFleetStatus();
+      return {
+        subagents: base.subagents,
+        coordinatorStats: stats ? { total: stats.total, running: stats.running, idle: stats.idle, stopped: stats.stopped } : void 0,
+        pending: fleetStatus?.pending ?? [],
+        usage: fm?.snapshot()
+      };
     }
   };
 }
@@ -10856,6 +11032,8 @@ var Director = class {
    * default cap.
    */
   taskCompletedListener = null;
+  /** Optional LLM classifier for smart dispatch. Passed from options. */
+  dispatchClassifier;
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID();
     this.manifestPath = opts.manifestPath;
@@ -10868,6 +11046,7 @@ var Director = class {
     this.spawnDepth = opts.spawnDepth ?? 0;
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
+    this.dispatchClassifier = opts.dispatchClassifier;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
     this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
     this.sessionsRoot = opts.sessionsRoot;
@@ -10897,7 +11076,10 @@ var Director = class {
       this.fleet = new FleetBus();
       this.usage = new FleetUsageAggregator(
         this.fleet,
-        (id) => this.priceLookups.get(id),
+        (id, provider, model) => {
+          if (provider && model) return this.priceLookups.get(`${provider}/${model}`);
+          return void 0;
+        },
         (id) => this.subagentMeta.get(id)
       );
     }
@@ -10905,6 +11087,8 @@ var Director = class {
       { ...opts.config, coordinatorId: this.id },
       { runner: opts.runner }
     );
+    this.coordinator.setFleetBus(this.fleet);
+    this.fleetManager?.setCoordinator(this.coordinator);
     this.taskCompletedListener = (payload) => {
       const r = payload.result;
       this.completed.set(r.taskId, r);
@@ -10939,7 +11123,11 @@ var Director = class {
           title
         }
       );
-      this.scheduleManifest();
+      if (this.fleetManager) {
+        this.fleetManager.flushManifest();
+      } else {
+        this.scheduleManifest();
+      }
     };
     this.coordinator.on("task.completed", this.taskCompletedListener);
     const extendCounts = /* @__PURE__ */ new Map();
@@ -11031,10 +11219,17 @@ var Director = class {
     }
   }
   /** Debounced manifest writer. A burst of spawn/assign/complete events
-   *  collapses into one write. Set `manifestDebounceMs` to 0 to disable. */
+   *  collapses into one write. Set `manifestDebounceMs` to 0 to write
+   *  synchronously (no debounce); set to negative to disable entirely. */
   scheduleManifest() {
-    if (!this.manifestPath || this.manifestDebounceMs <= 0) return;
-    if (this.manifestTimer) return;
+    if (!this.manifestPath) return;
+    if (this.manifestDebounceMs === 0) {
+      void this.writeManifest().catch(
+        (err) => this.logShutdownError("manifest_write_debounced", err)
+      );
+      return;
+    }
+    if (this.manifestDebounceMs < 0) return;
     this.manifestTimer = setTimeout(() => {
       this.manifestTimer = null;
       void this.writeManifest().catch(
@@ -11083,7 +11278,9 @@ var Director = class {
         provider: config.provider,
         model: config.model
       });
-      if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+      if (priceLookup && config.provider && config.model) {
+        this.priceLookups.set(`${config.provider}/${config.model}`, priceLookup);
+      }
     }
     const subagentBridge = new InMemoryAgentBridge(
       { agentId: result.subagentId, coordinatorId: this.id },