@wrongstack/core 0.264.0 → 0.265.1

package/dist/coordination/index.js

@@ -5089,6 +5089,7 @@ function resolveModelMatrix(matrix, role) {
 
 // src/coordination/subagent-budget.ts
 var TIMEOUT_PREEMPT_FRACTION = 0.85;
+var DECISION_TIMEOUT_MS = 6e4;
 var BudgetExceededError = class extends Error {
   kind;
   limit;
@@ -5118,6 +5119,31 @@ var BudgetThresholdSignal = class extends Error {
 };
 var SubagentBudget = class _SubagentBudget {
   limits;
+  /** Patch one or more budget limits in-place after construction.
+   * Used by the coordinator watchdog when granting an extension.
+   * All fields are optional — only provided fields are updated.
+   * This is the single write path for limit mutations so that future
+   * validation or side-effects live in one place (M1). */
+  patchLimits(ext) {
+    if (ext.maxIterations !== void 0) {
+      this.limits.maxIterations = ext.maxIterations;
+    }
+    if (ext.maxToolCalls !== void 0) {
+      this.limits.maxToolCalls = ext.maxToolCalls;
+    }
+    if (ext.maxTokens !== void 0) {
+      this.limits.maxTokens = ext.maxTokens;
+    }
+    if (ext.maxCostUsd !== void 0) {
+      this.limits.maxCostUsd = ext.maxCostUsd;
+    }
+    if (ext.timeoutMs !== void 0) {
+      this.limits.timeoutMs = ext.timeoutMs;
+    }
+    if (ext.idleTimeoutMs !== void 0) {
+      this.limits.idleTimeoutMs = ext.idleTimeoutMs;
+    }
+  }
   iterations = 0;
   toolCalls = 0;
   tokenInput = 0;
@@ -5138,12 +5164,44 @@ var SubagentBudget = class _SubagentBudget {
    * or hung listener (Director not built / event filter detached mid-run)
    * leaves the budget over-limit and never enforces anything.
    */
-  static DECISION_TIMEOUT_MS = 6e4;
+  static DECISION_TIMEOUT_MS = DECISION_TIMEOUT_MS;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used to emit `budget.threshold_reached` events in `'auto'` mode.
    */
   _events;
+  /**
+   * Guard against dual-path races between the coordinator watchdog
+   * (`executeWithTimeout`) and the budget's own `checkTimeout()`.
+   * Both paths detect `elapsed >= timeoutMs` and can emit
+   * `budget.threshold_reached` for kind `'timeout'` simultaneously.
+   * Set to the current `timeoutMs` ceiling by the coordinator BEFORE
+   * calling `onThreshold`, and cleared after the negotiation resolves.
+   * `checkTimeout()` skips its wall-clock check while this is set so
+   * the coordinator's watchdog is the sole source of wall-clock timeout
+   * events — `checkTimeout()` focuses exclusively on `idle_timeout`.
+   */
+  _watchdogActive;
+  /** Returns the timeout ceiling currently being negotiated by the watchdog,
+   * or `undefined` when no wall-clock negotiation is in flight.
+   * Used by `executeWithTimeout` to detect a stale lock (M3). */
+  get watchdogActive() {
+    return this._watchdogActive;
+  }
+  /** Called by the coordinator watchdog BEFORE calling `onThreshold` so that
+   * `checkTimeout()` skips its wall-clock check for this ceiling. Prevents
+   * the budget's own `checkTimeout()` from emitting a second
+   * `budget.threshold_reached` event while the watchdog is already
+   * negotiating the same wall-clock deadline (C1). */
+  setWatchdogNegotiation(timeoutMs) {
+    this._watchdogActive = timeoutMs;
+  }
+  /** Clears the watchdog guard after negotiation resolves. Called in the
+   * `finally` block of both the pre-empt and deadline branches so it fires
+   * on every exit path: grant, deny, throw, or error. */
+  clearWatchdogNegotiation() {
+    this._watchdogActive = void 0;
+  }
   /**
    * Negotiation mode — controls whether a threshold hit tries to emit
    * `budget.threshold_reached` and wait for a coordinator decision, or
@@ -5244,7 +5302,8 @@ var SubagentBudget = class _SubagentBudget {
       if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
         exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
       }
-      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs) {
+      const wallOwnedByWatchdog = this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
+      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs && !wallOwnedByWatchdog) {
         exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
       }
     }
@@ -5258,19 +5317,99 @@ var SubagentBudget = class _SubagentBudget {
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     const bus = this._events;
-    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+    if (!bus) {
       const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
+    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
+    if (bus.hasListenerFor("budget.threshold_reached")) {
+      for (const entry of exceeded) {
+        if (this._pendingNegotiations.has(entry.kind)) continue;
+        this._pendingNegotiations.set(entry.kind, this._negotiateExtension(entry));
+      }
+      const decision = this._pendingNegotiations.get(first.kind);
+      if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
+      throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
+    }
+    let hardStop = null;
     for (const entry of exceeded) {
       if (this._pendingNegotiations.has(entry.kind)) continue;
-      const decision2 = this._negotiateExtension(entry.kind, exceeded);
-      this._pendingNegotiations.set(entry.kind, decision2);
+      const marker = Promise.resolve("stop");
+      this._pendingNegotiations.set(entry.kind, marker);
+      void marker.finally(() => this._pendingNegotiations.delete(entry.kind));
+      const sync = this._invokeHandlerSync(entry);
+      if (!sync) hardStop ??= new BudgetExceededError(entry.kind, entry.limit, entry.used);
+    }
+    if (hardStop) throw hardStop;
+    return exceeded;
+  }
+  /**
+   * Invoke `onThreshold` once for `entry` on the NO-LISTENER path and report
+   * whether it decided synchronously. Returns `true` when the handler returned
+   * a synchronous decision (already honored — an `extend` patched the limits),
+   * or `false` when it returned a Promise (async; the caller hard-stops, since
+   * there is no listener to resolve the negotiation). The handler is given the
+   * full info shape (`requestDecision` plus direct `extend`/`deny`) so both
+   * recording handlers and policy handlers work without a wired listener.
+   */
+  _invokeHandlerSync(entry) {
+    const handler = this._onThreshold;
+    if (!handler) return false;
+    let extendArg;
+    const result = handler({
+      kind: entry.kind,
+      used: entry.used,
+      limit: entry.limit,
+      requestDecision: () => this._busRequestDecision(entry),
+      // Direct hooks for synchronous policy/recording handlers.
+      extend: (extra) => {
+        extendArg = extra;
+      },
+      deny: () => {
+      }
+    });
+    if (result && typeof result.then === "function") return false;
+    if (result === "throw") return false;
+    if (result && typeof result === "object" && "extend" in result) {
+      extendArg = result.extend;
     }
-    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
-    const decision = this._pendingNegotiations.get(first.kind);
-    if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
-    throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
+    if (extendArg) this.patchLimits(extendArg);
+    return true;
+  }
+  /**
+   * Emit `budget.threshold_reached` and resolve to the listener's verdict.
+   * Resolves to `'stop'` immediately when there is no listener (or no bus) so
+   * no negotiation can hang and no fallback timer leaks. Mirrors the
+   * coordinator watchdog's own request path so both agree on the no-listener
+   * default.
+   */
+  _busRequestDecision(entry) {
+    const bus = this._events;
+    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+      return Promise.resolve("stop");
+    }
+    return new Promise((resolve3) => {
+      let resolved = false;
+      const respond = (d) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(fallback);
+        resolve3(d);
+      };
+      const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
+      bus.emit("budget.threshold_reached", {
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+        // deny() wins over a same-dispatch extend(): a listener that both grants
+        // and denies (or two listeners disagreeing) is resolved as a stop. The
+        // grant is deferred a microtask so a synchronous deny in the same emit
+        // pre-empts it; async grants still resolve normally.
+        extend: (extra) => queueMicrotask(() => respond({ extend: extra })),
+        deny: () => respond("stop")
+      });
+    });
   }
   /**
    * Per-kind in-flight negotiation Promises. Each budget kind can have its
@@ -5290,77 +5429,33 @@ var SubagentBudget = class _SubagentBudget {
    * `{ extend: {} }` — keep going without patching; next overrun fires
    * a fresh signal.
    */
-  async _negotiateExtension(kind, exceeded) {
+  async _negotiateExtension(entry) {
     if (!this._onThreshold) {
       return "stop";
     }
     try {
-      const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       const result = this._onThreshold({
-        kind: first.kind,
-        used: first.used,
-        limit: first.limit,
-        requestDecision: () => {
-          const bus = this._events;
-          if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
-            return Promise.resolve("stop");
-          }
-          return new Promise((resolve3) => {
-            let resolved = false;
-            const respond = (d) => {
-              if (resolved) return;
-              resolved = true;
-              resolve3(d);
-            };
-            const fallback = setTimeout(
-              () => respond("stop"),
-              _SubagentBudget.DECISION_TIMEOUT_MS
-            );
-            for (const { kind: kind2, used, limit } of exceeded) {
-              bus.emit("budget.threshold_reached", {
-                kind: kind2,
-                used,
-                limit,
-                timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
-                extend: (extra) => {
-                  clearTimeout(fallback);
-                  respond({ extend: extra });
-                },
-                deny: () => {
-                  clearTimeout(fallback);
-                  respond("stop");
-                }
-              });
-            }
-          });
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        // One event for THIS kind only — each exceeded kind has its own
+        // negotiation (and its own resolve), so there is no cross-kind
+        // first-wins drop and no O(N^2) re-emission.
+        requestDecision: () => this._busRequestDecision(entry),
+        extend: (extra) => {
+          this.patchLimits(extra);
+        },
+        deny: () => {
         }
       });
       if (result === "throw") return "stop";
       if (result === "continue") return { extend: {} };
       const decision = await result;
       if (decision === "stop") return "stop";
-      const ext = decision.extend;
-      if (ext.maxIterations !== void 0) {
-        this.limits.maxIterations = ext.maxIterations;
-      }
-      if (ext.maxToolCalls !== void 0) {
-        this.limits.maxToolCalls = ext.maxToolCalls;
-      }
-      if (ext.maxTokens !== void 0) {
-        this.limits.maxTokens = ext.maxTokens;
-      }
-      if (ext.maxCostUsd !== void 0) {
-        this.limits.maxCostUsd = ext.maxCostUsd;
-      }
-      if (ext.timeoutMs !== void 0) {
-        this.limits.timeoutMs = ext.timeoutMs;
-      }
-      if (ext.idleTimeoutMs !== void 0) {
-        this.limits.idleTimeoutMs = ext.idleTimeoutMs;
-      }
+      this.patchLimits(decision.extend);
       return decision;
     } finally {
-      this._pendingNegotiations.delete(kind);
+      this._pendingNegotiations.delete(entry.kind);
     }
   }
   recordIteration() {
@@ -5403,7 +5498,8 @@ var SubagentBudget = class _SubagentBudget {
     const { timeoutMs, idleTimeoutMs } = this.limits;
     if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
-    const wallTripped = timeoutMs !== void 0 && elapsed > timeoutMs;
+    const wallSkipped = this._onThreshold !== void 0 && this._watchdogActive !== void 0 && timeoutMs !== void 0 && this._watchdogActive === timeoutMs;
+    const wallTripped = wallSkipped ? false : timeoutMs !== void 0 && elapsed > timeoutMs;
     const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
     if (!wallTripped && !idleTripped) return;
     void this.checkLimits(elapsed);
@@ -6025,6 +6121,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   terminating = /* @__PURE__ */ new Set();
   constructor(config, options = {}) {
     super();
+    this.setMaxListeners(0);
     this.coordinatorId = config.coordinatorId;
     this.config = config;
     this.runner = options.runner;
@@ -6419,7 +6516,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     let result;
     budget.start();
     try {
-      const outcome = await this.executeWithTimeout(this.runner, task, runCtx, budget);
+      const outcome = await this.executeWithTimeout(
+        this.runner,
+        task,
+        runCtx,
+        budget,
+        subagent.config.preemptFraction
+      );
       result = {
         subagentId,
         taskId: task.id,
@@ -6446,7 +6549,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     this.recordCompletion(result);
   }
-  async executeWithTimeout(runner, task, ctx, budget) {
+  async executeWithTimeout(runner, task, ctx, budget, preemptFraction = TIMEOUT_PREEMPT_FRACTION) {
     const initialTimeoutMs = budget.limits.timeoutMs;
     const idleLimitMs = budget.limits.idleTimeoutMs;
     if (initialTimeoutMs === void 0 && idleLimitMs === void 0) {
@@ -6454,8 +6557,21 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     const start = Date.now();
     let timer = null;
-    let preemptedForLimit = null;
+    let PreemptState;
+    ((PreemptState2) => {
+      PreemptState2["ACTIVE"] = "active";
+      PreemptState2["LOCKED"] = "locked";
+    })(PreemptState || (PreemptState = {}));
+    let preemptedCeiling = null;
+    let preemptState = "active" /* ACTIVE */;
+    let lastGrantActivityTs = -1;
     const timeoutPromise = new Promise((_, reject) => {
+      const terminate = (kind, limit, used) => {
+        this.subagents.get(ctx.subagentId)?.abortController.abort();
+        reject(
+          budget._events?.hasListenerFor("budget.threshold_reached") ? new Error(`subagent stopped: budget ${kind} (limit=${limit}, used=${used})`) : new BudgetExceededError(kind, limit, used)
+        );
+      };
       const armFor = (ms) => {
         if (timer) clearTimeout(timer);
         timer = setTimeout(onTick, Math.max(0, ms));
@@ -6464,7 +6580,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const wallLimit = budget.limits.timeoutMs ?? initialTimeoutMs;
         const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : wallLimit - (Date.now() - start);
         const idleRemaining = idleLimitMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
-        const preemptRemaining = initialTimeoutMs === void 0 || preemptedForLimit === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * TIMEOUT_PREEMPT_FRACTION - (Date.now() - start);
+        const preemptRemaining = initialTimeoutMs === void 0 || preemptedCeiling === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * preemptFraction - (Date.now() - start);
         armFor(Math.max(25, Math.min(wallRemaining, idleRemaining, preemptRemaining)));
       };
       const negotiateTimeout = async (used, limit) => {
@@ -6474,16 +6590,42 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           kind: "timeout",
           used,
           limit,
-          requestDecision: () => new Promise((resolveDecision) => {
-            budget._events?.emit("budget.threshold_reached", {
-              kind: "timeout",
-              used,
-              limit,
-              timeoutMs: 6e4,
-              extend: (extra) => resolveDecision({ extend: extra }),
-              deny: () => resolveDecision("stop")
+          requestDecision: () => {
+            if (!budget._events?.hasListenerFor("budget.threshold_reached")) {
+              return Promise.resolve("stop");
+            }
+            return new Promise((resolveDecision) => {
+              let settled = false;
+              const resolve3 = (d) => {
+                if (settled) return;
+                settled = true;
+                resolveDecision(d);
+              };
+              const fallback = setTimeout(() => resolve3("stop"), DECISION_TIMEOUT_MS);
+              budget._events?.emit("budget.threshold_reached", {
+                kind: "timeout",
+                used,
+                limit,
+                // Informational: the budget's own decision deadline. Listeners may use
+                // this to display a countdown. The coordinator does NOT enforce it —
+                // it is the budget's own `setTimeout(fallback)` that races against
+                // the listener's `extend()`/`deny()` call to guarantee progress.
+                timeoutMs: DECISION_TIMEOUT_MS,
+                // deny() wins over a same-dispatch extend(): defer the grant a
+                // microtask so a synchronous deny in the same emit pre-empts it
+                // (a listener that both grants and denies, or two listeners
+                // disagreeing, resolves as a stop). Async grants still resolve.
+                extend: (extra) => {
+                  clearTimeout(fallback);
+                  queueMicrotask(() => resolve3({ extend: extra }));
+                },
+                deny: () => {
+                  clearTimeout(fallback);
+                  resolve3("stop");
+                }
+              });
             });
-          })
+          }
         });
         return typeof result === "string" ? result : await result;
       };
@@ -6494,21 +6636,45 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const wallExceeded = wallLimit !== void 0 && elapsed >= wallLimit;
         const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
         if (idleExceeded && !wallExceeded) {
+          budget._events?.emit("budget.threshold_reached", {
+            kind: "idle_timeout",
+            used: budget.idleMs(),
+            limit: idleLimit ?? 0,
+            timeoutMs: DECISION_TIMEOUT_MS,
+            extend: () => {
+            },
+            deny: () => {
+            }
+          });
           this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", idleLimit ?? 0, budget.idleMs()));
+          reject(new BudgetExceededError("idle_timeout", idleLimit ?? 0, budget.idleMs()));
           return;
         }
-        if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptedForLimit !== wallLimit && elapsed >= wallLimit * TIMEOUT_PREEMPT_FRACTION) {
+        if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed >= wallLimit * preemptFraction) {
+          const activityTs = Date.now() - budget.idleMs();
+          if (activityTs <= lastGrantActivityTs) {
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
+            scheduleNext();
+            return;
+          }
+          budget.setWatchdogNegotiation(wallLimit);
           try {
             const decision = await negotiateTimeout(elapsed, wallLimit);
             if (typeof decision !== "string" && decision.extend.timeoutMs !== void 0) {
-              budget.limits.timeoutMs = decision.extend.timeoutMs;
-              preemptedForLimit = null;
+              budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+              lastGrantActivityTs = Date.now() - budget.idleMs();
+              preemptState = "active" /* ACTIVE */;
+              preemptedCeiling = null;
             } else {
-              preemptedForLimit = wallLimit;
+              preemptState = "locked" /* LOCKED */;
+              preemptedCeiling = wallLimit;
             }
           } catch {
-            preemptedForLimit = wallLimit;
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
+          } finally {
+            budget.clearWatchdogNegotiation();
           }
           scheduleNext();
           return;
@@ -6523,26 +6689,41 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           reject(new BudgetExceededError("timeout", limit, elapsed));
           return;
         }
+        budget.setWatchdogNegotiation(limit);
         try {
           const decision = await negotiateTimeout(elapsed, limit);
-          if (decision === "continue" || decision === "throw" || decision === "stop") {
-            preemptedForLimit = null;
+          if (decision === "throw") {
+            terminate("timeout", limit, elapsed);
+            return;
+          }
+          if (decision === "continue") {
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
             armFor(Math.max(1e3, limit));
             return;
           }
+          if (decision === "stop") {
+            terminate("timeout", limit, elapsed);
+            return;
+          }
           if (decision.extend.timeoutMs !== void 0) {
-            budget.limits.timeoutMs = decision.extend.timeoutMs;
-            preemptedForLimit = null;
+            budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+            lastGrantActivityTs = Date.now() - budget.idleMs();
+            preemptState = "active" /* ACTIVE */;
+            preemptedCeiling = null;
             scheduleNext();
             return;
           }
-          this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", limit, elapsed));
+          terminate("timeout", limit, elapsed);
+          return;
         } catch (err) {
           this.subagents.get(ctx.subagentId)?.abortController.abort();
           reject(
             err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
           );
+          return;
+        } finally {
+          budget.clearWatchdogNegotiation();
         }
       };
       scheduleNext();
@@ -8516,11 +8697,34 @@ var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
   secretScrubber;
+  /**
+   * In-memory cache for load() results, keyed by session ID. The cache is
+   * invalidated when the file's mtimeMs or size changes (indicating the
+   * file was written to). This eliminates redundant full-file reads and
+   * JSON parses when the same session is loaded multiple times within the
+   * store's lifetime (e.g., webui session detail views, list() fallbacks).
+   *
+   * Max size is capped to prevent unbounded memory growth in long-running
+   * processes. When the limit is reached, the oldest entry is evicted.
+   */
+  _loadCache = /* @__PURE__ */ new Map();
+  static LOAD_CACHE_MAX_ENTRIES = 50;
   constructor(opts) {
     this.dir = opts.dir;
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
   }
+  /**
+   * Clear the load() cache. Useful for testing or when the caller knows
+   * the file has changed externally (e.g., another process wrote to it).
+   */
+  clearLoadCache(sessionId) {
+    if (sessionId !== void 0) {
+      this._loadCache.delete(sessionId);
+    } else {
+      this._loadCache.clear();
+    }
+  }
   // ── Storage event helpers ───────────────────────────────────────────────────
   emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
     this.events?.emit("storage.read", {
@@ -8663,7 +8867,20 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
+    let cacheHit = false;
     try {
+      let stat6;
+      try {
+        const s = await fsp6.stat(file);
+        stat6 = { mtimeMs: s.mtimeMs, size: s.size };
+      } catch (err) {
+        throw err;
+      }
+      const cached = this._loadCache.get(id);
+      if (cached && cached.mtimeMs === stat6.mtimeMs && cached.size === stat6.size) {
+        cacheHit = true;
+        return cached.data;
+      }
       const raw = await fsp6.readFile(file, "utf8");
       const lines = raw.split("\n").filter((l) => l.trim());
       const events = [];
@@ -8679,13 +8896,30 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const meta = this.metaFromEvents(id, events);
       const { messages, usage } = this.replay(events, id);
       const toolCallEnds = extractToolCallEnds(events);
-      return { metadata: meta, events, messages, usage, toolCallEnds };
+      const data = { metadata: meta, events, messages, usage, toolCallEnds };
+      if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
+        const oldest = this._loadCache.keys().next().value;
+        if (oldest !== void 0) {
+          this._loadCache.delete(oldest);
+        }
+      }
+      this._loadCache.set(id, { mtimeMs: stat6.mtimeMs, size: stat6.size, data });
+      return data;
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
       throw err;
     } finally {
       this.emitRead(id, file, "load", outcome, Date.now() - t0, errorMsg);
+      if (cacheHit) {
+        this.events?.emit("storage.cache_hit", {
+          sessionId: id,
+          store: "session",
+          filePath: file,
+          operation: "load",
+          durationMs: Date.now() - t0
+        });
+      }
     }
   }
   async list(limit = 20) {
@@ -9692,6 +9926,7 @@ function attachAutoExtend(events, policy = {}) {
   const extendCounts = /* @__PURE__ */ new Map();
   let progress = 0;
   let lastTimeoutProgress = -1;
+  let lastSeenKey = null;
   const unsubs = [
     events.on("tool.executed", () => {
       progress++;
@@ -9701,6 +9936,9 @@ function attachAutoExtend(events, policy = {}) {
     }),
     events.on("budget.threshold_reached", (e) => {
       const { kind, limit, extend, deny } = e;
+      const key = `${kind}:${limit}`;
+      if (key === lastSeenKey) return;
+      lastSeenKey = key;
       if (kind === "timeout" || kind === "idle_timeout") {
         if (progress > lastTimeoutProgress) {
           lastTimeoutProgress = progress;
@@ -10410,7 +10648,8 @@ var BrainMonitor = class {
             id: "steer",
             label: "Steer the agent with corrective guidance",
             consequence: "A steer message is injected before its next step.",
-            risk: "low"
+            risk: "low",
+            recommended: true
           },
           {
             id: "continue",
@@ -10419,9 +10658,9 @@ var BrainMonitor = class {
           }
         ],
         risk: "medium",
-        // Without an LLM layer the policy brain resolves this fallback to
-        // "continue" — the monitor observes but never interferes.
-        fallback: "continue"
+        // 'ask_human' routes to the LLM-backed autonomous layer via
+        // createTieredBrainArbiter before any human escalation.
+        fallback: "ask_human"
       };
       const decision = await this.opts.brain.decide(request);
       const intervened = await this.maybeIntervene(kind, request, decision);
@@ -11518,6 +11757,10 @@ function makeDependencyWatcherConfig(opts) {
   return {
     watchPaths: unique,
     debounceMs,
+    dispose() {
+      for (const t of pending.values()) clearTimeout(t);
+      pending.clear();
+    },
     async onChange(entry) {
       if (entry.event === "delete") return;
       if (!matchesPattern(entry.path)) return;
@@ -11935,6 +12178,10 @@ var KnowledgeGraph = class {
   pendingDeliveries = /* @__PURE__ */ new Map();
   filePath;
   graphFilePath;
+  /** Exposed for unit-testing only: read current index contents. */
+  getIndex() {
+    return this.index;
+  }
   constructor(sessionDir) {
     this.filePath = path5.join(sessionDir, "_knowledge_graph");
     this.graphFilePath = path5.join(this.filePath, "graph.jsonl");
@@ -11947,7 +12194,7 @@ var KnowledgeGraph = class {
   async add(node) {
     const full = { id: randomUUID(), ...node };
     this.nodes.set(full.id, full);
-    this._index(full);
+    this._addToIndex(full, this._indexKeys(full));
     await this._persist(full);
     this._deliver(full);
     return full;
@@ -11956,8 +12203,10 @@ var KnowledgeGraph = class {
   async update(id, patch) {
     const existing = this.nodes.get(id);
     if (!existing) return null;
+    this._removeFromIndex(existing, this._indexKeys(existing));
     const updated = { ...existing, ...patch };
     this.nodes.set(id, updated);
+    this._addToIndex(updated, this._indexKeys(updated));
     this._deliver(updated);
     await this._append(updated);
     return updated;
@@ -12043,15 +12292,10 @@ var KnowledgeGraph = class {
     return { passed: checks.every((c) => c.passed), checks };
   }
   // ── Private ────────────────────────────────────────────────────────────
-  _index(node) {
-    const add = (key) => {
-      let set = this.index.get(key);
-      if (!set) {
-        set = /* @__PURE__ */ new Set();
-        this.index.set(key, set);
-      }
-      set.add(node.id);
-    };
+  /** Pure: compute the set of index keys a node would belong to. */
+  _indexKeys(node) {
+    const keys = /* @__PURE__ */ new Set();
+    const add = (key) => keys.add(key);
     add(`type:${node.type}`);
     if (node.type === "fact") {
       const f = node;
@@ -12060,6 +12304,8 @@ var KnowledgeGraph = class {
       add(`by:${f.discoveredBy}`);
       for (const tag of f.tags) add(`tag:${tag}`);
       add(`key:${f.key}`);
+      add(`subject:${f.subject}`);
+      if (f.detail) add(`detail:${f.detail}`);
     }
     if (node.type === "goal") {
       const g = node;
@@ -12074,6 +12320,24 @@ var KnowledgeGraph = class {
       add(`by:${c.proposedBy}`);
       for (const g of c.satisfiesGoals) add(`goal:${g}`);
     }
+    return keys;
+  }
+  /** Mutate the index: add a node's id to every set for the given keys. */
+  _addToIndex(node, keys) {
+    for (const key of keys) {
+      let set = this.index.get(key);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        this.index.set(key, set);
+      }
+      set.add(node.id);
+    }
+  }
+  /** Remove a node's id from all index sets for the given keys. */
+  _removeFromIndex(node, keys) {
+    for (const key of keys) {
+      this.index.get(key)?.delete(node.id);
+    }
   }
   _matches(node, f) {
     if (f.type && node.type !== f.type) return false;
@@ -12123,11 +12387,15 @@ var KnowledgeGraph = class {
         try {
           const parsed = JSON.parse(line);
           if (parsed.op === "update") {
+            const oldNode = this.nodes.get(parsed.node.id);
+            if (oldNode) {
+              this._removeFromIndex(oldNode, this._indexKeys(oldNode));
+            }
             this.nodes.set(parsed.node.id, parsed.node);
-            this._index(parsed.node);
+            this._addToIndex(parsed.node, this._indexKeys(parsed.node));
           } else {
             this.nodes.set(parsed.id, parsed);
-            this._index(parsed);
+            this._addToIndex(parsed, this._indexKeys(parsed));
           }
         } catch {
         }
@@ -12428,7 +12696,7 @@ var TaskDAG = class {
       if (visited.has(current)) continue;
       visited.add(current);
       const node = this.nodes.get(current);
-      if (node) stack.push(...node.dependents);
+      if (node) stack.push(...node.deps);
     }
     return false;
   }
@@ -12531,8 +12799,10 @@ var ConsensusProtocol = class {
     return this._resolve(changeId, change.votes, eligible);
   }
   // ── Private ───────────────────────────────────────────────────────────
-  _eligibleVoters(_change) {
-    return Array.from(this.voters.keys());
+  _eligibleVoters(change) {
+    return Array.from(this.voters.keys()).filter(
+      (agentId) => agentId !== change.proposedBy
+    );
   }
   _resolve(changeId, votes, eligible) {
     const totalEligible = eligible.length;
@@ -12577,7 +12847,7 @@ var ConsensusProtocol = class {
     if (!quorumMet) {
       return {
         changeId,
-        outcome: "pending",
+        outcome: "quorum_not_met",
         votes,
         approveCount: approve.length,
         rejectCount: reject.length,
@@ -12954,7 +13224,7 @@ var AutonomousBrain = class {
       }
       return { type: "deny", reason: `Brain LLM failed: ${String(err)}` };
     }
-    void this._recordDecision({
+    this._recordDecision({
       id,
       decisionType,
       question,
@@ -12963,6 +13233,7 @@ var AutonomousBrain = class {
       rationale: result.rationale,
       madeBy: "autonomous-brain",
       context: JSON.stringify(context)
+    }).catch(() => {
     });
     if (requiresConsensus) {
       this._emit("brain.decision", { id, decisionType, optionId: result.optionId, rationale: result.rationale, consensusRequired: true });
@@ -13241,10 +13512,16 @@ var TaskAuctioneer = class {
   maxTasksPerAgent;
   minConfidence;
   // minimum dispatcher confidence to accept a bid
+  maxBidRetries;
+  // max republished attempts before marking task failed
   /** Pending bids keyed by taskId. */
   pendingBids = /* @__PURE__ */ new Map();
   /** Active bid windows keyed by taskId. */
   bidTimers = /* @__PURE__ */ new Map();
+  /** FleetBus subscription disposers, detached in dispose(). */
+  unsubs = [];
+  /** How many times a task has been republished with no bids received. */
+  bidRetryCounts = /* @__PURE__ */ new Map();
   /** Agent → current task count (from graph + in-flight). */
   agentTaskCounts = /* @__PURE__ */ new Map();
   constructor(opts) {
@@ -13255,8 +13532,26 @@ var TaskAuctioneer = class {
     this.bidWindowMs = opts.bidWindowMs ?? 3e4;
     this.maxTasksPerAgent = opts.maxTasksPerAgent ?? 3;
     this.minConfidence = opts.minConfidence ?? 0.3;
-    this.fleet?.filter("task:bid", (e) => this._onBidEvent(e));
-    this.fleet?.filter("task:claimed", (e) => this._onClaimedEvent(e));
+    this.maxBidRetries = opts.maxBidRetries ?? 3;
+    const offBid = this.fleet?.filter("task:bid", (e) => this._onBidEvent(e));
+    const offClaimed = this.fleet?.filter("task:claimed", (e) => this._onClaimedEvent(e));
+    if (offBid) this.unsubs.push(offBid);
+    if (offClaimed) this.unsubs.push(offClaimed);
+  }
+  /**
+   * Detach all FleetBus subscriptions and cancel any open bid-window timers.
+   * Call when the owning coordinator stops/restarts so handlers and timers
+   * don't accumulate across cycles.
+   */
+  dispose() {
+    for (const off of this.unsubs.splice(0)) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    for (const t of this.bidTimers.values()) clearTimeout(t);
+    this.bidTimers.clear();
   }
   // ── Publish a task ────────────────────────────────────────────────────
   /**
@@ -13266,14 +13561,16 @@ var TaskAuctioneer = class {
    * If `targetAgent` is specified, the task is assigned directly without auction.
    */
   async publishTask(input) {
+    const blockedBy = input.blockedBy ?? [];
+    const hasOpenBlockers = blockedBy.length > 0 && blockedBy.some((id) => this.graph.get(id)?.status !== "done");
     const goal = await this.graph.add({
       type: "goal",
       title: input.title,
       description: input.description,
-      status: input.targetAgent ? "in_progress" : "pending",
+      status: input.targetAgent ? "in_progress" : hasOpenBlockers ? "blocked" : "pending",
       priority: input.priority ?? "medium",
       assignee: input.targetAgent,
-      blockedBy: [],
+      blockedBy,
       dependsOn: input.satisfiesGoals ?? [],
       createdBy: this.selfAgentId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -13290,6 +13587,12 @@ var TaskAuctioneer = class {
         });
       }
     }
+    for (const blockerId of blockedBy) {
+      const blocker = this.graph.get(blockerId);
+      if (blocker && !blocker.children.includes(goal.id)) {
+        await this.graph.update(blockerId, { children: [...blocker.children, goal.id] });
+      }
+    }
     if (input.targetAgent) {
       await this._assignDirect(goal.id, input.targetAgent);
     } else {
@@ -13401,9 +13704,12 @@ Priority: ${goal.priority}`,
       status: "done",
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
+    this.bidRetryCounts.delete(taskId);
+    this.pendingBids.delete(taskId);
+    this._cancelBidWindow(taskId);
     for (const childId of goal.children) {
       const child = this.graph.get(childId);
-      if (child) {
+      if (child && child.status === "blocked") {
         const allUnblocked = child.blockedBy.every((blockedId) => {
           const blocked = this.graph.get(blockedId);
           return blocked?.status === "done";
@@ -13412,6 +13718,7 @@ Priority: ${goal.priority}`,
           await this.graph.update(childId, { status: "pending", updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
           const unblockedGoal = this.graph.get(childId);
           await this._broadcastTask(unblockedGoal);
+          this._startBidWindow(childId);
         }
       }
     }
@@ -13437,6 +13744,9 @@ ${_result ?? "No result provided."}`
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       result: error
     });
+    this.bidRetryCounts.delete(taskId);
+    this.pendingBids.delete(taskId);
+    this._cancelBidWindow(taskId);
     this._emit("task:failed", { taskId, agentId, error });
     await this._mailboxPublish({
       type: "note",
@@ -13515,7 +13825,7 @@ Assignee: ${agentId}`
       priority: goal.priority,
       tags: goal.tags
     });
-    void this._mailboxPublish({
+    this._mailboxPublish({
       type: "broadcast",
       subject: `[task] ${goal.title} (${goal.priority})`,
       body: `New task available: "${goal.title}"
@@ -13526,6 +13836,7 @@ Task ID: ${goal.id}
 Tags: ${goal.tags.join(", ") || "none"}
 
 Bid by calling taskAuctioneer.bid("${goal.id}", ...)`
+    }).catch(() => {
     });
   }
   async _mailboxPublish(msg) {
@@ -13559,9 +13870,10 @@ Bid by calling taskAuctioneer.bid("${goal.id}", ...)`
   }
   _startBidWindow(taskId) {
     this._cancelBidWindow(taskId);
-    const timer = setTimeout(async () => {
+    const timer = setTimeout(() => {
       this.bidTimers.delete(taskId);
-      await this._evaluateBids(taskId);
+      void this._evaluateBids(taskId).catch(() => {
+      });
     }, this.bidWindowMs);
     this.bidTimers.set(taskId, timer);
   }
@@ -13575,6 +13887,13 @@ Bid by calling taskAuctioneer.bid("${goal.id}", ...)`
   async _evaluateBids(taskId) {
     const bids = this.pendingBids.get(taskId);
     if (!bids || bids.length === 0) {
+      const retryCount = (this.bidRetryCounts.get(taskId) ?? 0) + 1;
+      this.bidRetryCounts.set(taskId, retryCount);
+      if (retryCount >= this.maxBidRetries) {
+        await this.fail(taskId, `No bids received after ${this.maxBidRetries} attempts`);
+        this.bidRetryCounts.delete(taskId);
+        return;
+      }
       const goal = this.graph.get(taskId);
       if (goal) {
         await this._broadcastTask(goal);
@@ -13583,7 +13902,15 @@ Bid by calling taskAuctioneer.bid("${goal.id}", ...)`
       return;
     }
     bids.sort((a, b) => b.score - a.score);
-    const winner = bids[0];
+    const winner = bids.find((b) => this._getAgentTaskCount(b.agentId) < this.maxTasksPerAgent);
+    if (!winner) {
+      const goal = this.graph.get(taskId);
+      if (goal) {
+        await this._broadcastTask(goal);
+        this._startBidWindow(taskId);
+      }
+      return;
+    }
     await this.claim(taskId, winner.agentId, winner.agentName);
   }
   async _assignDirect(taskId, agentId) {
@@ -13630,16 +13957,24 @@ var AutonomousCoordinator = class {
   selfAgentId;
   fleet;
   fleetManager;
+  director;
   mailbox;
   events;
+  onCoordinatorEvent;
   running = false;
   iterationCount = 0;
+  /** Tasks already handled by _onSubagentTerminated (to avoid double goal:failed on fleet event). */
+  _handledBySubagent = /* @__PURE__ */ new Set();
+  /** FleetBus subscription disposers, detached in dispose(). */
+  unsubs = [];
   constructor(opts) {
     this.selfAgentId = opts.selfAgentId;
     this.fleet = opts.fleet ?? void 0;
     this.fleetManager = opts.fleetManager ?? void 0;
+    this.director = opts.director ?? void 0;
     this.mailbox = opts.mailbox ?? void 0;
     this.events = opts.events ?? void 0;
+    this.onCoordinatorEvent = opts.onCoordinatorEvent;
     this.graph = new KnowledgeGraph(opts.sessionDir);
     this.dag = new TaskDAG();
     this.auction = new TaskAuctioneer({
@@ -13675,9 +14010,19 @@ var AutonomousCoordinator = class {
     this.dag.onEvent((event) => {
       this._onDagEvent(event);
     });
-    this.fleet?.filter("subagent.terminated", (e) => {
+    const offCompleted = this.fleet?.filter("subagent.completed", (e) => {
       this._onSubagentTerminated(e);
     });
+    if (offCompleted) this.unsubs.push(offCompleted);
+    const offFailed = this.fleet?.filter("task:failed", (e) => {
+      const payload = e.payload;
+      const taskId = payload?.taskId;
+      if (!taskId || this._handledBySubagent.has(taskId)) return;
+      this._handledBySubagent.add(taskId);
+      this._emit({ type: "goal:failed", goalId: taskId, text: payload?.error ?? "Task failed" });
+    });
+    if (offFailed) this.unsubs.push(offFailed);
+    this._emit({ type: "coordinator:mode", mode: this.fleet ? "fleet" : "standalone" });
   }
   // ── Public API ───────────────────────────────────────────────────────
   /**
@@ -13691,11 +14036,13 @@ var AutonomousCoordinator = class {
     const maxIterations = opts.maxIterations ?? 100;
     const goal = opts.goal ?? "Improve the codebase";
     const maxCost = opts.maxCostUsd;
-    await this.graph.load();
     try {
+      await this.graph.load();
       const goalConfigs = await this._decomposeGoal(goal);
       for (const g of goalConfigs) {
-        await this.auction.publishTask(g);
+        const goalId = await this.auction.publishTask(g);
+        this.dag.addNode(goalId, g.description, []);
+        this._emit({ type: "goal:added", goalId, title: g.title, text: g.description });
       }
       while (this.running) {
         this.iterationCount++;
@@ -13722,6 +14069,7 @@ var AutonomousCoordinator = class {
           const blocked = this.dag.getBlocked();
           if (blocked.length > 0 && this.dag.hasDeadlock()) {
             (this.events?.emit)("autonomous:deadlock", { blocked });
+            this._emit({ type: "deadlock:detected", goalId: blocked[0]?.id ?? "", text: `Deadlock detected: ${blocked.map((n) => n.id).join(", ")}` });
             this.running = false;
           }
           break;
@@ -13738,7 +14086,15 @@ var AutonomousCoordinator = class {
         }
         const pendingChanges = this.changes.getPendingReviews();
         for (const change of pendingChanges) {
-          await this._handlePendingChange(change);
+          try {
+            await this._handlePendingChange(change);
+          } catch (err) {
+            this._emit({
+              type: "goal:failed",
+              goalId: change.id,
+              text: `Consensus handling failed: ${err instanceof Error ? err.message : String(err)}`
+            });
+          }
         }
       }
     } finally {
@@ -13748,7 +14104,26 @@ var AutonomousCoordinator = class {
   }
   /** Stop the autonomous loop. */
   stop() {
+    if (!this.running) return;
     this.running = false;
+    console.error(`[AutonomousCoordinator] stop signal received \u2014 shutting down (iteration ${this.iterationCount})`);
+  }
+  /**
+   * Tear down the coordinator for good: stop the loop and detach all FleetBus
+   * subscriptions (this coordinator's + the auctioneer's) plus any open bid
+   * timers. Call this when discarding the instance (e.g. `/coordinator stop`
+   * that recreates a fresh coordinator on the next start) so handlers and
+   * timers don't accumulate across cycles. `stop()` only pauses the loop.
+   */
+  dispose() {
+    this.stop();
+    for (const off of this.unsubs.splice(0)) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    this.auction.dispose();
   }
   /** Get a stats snapshot. */
   getStats() {
@@ -13803,6 +14178,7 @@ var AutonomousCoordinator = class {
       body: `**${input.category}**${input.file ? ` in ${input.file}${input.line ? `:${input.line}` : ""}` : ""}
 ${input.detail}`
     });
+    this._emit({ type: "knowledge:added", knowledgeId: fact.id, title: input.subject, text: input.detail });
     return fact;
   }
   // ── Goal creation helpers ────────────────────────────────────────────
@@ -13815,7 +14191,10 @@ ${input.detail}`
       title: input.title,
       description: input.description,
       priority: resolvedPriority,
-      ...input.tags ? { tags: input.tags } : {}
+      ...input.tags ? { tags: input.tags } : {},
+      // Mirror the dependency edges into the auction so blocked goals aren't
+      // biddable until their deps complete (the DAG tracks the same edges).
+      ...input.deps && input.deps.length > 0 ? { blockedBy: input.deps } : {}
     });
     const goal = this.graph.get(goalId);
     for (const depId of input.deps ?? []) {
@@ -13856,30 +14235,34 @@ ${input.detail}`
   async _processGoal(goalId) {
     const ready = this.dag.getReady();
     if (ready.length === 0) return;
-    const next = ready.find((n) => n.id === goalId) ?? ready[0];
-    this.dag.start(next.id, "auctioneer");
-    const existingAgent = this.auction.getTasksForAgent(this.selfAgentId).find((g) => g.id === next.id);
-    if (!existingAgent) {
-      await this.auction.publishTask({
-        title: next.description,
-        description: next.description,
-        priority: this._dagPriorityToGoal(next.priority),
-        tags: next.tags
+    const dagNode = ready.find((n) => n.id === goalId) ?? ready[0];
+    this.dag.start(dagNode.id, "auctioneer");
+    const goalNode = this.graph.get(goalId);
+    if (!goalNode) return;
+    const title = goalNode.title || dagNode.description;
+    const taskId = await this.auction.publishTask({
+      title,
+      description: goalNode.description,
+      priority: this._dagPriorityToGoal(dagNode.priority),
+      tags: dagNode.tags
+    });
+    this._emit({ type: "task:ready", goalId, taskId, title });
+    if (this.director) {
+      const config = {
+        name: `worker-${goalId.slice(0, 8)}`,
+        role: "general",
+        maxIterations: 100,
+        timeoutMs: 6e5
+        // 10 minutes per goal
+      };
+      const subagentId = await this.director.spawn(config);
+      await this.auction.claim(taskId, subagentId, config.name);
+      await this.director.assign({
+        id: goalId,
+        subagentId,
+        description: goalNode.description
       });
     }
-    await this._waitForClaim(next.id);
-  }
-  async _waitForClaim(taskId) {
-    const maxWait = 6e4;
-    const pollInterval = 2e3;
-    const start = Date.now();
-    while (Date.now() - start < maxWait) {
-      const goal = this.graph.get(taskId);
-      if (goal?.status === "in_progress" || goal?.status === "done") {
-        return;
-      }
-      await this._sleep(pollInterval);
-    }
   }
   async _handlePendingChange(change) {
     const result = this.consensus.getStatus(change.id);
@@ -13893,6 +14276,17 @@ ${input.detail}`
       );
       if (voteResult.outcome === "approved") {
         await this.changes.markApplied(change.id, (/* @__PURE__ */ new Date()).toISOString());
+        this._emit({ type: "consensus:reached", goalId: change.id, text: "Change approved and applied" });
+      }
+    } else {
+      const voteResult = await this.consensus.castVote(
+        change.id,
+        this.selfAgentId,
+        "reject",
+        `Quality gate failed: ${change.qualityGate.checks.map((c) => `${c.name}=${c.passed}`).join(", ")}`
+      );
+      if (voteResult.outcome === "rejected" || voteResult.outcome === "vetoed") {
+        this._emit({ type: "consensus:reached", goalId: change.id, text: "Change rejected by quality gate" });
       }
     }
   }
@@ -13903,10 +14297,6 @@ ${input.detail}`
         (this.events?.emit)("autonomous:task_ready", { taskId: event.nodeId, description: node.description });
       }
     }
-    if (event.type === "deadlock") {
-      (this.events?.emit)("autonomous:deadlock", { blocked: event.blocked });
-      this.running = false;
-    }
     if (event.type === "graph:done") {
       (this.events?.emit)("autonomous:all_done", this.getStats());
     }
@@ -13914,13 +14304,16 @@ ${input.detail}`
   _onSubagentTerminated(e) {
     const payload = e.payload;
     const subagentId = payload?.subagentId ?? e.subagentId;
-    const stopReason = payload?.stopReason ?? "unknown";
+    const stopReason = payload?.stopReason ?? (payload?.status === "ok" ? "end_turn" : payload?.status ?? "unknown");
     const tasks = this.auction.getTasksForAgent(subagentId);
     for (const task of tasks) {
+      this._handledBySubagent.add(task.id);
       if (stopReason === "end_turn") {
         void this.auction.complete(task.id, "Subagent completed successfully");
+        this._emit({ type: "task:completed", goalId: task.id, taskId: task.id, text: "Subagent completed successfully" });
       } else {
         void this.auction.fail(task.id, `Subagent terminated: ${stopReason}`);
+        this._emit({ type: "goal:failed", goalId: task.id, text: `Subagent terminated: ${stopReason}` });
       }
     }
   }
@@ -13934,6 +14327,10 @@ ${input.detail}`
   }
   _buildVoters() {
     return [
+      // The coordinator itself casts the quality-gate auto-vote in
+      // _handlePendingChange — it MUST be a registered, eligible voter or
+      // castVote throws "unknown voter" and tears down the run() loop.
+      { agentId: this.selfAgentId, agentName: "Coordinator", role: "coordinator", weight: 1 },
       { agentId: "critic", agentName: "Critic", role: "critic", weight: 2, veto: true },
       { agentId: "bug-hunter", agentName: "Bug Hunter", role: "bug-hunter", weight: 1.5 },
       { agentId: "security-scanner", agentName: "Security Scanner", role: "security-scanner", weight: 1.5 },
@@ -13971,11 +14368,12 @@ ${input.detail}`
     } catch {
     }
   }
-  _sleep(ms) {
-    return new Promise((r) => setTimeout(r, ms));
+  /** Emit a CoordinatorEvent to the subscriber (e.g. TUI panel timeline). */
+  _emit(event) {
+    this.onCoordinatorEvent?.(event);
   }
 };
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MEDIUM_BUDGET, META_AGENTS, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, normalizeRecipient, recordPackageAction, resolveMailboxIdentity, resolveProjectDir, rosterSummaryFromConfigs, scoreAgents, startPackageOutdatedWatcher, updatePackageOutdatedStatus, withDisabledToolFiltering };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MEDIUM_BUDGET, META_AGENTS, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, normalizeRecipient, recordPackageAction, resolveMailboxIdentity, resolveProjectDir, rosterSummaryFromConfigs, scoreAgents, startPackageOutdatedWatcher, updatePackageOutdatedStatus, withDisabledToolFiltering };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map