@wrongstack/core 0.9.19 → 0.9.20

package/dist/index.js

@@ -56,8 +56,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat9 = await fsp2.stat(targetPath);
-      mode = stat9.mode & 511;
+      const stat8 = await fsp2.stat(targetPath);
+      mode = stat8.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -1676,6 +1676,7 @@ var HybridCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateMessages(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
     const policy = readContextWindowPolicy(ctx);
     const preserveK = policy?.preserveK ?? this.preserveK;
@@ -1691,9 +1692,12 @@ var HybridCompactor = class {
       ctx.state.replaceMessages(repaired.messages);
     }
     const afterTokens = this.estimateMessages(ctx.messages);
+    const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
       after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
       reductions,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
@@ -1702,6 +1706,14 @@ var HybridCompactor = class {
       } : void 0
     };
   }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
+  }
   eliseOldToolResults(ctx, preserveK = this.preserveK, eliseThreshold = this.eliseThreshold) {
     const messages = ctx.messages;
     let pairCount = 0;
@@ -4036,11 +4048,11 @@ function validateAgainstSchema(value, schema) {
   walk2(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk2(value, schema, path31, errors) {
+function walk2(value, schema, path35, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path31 || "<root>",
+        path: path35 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -4049,7 +4061,7 @@ function walk2(value, schema, path31, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path31 || "<root>",
+        path: path35 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -4059,19 +4071,19 @@ function walk2(value, schema, path31, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path31, req), message: "required property missing" });
+        errors.push({ path: joinPath(path35, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk2(obj[key], subSchema, joinPath(path31, key), errors);
+          walk2(obj[key], subSchema, joinPath(path35, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk2(item, schema.items, `${path31}[${i}]`, errors));
+    value.forEach((item, i) => walk2(item, schema.items, `${path35}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -4126,80 +4138,85 @@ function deepEqual(a, b) {
 
 // src/utils/json-repair.ts
 function completePartialObject(s) {
-  let result = s;
-  const trimmed = result.trim();
-  if (!trimmed.startsWith("{")) return s;
-  for (let pass = 0; pass < 3; pass++) {
-    let braceDepth = 0;
-    let inString2 = false;
-    let escaped2 = false;
-    let foundClose = false;
-    for (const ch of result) {
-      if (escaped2) {
-        escaped2 = false;
+  if (!s.trim().startsWith("{")) return s;
+  if (tryParse(s).ok) return s;
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let sawKey = false;
+  let prevSig = "";
+  let contentEnd = 0;
+  let stringBraceDepth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (inString) {
+      contentEnd = i + 1;
+      if (escaped) {
+        escaped = false;
         continue;
       }
       if (ch === "\\") {
-        escaped2 = true;
+        escaped = true;
         continue;
       }
       if (ch === '"') {
-        inString2 = !inString2;
+        inString = false;
+        prevSig = '"';
+        stringBraceDepth = 0;
         continue;
       }
-      if (inString2) continue;
-      if (ch === "{") {
-        braceDepth++;
-        foundClose = false;
-      } else if (ch === "}") {
-        braceDepth--;
-        if (braceDepth === 0) foundClose = true;
-      }
-    }
-    if (foundClose || braceDepth <= 0) break;
-    result += "}".repeat(braceDepth);
-  }
-  if (tryParse(result).ok) return result;
-  let inString = false;
-  let escaped = false;
-  for (let i = result.length - 1; i >= 0; i--) {
-    const ch = result[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
+      if (ch === "{") stringBraceDepth++;
+      else if (ch === "}" && stringBraceDepth > 0) stringBraceDepth--;
       continue;
     }
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") continue;
+    contentEnd = i + 1;
     if (ch === '"') {
-      let nextNonWs;
-      for (let j = i + 1; j < result.length; j++) {
-        const nc = result[j];
-        if (nc === " " || nc === "	" || nc === "\n" || nc === "\r") continue;
-        nextNonWs = result[j];
-        break;
-      }
-      if (nextNonWs === ":") {
-        continue;
-      } else {
-        inString = !inString;
-        continue;
-      }
+      inString = true;
+      sawKey = true;
+      stringBraceDepth = 0;
+      prevSig = '"';
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      prevSig = ch;
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      prevSig = ch;
+    } else {
+      prevSig = ch;
     }
   }
+  if (!sawKey && !inString) return s;
+  let result = s.slice(0, contentEnd);
   if (inString) {
-    result = result.trimEnd();
-    if (result.endsWith("\\")) result = result.slice(0, -1);
-    let depth = 0;
-    for (const ch of result) {
-      if (ch === "{") depth++;
-      else if (ch === "}") depth = Math.max(0, depth - 1);
+    if (escaped) {
+      result = result.slice(0, -1);
+    } else if (endsWithInvalidEscape(result)) {
+      result = result.slice(0, -2);
     }
-    result += '"' + "}".repeat(Math.max(1, depth));
+    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
+    result += '"';
+  } else if (prevSig === ":") {
+    result += "null";
+  }
+  for (let k = stack.length - 1; k >= 0; k--) {
+    result += stack[k] === "{" ? "}" : "]";
+  }
+  if (!tryParse(result).ok) {
+    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
+    if (tryParse(patched).ok) result = patched;
   }
   return result;
 }
+var VALID_ESCAPE = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+function endsWithInvalidEscape(str) {
+  const last = str[str.length - 1];
+  if (str[str.length - 2] !== "\\" || last === void 0) return false;
+  if (VALID_ESCAPE.has(last)) return false;
+  let backslashes = 0;
+  for (let k = str.length - 2; k >= 0 && str[k] === "\\"; k--) backslashes++;
+  return backslashes % 2 === 1;
+}
 function tryParse(s) {
   try {
     return { ok: true, value: JSON.parse(s) };
@@ -4340,8 +4357,8 @@ var DefaultSessionStore = class {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat9 = await fsp2.stat(full);
-      const summary = await this.summarize(id, stat9.mtime.toISOString());
+      const stat8 = await fsp2.stat(full);
+      const summary = await this.summarize(id, stat8.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
@@ -4534,7 +4551,6 @@ var FileSessionWriter = class {
     }
     return event;
   }
-  promptIndex = 0;
   pendingFileSnapshots = [];
   /** Tracks open tool_use IDs during the current run to serialize on close for resume. */
   openToolUses = /* @__PURE__ */ new Set();
@@ -4625,7 +4641,6 @@ var FileSessionWriter = class {
       await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
-    this.promptIndex = promptIndex + 1;
     await this.append({
       type: "checkpoint",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4721,6 +4736,38 @@ var FileSessionWriter = class {
 `;
     await fsp2.writeFile(this.filePath, record, "utf8");
   }
+  /**
+   * Idea #1 — write an in-flight marker. The agent loop should call
+   * this at the start of each long-running operation; a matching
+   * `clearInFlightMarker` follows on clean exit. A stale marker
+   * (no end) is what `SessionRecovery.detectStale` looks for.
+   */
+  async writeInFlightMarker(context) {
+    if (!context || context.length > 500) {
+      throw new Error("In-flight context must be 1..500 chars");
+    }
+    await this.append({
+      type: "in_flight_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      context
+    });
+    this.events?.emit("in_flight.started", { context, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  /**
+   * Idea #1 — close the in-flight marker. Idempotent in spirit
+   * (you can call it after a successful iteration even if you
+   * didn't open one this round) — but the session log records
+   * every call so postmortem tooling can see "the agent finished
+   * cleanly X times, then died without finishing Y".
+   */
+  async clearInFlightMarker(reason) {
+    await this.append({
+      type: "in_flight_end",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      reason
+    });
+    this.events?.emit("in_flight.ended", { reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  }
 };
 function userInputTitle(content) {
   const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
@@ -6976,8 +7023,9 @@ var IntelligentCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateTokens(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
-    const load = beforeTokens / this.maxContext;
+    const load = beforeFull / this.maxContext;
     const aggressive = load >= this.hardThreshold ? true : opts.aggressive ?? load >= this.softThreshold;
     const saved1 = this.eliseOldToolResults(ctx);
     if (saved1 > 0) reductions.push({ phase: "elision", saved: saved1 });
@@ -6991,9 +7039,12 @@ var IntelligentCompactor = class {
     const repaired = repairToolUseAdjacency(ctx.messages);
     if (repaired.report.changed) ctx.state.replaceMessages(repaired.messages);
     const afterTokens = this.estimateTokens(ctx.messages);
+    const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
       after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
       reductions,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
@@ -7002,6 +7053,14 @@ var IntelligentCompactor = class {
       } : void 0
     };
   }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
+  }
   async summarizeAncientTurns(ctx) {
     const messages = ctx.messages;
     const cutoff = Math.max(0, messages.length - this.preserveK * 2);
@@ -7014,29 +7073,26 @@ var IntelligentCompactor = class {
     try {
       summaryText = await this.callSummarizer(toSummarize, ctx);
     } catch {
-      const toolNames = /* @__PURE__ */ new Set();
-      const filePaths = /* @__PURE__ */ new Set();
-      let userTurns = 0;
-      let assistantTurns = 0;
+      const preservedMessages = [];
       for (const m of toSummarize) {
-        if (m.role === "user") userTurns++;
-        else if (m.role === "assistant") {
-          assistantTurns++;
-          if (Array.isArray(m.content)) {
-            for (const b of m.content) {
-              if (b.type === "tool_use") toolNames.add(b.name ?? "unknown");
-            }
-          }
+        if (m.role === "system") continue;
+        if (typeof m.content === "string") {
+          preservedMessages.push(m);
+        } else if (Array.isArray(m.content)) {
+          const textParts = m.content.filter(isTextBlock);
+          const toolParts = m.content.filter((b) => b.type === "tool_use" || b.type === "tool_result");
+          const next = {
+            role: m.role,
+            content: [
+              ...textParts,
+              ...toolParts.length > 0 ? [{ type: "text", text: `[${toolParts.length} tool call(s) omitted]` }] : []
+            ]
+          };
+          preservedMessages.push(next);
         }
-        const text = typeof m.content === "string" ? m.content : "";
-        const matches = text.matchAll(/(?:[\w.,\-/@]+\/)*[\w.,\-/@]+\.\w+/g);
-        for (const m_ of matches) filePaths.add(m_[0]);
       }
-      const parts = [`${toSummarize.length} turns (${userTurns} user, ${assistantTurns} assistant)`];
-      if (toolNames.size > 0) parts.push(`tools: ${[...toolNames].join(", ")}`);
-      if (filePaths.size > 0) parts.push(`files: ${[...filePaths].slice(0, 10).join(", ")}`);
-      summaryText = parts.join(" | ");
-      if (!summaryText) summaryText = `${toSummarize.length} earlier turns omitted`;
+      summaryText = preservedMessages.map((m) => `[${m.role}]: ${typeof m.content === "string" ? m.content : m.content.filter(isTextBlock).map((b) => b.text).join(" ")}`).join("\n");
+      if (!summaryText) summaryText = `${toSummarize.length} earlier turns (semantic content preserved)`;
     }
     const summaryMsg = {
       role: "system",
@@ -7282,7 +7338,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       const res = await this.provider.complete(req, { signal: ac.signal });
       const textBlocks = res.content.filter(isTextBlock);
       raw = textBlocks.map((b) => b.text).join("\n").trim();
-    } catch (err) {
+    } catch (_err) {
       return this.fallbackSelect(messages, effectiveBudget);
     }
     return this.parseSelectorOutput(raw, messages.length);
@@ -7374,15 +7430,24 @@ var SelectiveCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateTokens(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
-    const load = beforeTokens / this.maxContext;
+    const load = beforeFull / this.maxContext;
     const shouldCompact = load >= this.warnThreshold || opts.aggressive;
     if (!shouldCompact) {
       const saved = this.eliseOldToolResults(ctx);
       if (saved > 0) reductions.push({ phase: "elision", saved });
       const repair2 = this.repairProtocolAdjacency(ctx);
       const afterTokens2 = this.estimateTokens(ctx.messages);
-      return { before: beforeTokens, after: afterTokens2, reductions, repaired: repair2 };
+      const afterFull2 = this.estimateFullRequest(ctx);
+      return {
+        before: beforeTokens,
+        after: afterTokens2,
+        fullRequestTokensBefore: beforeFull,
+        fullRequestTokensAfter: afterFull2,
+        reductions,
+        repaired: repair2
+      };
     }
     const savedElision = this.eliseOldToolResults(ctx);
     if (savedElision > 0) reductions.push({ phase: "elision", saved: savedElision });
@@ -7394,7 +7459,23 @@ var SelectiveCompactor = class {
     }
     const repair = this.repairProtocolAdjacency(ctx);
     const afterTokens = this.estimateTokens(ctx.messages);
-    return { before: beforeTokens, after: afterTokens, reductions, repaired: repair };
+    const afterFull = this.estimateFullRequest(ctx);
+    return {
+      before: beforeTokens,
+      after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
+      reductions,
+      repaired: repair
+    };
+  }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
   }
   repairProtocolAdjacency(ctx) {
     const repaired = repairToolUseAdjacency(ctx.messages);
@@ -7584,7 +7665,8 @@ var LEVEL_RANK2 = { warn: 0, soft: 1, hard: 2 };
 var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
-  estimator;
+  /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
+  _estimator;
   warnThreshold;
   softThreshold;
   hardThreshold;
@@ -7594,19 +7676,6 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   events;
   failureMode;
   policyProvider;
-  /**
-   * Calibration factor applied to the estimator output. The estimator is now
-   * expected to already include messages + system prompt + tool definitions
-   * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
-   * as a constant so a future calibration against real provider tokenization
-   * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
-   * threshold-check math.
-   *
-   * Historical note: was 1.3 when the estimator only counted messages — that
-   * double-counted system+tools once the estimator was upgraded, firing
-   * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
-   */
-  static OVERHEAD_FACTOR = 1;
   /**
    * Once a compaction attempt reduces nothing (preserveK protects everything,
    * no oversized tool_results remain to elide), retrying on every iteration
@@ -7619,8 +7688,11 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   lastNoopAttempt = null;
   /**
    * @param compactor        Compactor to use for compaction.
-   * @param maxContext       Provider's max context window in tokens.
-   * @param estimator        Token estimation function.
+   * @param maxContext Provider's max context window in tokens.
+   * @param _estimator       Deprecated parameter kept for backward compatibility.
+   *                         The middleware now uses `estimateRequestTokens` internally
+   *                         for accurate full-request token counting (messages +
+   *                         systemPrompt + toolDefs).
    * @param thresholds       Threshold fractions (0-1) of maxContext.
    * @param opts             Optional behavior. By default, failures at the
    *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
@@ -7628,11 +7700,11 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
    *                         provider context overflow. Warn/soft failures
    *                         still emit compaction.failed and continue.
    */
-  constructor(compactor, maxContext, estimator, thresholds, optsOrAggressiveOn = {}, events) {
+  constructor(compactor, maxContext, _estimator, thresholds, optsOrAggressiveOn = {}, events) {
     const opts = typeof optsOrAggressiveOn === "string" ? { aggressiveOn: optsOrAggressiveOn, events } : optsOrAggressiveOn;
     this.compactor = compactor;
     this._maxContext = maxContext;
-    this.estimator = estimator;
+    this._estimator = _estimator;
     this.warnThreshold = thresholds.warn;
     this.softThreshold = thresholds.soft;
     this.hardThreshold = thresholds.hard;
@@ -7648,8 +7720,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   }
   handler() {
     return async (ctx, next) => {
-      const rawTokens = this.estimator(ctx);
-      const tokens = Math.ceil(rawTokens * _AutoCompactionMiddleware.OVERHEAD_FACTOR);
+      const tokens = this._estimator ? this._estimator(ctx) : estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []).total;
       const load = tokens / this._maxContext;
       const policy = this.policyProvider?.(ctx);
       const thresholds = policy?.thresholds ?? {
@@ -7684,7 +7755,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     return delta < _AutoCompactionMiddleware.NOOP_RETRY_DELTA_TOKENS;
   }
   recordAttempt(level, tokens, report) {
-    const reduced = report.before > report.after;
+    const reduced = (report.fullRequestTokensBefore ?? report.before) > (report.fullRequestTokensAfter ?? report.after);
     const repaired = !!report.repaired;
     if (reduced || repaired) {
       this.lastNoopAttempt = null;
@@ -8617,17 +8688,7 @@ var SubagentBudget = class _SubagentBudget {
   startTime = null;
   _onThreshold;
   /**
-   * Tracks which budget kinds currently have an extension request
-   * in flight. While a kind is here, further `checkLimit` calls for the
-   * 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 `negotiateExtension`'s
-   * `finally`.
-   */
-  pendingExtensions = /* @__PURE__ */ new Set();
-  /**
-   * Hard cap on how long `negotiateExtension` 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.
@@ -8689,38 +8750,83 @@ var SubagentBudget = class _SubagentBudget {
    * - `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) {
+  /**
+   * Collects all exceeded budget kinds into a single NOOP-free negotiation.
+   * Called by recordIteration / recordToolCall / recordUsage — each may call
+   * this for its own kind. The first call starts the negotiation and stores
+   * the Promise in _pendingNegotiation. Subsequent calls for DIFFERENT
+   * kinds (while a negotiation is in flight) are NOOPs — they don't start
+   * new conversations with the coordinator. This prevents an EventBus flood
+   * when multiple budget kinds are exceeded simultaneously in one iteration.
+   *
+   * Returns the kinds that were found to be exceeded (for logging/debugging).
+   */
+  checkLimits(elapsedMs) {
+    const exceeded = [];
+    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
+      exceeded.push({ kind: "iterations", used: this.iterations, limit: this.limits.maxIterations });
+    }
+    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
+      exceeded.push({ kind: "tool_calls", used: this.toolCalls, limit: this.limits.maxToolCalls });
+    }
+    const totalTokens = this.tokenInput + this.tokenOutput;
+    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
+      exceeded.push({ kind: "tokens", used: totalTokens, limit: this.limits.maxTokens });
+    }
+    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
+      exceeded.push({ kind: "cost", used: this.costUsd, limit: this.limits.maxCostUsd });
+    }
+    if (elapsedMs !== void 0 && this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs) {
+      exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
+    }
+    if (exceeded.length === 0) return [];
     if (!this._onThreshold) {
-      throw new BudgetExceededError(kind, limit, used);
+      const first2 = exceeded[0];
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     if (this._mode === "sync") {
-      throw new BudgetExceededError(kind, limit, used);
+      const first2 = exceeded[0];
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     const bus = this._events;
     if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
-      throw new BudgetExceededError(kind, limit, used);
+      const first2 = exceeded[0];
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
+    }
+    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);
     }
-    if (this.pendingExtensions.has(kind)) return;
-    this.pendingExtensions.add(kind);
-    const decision = this.negotiateExtension(kind, used, limit);
-    throw new BudgetThresholdSignal(kind, limit, used, decision);
+    const first = exceeded[0];
+    const decision = this._pendingNegotiations.get(first.kind);
+    throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
   }
+  /**
+   * Per-kind in-flight negotiation Promises. Each budget kind can have its
+   * own concurrent negotiation — e.g. iterations and timeout can both
+   * be exceeded simultaneously without blocking each other. The same kind
+   * cannot start two concurrent negotiations (dedup guard).
+   * Cleared in `_negotiateExtension`'s `finally` block.
+   */
+  _pendingNegotiations = /* @__PURE__ */ new Map();
   /**
    * Drive the threshold handler to a decision. Resolves with `'stop'`
    * (signal the runner to abort) or `{ extend: ... }` (limits already
-   * patched in-place; the runner should not abort). Always releases the
-   * `pendingExtensions` slot in `finally`.
+   * patched in-place; the runner should not abort). Clears the
+   * per-kind slot in `_pendingNegotiations` in `finally`.
    *
    * The 'continue' return from a sync handler is treated as
    * `{ extend: {} }` — keep going without patching; next overrun fires
    * a fresh signal.
    */
-  async negotiateExtension(kind, used, limit) {
+  async _negotiateExtension(kind, exceeded) {
     try {
+      const first = exceeded[0];
       const result = this._onThreshold({
-        kind,
-        used,
-        limit,
+        kind: first.kind,
+        used: first.used,
+        limit: first.limit,
         requestDecision: () => {
           const bus = this._events;
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
@@ -8737,20 +8843,22 @@ var SubagentBudget = class _SubagentBudget {
               () => respond("stop"),
               _SubagentBudget.DECISION_TIMEOUT_MS
             );
-            bus.emit("budget.threshold_reached", {
-              kind,
-              used,
-              limit,
-              timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
-              extend: (extra) => {
-                clearTimeout(fallback);
-                respond({ extend: extra });
-              },
-              deny: () => {
-                clearTimeout(fallback);
-                respond("stop");
-              }
-            });
+            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");
+                }
+              });
+            }
           });
         }
       });
@@ -8776,47 +8884,39 @@ var SubagentBudget = class _SubagentBudget {
       }
       return decision;
     } finally {
-      this.pendingExtensions.delete(kind);
+      this._pendingNegotiations.delete(kind);
     }
   }
   recordIteration() {
     this.iterations++;
-    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
-      void this.checkLimit("iterations", this.iterations, this.limits.maxIterations);
-    }
+    void this.checkLimits();
   }
   recordToolCall() {
     this.toolCalls++;
-    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
-      void this.checkLimit("tool_calls", this.toolCalls, this.limits.maxToolCalls);
-    }
+    void this.checkLimits();
   }
   recordUsage(usage, costUsd = 0) {
     this.tokenInput += usage.input;
     this.tokenOutput += usage.output;
     this.costUsd += costUsd;
-    const totalTokens = this.tokenInput + this.tokenOutput;
-    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
-      void this.checkLimit("tokens", totalTokens, this.limits.maxTokens);
-    }
-    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
-      void this.checkLimit("cost", this.costUsd, this.limits.maxCostUsd);
-    }
+    void this.checkLimits();
   }
   /**
-   * 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.
+   * Wall-clock budget check. Unlike other limits, timeout is always a hard stop
+   * — wall-clock time cannot be "extended" by the coordinator, so it throws
+   * synchronously rather than entering the negotiation flow.
+   *
+   * Decision table:
+   * - no `onThreshold` handler         → throw `BudgetExceededError`
+   * - `mode === 'sync'`               → throw `BudgetExceededError`
+   * - `mode === 'auto'` + no listener  → throw `BudgetExceededError`
+   * - `mode === 'auto'` + listener     → throw `BudgetExceededError` (timeout is not extendable)
    */
   checkTimeout() {
     if (this.startTime === null || this.limits.timeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
-    if (elapsed > this.limits.timeoutMs) {
-      void this.checkLimit("timeout", elapsed, this.limits.timeoutMs);
-    }
+    if (elapsed <= this.limits.timeoutMs) return;
+    void this.checkLimits(elapsed);
   }
   /** Returns true if a timeout has occurred without throwing. Useful for races. */
   isTimedOut() {
@@ -11604,6 +11704,107 @@ var FLEET_ROSTER_WITHACP = {
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
 };
 
+// src/coordination/subagent-nicknames.ts
+var NICKNAME_POOL = {
+  // Physics & fundamental sciences
+  "einstein": { name: "Einstein", domain: "physics" },
+  "newton": { name: "Newton", domain: "physics" },
+  "feynman": { name: "Feynman", domain: "physics" },
+  "dirac": { name: "Dirac", domain: "physics" },
+  "bohr": { name: "Bohr", domain: "physics" },
+  "planck": { name: "Planck", domain: "physics" },
+  "curie": { name: "Curie", domain: "physics" },
+  "fermi": { name: "Fermi", domain: "physics" },
+  "heisenberg": { name: "Heisenberg", domain: "physics" },
+  "schrodinger": { name: "Schr\xF6dinger", domain: "physics" },
+  // Mathematics
+  "euclid": { name: "Euclid", domain: "math" },
+  "gauss": { name: "Gauss", domain: "math" },
+  "turing": { name: "Turing", domain: "math" },
+  "poincare": { name: "Poincar\xE9", domain: "math" },
+  "riemann": { name: "Riemann", domain: "math" },
+  "hilbert": { name: "Hilbert", domain: "math" },
+  "pythagoras": { name: "Pythagoras", domain: "math" },
+  // Computing & information theory
+  "von-neumann": { name: "Von Neumann", domain: "computing" },
+  "shannon": { name: "Shannon", domain: "computing" },
+  "hopper": { name: "Hopper", domain: "computing" },
+  "backus": { name: "Backus", domain: "computing" },
+  "knuth": { name: "Knuth", domain: "computing" },
+  "torvalds": { name: "Torvalds", domain: "computing" },
+  "stallman": { name: "Stallman", domain: "computing" },
+  "berners-lee": { name: "Berners-Lee", domain: "computing" },
+  "babbage": { name: "Babbage", domain: "computing" },
+  "lovelace": { name: "Lovelace", domain: "computing" },
+  "klein": { name: "Klein", domain: "computing" },
+  // Electronics & electrical engineering
+  "edison": { name: "Edison", domain: "ee" },
+  "tesla": { name: "Tesla", domain: "ee" },
+  "faraday": { name: "Faraday", domain: "ee" },
+  "maxwell": { name: "Maxwell", domain: "ee" },
+  "ohm": { name: "Ohm", domain: "ee" },
+  "bell": { name: "Bell", domain: "ee" },
+  "marconi": { name: "Marconi", domain: "ee" },
+  "lamarr": { name: "Lamarr", domain: "ee" },
+  // General science / multi-disciplinary
+  "darwin": { name: "Darwin", domain: "biology" },
+  "mendel": { name: "Mendel", domain: "biology" },
+  "pasteur": { name: "Pasteur", domain: "biology" },
+  "hawking": { name: "Hawking", domain: "cosmology" },
+  "sagan": { name: "Sagan", domain: "cosmology" },
+  // Chemistry / materials
+  "lavoisier": { name: "Lavoisier", domain: "chemistry" },
+  "mendeleev": { name: "Mendeleev", domain: "chemistry" }
+};
+var ALL_NICKNAMES = Object.values(NICKNAME_POOL);
+var DOMAIN_PREFERENCES = {
+  "security": ["shannon", "turing", "lamarr", "stallman"],
+  "bug-hunter": ["darwin", "curie", "feynman", "fermi"],
+  "refactor": ["gauss", "hilbert", "euclid", "planck"],
+  "audit-log": ["sagan", "hawking", "poincare", "newton"],
+  "planner": ["hilbert", "gauss", "turing", "euclid"],
+  "researcher": ["sagan", "hawking", "darwin", "pasteur"],
+  "explorer": ["marconi", "bell", "columbus", "polo"],
+  "testing": ["pasteur", "curie", "fermi", "bohr"],
+  "frontend": ["lovelace", "hopper", "babbage", "backus"],
+  "backend": ["torvalds", "stallman", "von-neumann", "backus"],
+  "database": ["turing", "shannon", "backus", "knuth"],
+  "devops": ["tesla", "edison", "faraday", "bell"],
+  "security-scanner": ["shannon", "turing", "lamarr", "stallman"],
+  "refactor-planner": ["gauss", "hilbert", "planck", "newton"],
+  "architect": ["von-neumann", "turing", "gauss", "hilbert"],
+  "critic": ["einstein", "feynman", "dirac", "bohr"],
+  "e2e": ["hopper", "bell", "marconi", "tesla"],
+  "performance": ["knuth", "gauss", "planck", "feynman"],
+  "chaos": ["tesla", "edison", "curie", "fermi"],
+  "cost": ["ohm", "bell", "marconi", "tesla"],
+  // default fallback
+  "default": ["einstein", "newton", "curie", "tesla", "edison", "turing", "shannon", "hopper", "knuth", "stallman"]
+};
+function assignNickname(role, used) {
+  const preferences = [
+    ...DOMAIN_PREFERENCES[role] ?? [],
+    ...DOMAIN_PREFERENCES["default"] ?? []
+  ];
+  for (const key of preferences) {
+    const entry = NICKNAME_POOL[key];
+    if (entry && !used.has(key)) {
+      return `${entry.name} (${formatRole(role)})`;
+    }
+  }
+  for (const entry of ALL_NICKNAMES) {
+    const key = Object.entries(NICKNAME_POOL).find(([, v]) => v.name === entry.name)?.[0];
+    if (key && !used.has(key)) {
+      return `${entry.name} (${formatRole(role)})`;
+    }
+  }
+  const counter = used.size + 1;
+  return `Scientist #${counter} (${formatRole(role)})`;
+}
+function formatRole(role) {
+  return role.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+
 // src/coordination/multi-agent-coordinator.ts
 var DefaultMultiAgentCoordinator = class extends EventEmitter {
   coordinatorId;
@@ -11611,6 +11812,15 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   runner;
   fleetBus;
   subagents = /* @__PURE__ */ new Map();
+  /**
+   * Base nickname keys already handed out this run (e.g. `einstein`, `tesla`).
+   * Prevents two workers sharing a name. Direct `coordinator.spawn()` callers
+   * (parallel/eternal engine, SDD parallel run) don't go through
+   * `Director.spawn()` where nicknames are normally assigned, so the
+   * coordinator upgrades placeholder names ("Executor", "slot-ab12cd", role
+   * names) to memorable ones here — that's what surfaces in the fleet monitor.
+   */
+  usedNicknames = /* @__PURE__ */ new Set();
   pendingTasks = [];
   completedResults = [];
   totalIterations = 0;
@@ -11659,7 +11869,26 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.config.maxConcurrent = Math.floor(n);
     this.tryDispatchNext();
   }
+  /**
+   * Upgrade a placeholder/role-derived name to a memorable scientist nickname
+   * (e.g. "Einstein (Executor)"). A name is treated as a placeholder when it is
+   * empty, equals the role (case-insensitive), is a generic default
+   * ("subagent"/"adhoc"/"generic"), or is an auto-generated `slot-…` id.
+   * Explicit, human-chosen names — including nicknames already assigned by
+   * `Director.spawn()` — are left untouched, so this never double-assigns.
+   */
+  withNickname(subagent) {
+    const role = subagent.role ?? "subagent";
+    const name = subagent.name?.trim() ?? "";
+    const isPlaceholder = name === "" || name.toLowerCase() === role.toLowerCase() || name === "subagent" || name === "adhoc" || name === "generic" || /^slot-/.test(name);
+    if (!isPlaceholder) return subagent;
+    const nickname = assignNickname(role, this.usedNicknames);
+    const baseKey = nickname.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    this.usedNicknames.add(baseKey);
+    return { ...subagent, name: nickname };
+  }
   async spawn(subagent) {
+    subagent = this.withNickname(subagent);
     const id = subagent.id || randomUUID();
     if (this.subagents.has(id)) {
       throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
@@ -12253,12 +12482,12 @@ var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
   constructor(opts) {
     this.opts = opts;
-    this.goalPath = goalFilePath(opts.projectRoot);
+    this.goalPath = opts.goalPath ?? goalFilePath(opts.projectRoot);
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
     this.timeoutMs = opts.iterationTimeoutMs ?? 3e5;
     this.dispatchEnabled = opts.dispatch !== false;
     this.dispatchClassifier = opts.dispatchClassifier;
-    this.agentFactory = opts.subagentFactory ?? (async (config) => ({
+    this.agentFactory = opts.subagentFactory ?? (async (_config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
     }));
@@ -12352,7 +12581,6 @@ var ParallelEternalEngine = class {
     }
     const tasks = await this.decomposeGoal(goal);
     if (!tasks || tasks.length === 0) {
-      await sleep2(5e3);
       return false;
     }
     const fanOut = await this.fanOut(goal, tasks);
@@ -12373,6 +12601,7 @@ var ParallelEternalEngine = class {
     });
     if (fanOut.goalComplete) {
       this.stopRequested = true;
+      this.state = "stopped";
       return true;
     }
     await this.maybeCompact();
@@ -12553,7 +12782,11 @@ ${lastFew}` : "No prior iterations.",
       } finally {
         clearTimeout(timer);
       }
-    } catch {
+    } catch (err) {
+      this.opts.onError?.(
+        err instanceof Error ? err : new Error(String(err)),
+        this.consecutiveFailures
+      );
       return [];
     }
   }
@@ -12770,7 +13003,11 @@ Working rules:
      thrashing, terminate it rather than letting cost climb silently.
   6. Never claim a subagent's work as your own without verifying it. If a
      result looks wrong, ask_subagent for clarification before passing it
-     to the user.`;
+     to the user.
+  7. Wind down when satisfied. When the results are good enough, call
+     work_complete \u2014 no new subagents will spawn and queued tasks complete
+     as aborted. Running subagents finish naturally. Call terminate_subagent
+     only for ones you need to stop immediately.`;
 var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
 a specific slice of a larger plan \u2014 do that slice well and report back.
 
@@ -12915,14 +13152,12 @@ var FleetBus = class {
 };
 var FleetUsageAggregator = class {
   constructor(bus, priceLookup, metaLookup) {
-    this.bus = bus;
     this.priceLookup = priceLookup;
     this.metaLookup = metaLookup;
     bus.filter("provider.response", (e) => this.onProviderResponse(e));
     bus.filter("tool.executed", (e) => this.onToolExecuted(e));
     bus.filter("iteration.started", (e) => this.onIterationStarted(e));
   }
-  bus;
   priceLookup;
   metaLookup;
   perSubagent = /* @__PURE__ */ new Map();
@@ -12990,106 +13225,6 @@ var FleetUsageAggregator = class {
     snap.lastEventAt = e.ts;
   }
 };
-
-// src/coordination/subagent-nicknames.ts
-var NICKNAME_POOL = {
-  // Physics & fundamental sciences
-  "einstein": { name: "Einstein", domain: "physics" },
-  "newton": { name: "Newton", domain: "physics" },
-  "feynman": { name: "Feynman", domain: "physics" },
-  "dirac": { name: "Dirac", domain: "physics" },
-  "bohr": { name: "Bohr", domain: "physics" },
-  "planck": { name: "Planck", domain: "physics" },
-  "curie": { name: "Curie", domain: "physics" },
-  "fermi": { name: "Fermi", domain: "physics" },
-  "heisenberg": { name: "Heisenberg", domain: "physics" },
-  "schrodinger": { name: "Schr\xF6dinger", domain: "physics" },
-  // Mathematics
-  "euclid": { name: "Euclid", domain: "math" },
-  "gauss": { name: "Gauss", domain: "math" },
-  "turing": { name: "Turing", domain: "math" },
-  "poincare": { name: "Poincar\xE9", domain: "math" },
-  "riemann": { name: "Riemann", domain: "math" },
-  "hilbert": { name: "Hilbert", domain: "math" },
-  "pythagoras": { name: "Pythagoras", domain: "math" },
-  // Computing & information theory
-  "von-neumann": { name: "Von Neumann", domain: "computing" },
-  "shannon": { name: "Shannon", domain: "computing" },
-  "hopper": { name: "Hopper", domain: "computing" },
-  "backus": { name: "Backus", domain: "computing" },
-  "knuth": { name: "Knuth", domain: "computing" },
-  "torvalds": { name: "Torvalds", domain: "computing" },
-  "stallman": { name: "Stallman", domain: "computing" },
-  "berners-lee": { name: "Berners-Lee", domain: "computing" },
-  "babbage": { name: "Babbage", domain: "computing" },
-  "lovelace": { name: "Lovelace", domain: "computing" },
-  "klein": { name: "Klein", domain: "computing" },
-  // Electronics & electrical engineering
-  "edison": { name: "Edison", domain: "ee" },
-  "tesla": { name: "Tesla", domain: "ee" },
-  "faraday": { name: "Faraday", domain: "ee" },
-  "maxwell": { name: "Maxwell", domain: "ee" },
-  "ohm": { name: "Ohm", domain: "ee" },
-  "bell": { name: "Bell", domain: "ee" },
-  "marconi": { name: "Marconi", domain: "ee" },
-  "lamarr": { name: "Lamarr", domain: "ee" },
-  // General science / multi-disciplinary
-  "darwin": { name: "Darwin", domain: "biology" },
-  "mendel": { name: "Mendel", domain: "biology" },
-  "pasteur": { name: "Pasteur", domain: "biology" },
-  "hawking": { name: "Hawking", domain: "cosmology" },
-  "sagan": { name: "Sagan", domain: "cosmology" },
-  // Chemistry / materials
-  "lavoisier": { name: "Lavoisier", domain: "chemistry" },
-  "mendeleev": { name: "Mendeleev", domain: "chemistry" }
-};
-var ALL_NICKNAMES = Object.values(NICKNAME_POOL);
-var DOMAIN_PREFERENCES = {
-  "security": ["shannon", "turing", "lamarr", "stallman"],
-  "bug-hunter": ["darwin", "curie", "feynman", "fermi"],
-  "refactor": ["gauss", "hilbert", "euclid", "planck"],
-  "audit-log": ["sagan", "hawking", "poincare", "newton"],
-  "planner": ["hilbert", "gauss", "turing", "euclid"],
-  "researcher": ["sagan", "hawking", "darwin", "pasteur"],
-  "explorer": ["marconi", "bell", "columbus", "polo"],
-  "testing": ["pasteur", "curie", "fermi", "bohr"],
-  "frontend": ["lovelace", "hopper", "babbage", "backus"],
-  "backend": ["torvalds", "stallman", "von-neumann", "backus"],
-  "database": ["turing", "shannon", "backus", "knuth"],
-  "devops": ["tesla", "edison", "faraday", "bell"],
-  "security-scanner": ["shannon", "turing", "lamarr", "stallman"],
-  "refactor-planner": ["gauss", "hilbert", "planck", "newton"],
-  "architect": ["von-neumann", "turing", "gauss", "hilbert"],
-  "critic": ["einstein", "feynman", "dirac", "bohr"],
-  "e2e": ["hopper", "bell", "marconi", "tesla"],
-  "performance": ["knuth", "gauss", "planck", "feynman"],
-  "chaos": ["tesla", "edison", "curie", "fermi"],
-  "cost": ["oh", "bell", "marconi", "tesla"],
-  // default fallback
-  "default": ["einstein", "newton", "curie", "tesla", "edison", "turing", "shannon", "hopper", "knuth", "stallman"]
-};
-function assignNickname(role, used) {
-  const preferences = [
-    ...DOMAIN_PREFERENCES[role] ?? [],
-    ...DOMAIN_PREFERENCES["default"] ?? []
-  ];
-  for (const key of preferences) {
-    if (!used.has(key)) {
-      return `${NICKNAME_POOL[key].name} (${formatRole(role)})`;
-    }
-  }
-  for (const entry of ALL_NICKNAMES) {
-    const key = Object.entries(NICKNAME_POOL).find(([, v]) => v.name === entry.name)?.[0];
-    if (key && !used.has(key)) {
-      return `${entry.name} (${formatRole(role)})`;
-    }
-  }
-  const counter = used.size + 1;
-  return `Scientist #${counter} (${formatRole(role)})`;
-}
-function formatRole(role) {
-  return role.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
 function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
@@ -13260,7 +13395,7 @@ function makeRollUpTool(director) {
 function makeTerminateTool(director) {
   return {
     name: "terminate_subagent",
-    description: "Forcibly abort a subagent.",
+    description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
     permission: "auto",
     mutating: true,
     inputSchema: { type: "object", properties: { subagentId: { type: "string", description: "Subagent to abort." } }, required: ["subagentId"] },
@@ -13271,6 +13406,19 @@ function makeTerminateTool(director) {
     }
   };
 }
+function makeTerminateAllTool(director) {
+  return {
+    name: "terminate_all",
+    description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
+    permission: "auto",
+    mutating: true,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      await director.terminateAll();
+      return { ok: true, message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.` };
+    }
+  };
+}
 function makeFleetStatusTool(director) {
   return {
     name: "fleet_status",
@@ -13413,7 +13561,7 @@ function makeCollabDebugTool(director) {
 function makeFleetEmitTool(director) {
   return {
     name: "fleet_emit",
-    description: "Emit a structured event on the FleetBus. Use this when you find a bug (bug.found), complete a refactor plan (refactor.plan), or finish an evaluation (critic.evaluation). Events are routed to other agents in the collab session.",
+    description: "Emit a structured event on the FleetBus. Any subagent can emit any event type; the Director routes it to all listeners. Use it to stream findings, progress updates, or final results to other agents in real time.",
     permission: "auto",
     mutating: false,
     inputSchema: {
@@ -13421,14 +13569,14 @@ function makeFleetEmitTool(director) {
       properties: {
         type: {
           type: "string",
-          description: "Event type: bug.found | refactor.plan | critic.evaluation"
+          description: "Event type string (e.g. bug.found, refactor.plan, critic.evaluation, progress, result)."
         },
         payload: {
           type: "object",
-          description: "Event payload matching the event type."
+          description: "Event payload. Structure depends on event type. Use null if no payload."
         }
       },
-      required: ["type", "payload"]
+      required: ["type"]
     },
     async execute(input) {
       const i = input;
@@ -13436,12 +13584,25 @@ function makeFleetEmitTool(director) {
         subagentId: director.id,
         ts: Date.now(),
         type: i.type,
-        payload: i.payload
+        payload: i.payload ?? {}
       });
       return { ok: true, event: i.type };
     }
   };
 }
+function makeWorkCompleteTool(director) {
+  return {
+    name: "work_complete",
+    description: "Signal that the director is satisfied with the results and the fleet should wind down. After calling this, spawn_subagent will refuse with a budget error and assign_task will instantly complete any queued tasks as aborted. Running subagents finish naturally. Call terminate_subagent separately to stop specific subagents immediately.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      director.workComplete();
+      return { ok: true, message: "Fleet wind-down signaled. No new spawns or task dispatches." };
+    }
+  };
+}
 var CollabSession = class extends EventEmitter {
   sessionId;
   options;
@@ -13456,6 +13617,14 @@ var CollabSession = class extends EventEmitter {
   disposers = new Array();
   settled = false;
   timeoutMs;
+  cancelled = false;
+  alerts = [];
+  /** Tracks tool call counts per subagent for progress-based timeout decisions. */
+  progressBySubagent = /* @__PURE__ */ new Map();
+  /** Last tool call count when a timeout warning was handled. */
+  lastTimeoutProgress = /* @__PURE__ */ new Map();
+  /** Session-level timeout timer handle (cleared on cancel or natural completion). */
+  _timeoutTimer;
   constructor(director, fleetBus, options) {
     super();
     this.sessionId = randomUUID();
@@ -13473,11 +13642,23 @@ var CollabSession = class extends EventEmitter {
       };
     }
   }
+  get id() {
+    return this.sessionId;
+  }
+  getSessionAlerts() {
+    return [...this.alerts];
+  }
+  isCancelled() {
+    return this.cancelled;
+  }
   /**
-   * Read the target files from disk and populate the snapshot.
-   * Call this after construction if you did not provide a prebuiltSnapshot
-   * and want the session to operate on real file contents.
+   * Snapshot of role → subagentId map. The Director calls coordinator.stop()
+   * for each agent when cancelling the session, using this map to enumerate
+   * all three collab agents.
    */
+  getSubagentIds() {
+    return new Map(this.subagentIds);
+  }
   async buildSnapshot() {
     if (this.snapshot.files.length > 0) return this.snapshot;
     for (const filePath of this.options.targetPaths) {
@@ -13493,9 +13674,30 @@ var CollabSession = class extends EventEmitter {
     return this.snapshot;
   }
   /**
-   * Start the collaborative session: snapshot files, spawn all three agents,
-   * wire up event routing, and wait for completion.
+   * Cancel the session. Emits director.cancel_collab on the FleetBus so all
+   * collab agents finish early. The session-level timeout timer is also cleared.
+   * Safe to call multiple times (idempotent after first call).
    */
+  cancel(reason = "Director cancelled collab session") {
+    if (this.settled) return;
+    this.cancelled = true;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = void 0;
+    }
+    this.fleetBus.emit({
+      subagentId: this.director.id,
+      ts: Date.now(),
+      type: "director.cancel_collab",
+      payload: { sessionId: this.sessionId, reason, cancelledAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    this.fleetBus.emit({
+      subagentId: this.director.id,
+      ts: Date.now(),
+      type: "collab.cancelled",
+      payload: { sessionId: this.sessionId, reason }
+    });
+  }
   async start() {
     if (this.settled) throw new Error("session already settled");
     this.settled = true;
@@ -13510,10 +13712,10 @@ var CollabSession = class extends EventEmitter {
     this.subagentIds.set("refactor-planner", refactorPlannerId);
     this.subagentIds.set("critic", criticId);
     const timeout = new Promise((_, reject) => {
-      setTimeout(
-        () => reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`)),
-        this.timeoutMs
-      );
+      this._timeoutTimer = setTimeout(() => {
+        this.cancel("Session-level timeout reached");
+        reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
     });
     let results;
     try {
@@ -13526,6 +13728,10 @@ var CollabSession = class extends EventEmitter {
         timeout
       ]);
     } catch (err) {
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = void 0;
+      }
       this.cleanup();
       const error = err instanceof Error ? err : new Error(String(err));
       this.emit("session.error", error);
@@ -13539,17 +13745,6 @@ var CollabSession = class extends EventEmitter {
     this.emit("session.done", report);
     return report;
   }
-  /**
-   * Parse a completed agent's final text output and route the structured
-   * findings onto the FleetBus. Agents are instructed to emit one JSON object
-   * per finding / plan / evaluation; we scan the output for balanced JSON
-   * objects (tolerating prose, markdown, and ```json fences around them) and
-   * dispatch each by its discriminating key. The wired FleetBus listeners then
-   * collect them into the bugs / plans / evaluations maps.
-   *
-   * Failed or empty results are ignored, and a single malformed object never
-   * aborts the collation pass — see {@link extractJsonObjects}.
-   */
   async parseAndEmit(result) {
     if (result.status !== "success" || result.result == null) return;
     const text = typeof result.result === "string" ? result.result : JSON.stringify(result.result);
@@ -13565,12 +13760,6 @@ var CollabSession = class extends EventEmitter {
       });
     }
   }
-  /**
-   * Extract every top-level JSON object embedded in free-form agent text.
-   * Scans for balanced braces while respecting string literals and escape
-   * sequences, so prose, markdown headers, and code fences around the JSON
-   * are skipped. Malformed spans are dropped silently rather than thrown.
-   */
   extractJsonObjects(text) {
     const objects = [];
     let depth = 0;
@@ -13607,25 +13796,33 @@ var CollabSession = class extends EventEmitter {
     }
     return objects;
   }
+  budgetForRole(role) {
+    if (this.options.budgetOverrides?.[role]) {
+      return this.options.budgetOverrides[role];
+    }
+    const defaults = {
+      "bug-hunter": { maxIterations: 2e3, maxToolCalls: 5e3, timeoutMs: 10 * 60 * 1e3 },
+      "refactor-planner": { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 },
+      "critic": { maxIterations: 1e3, maxToolCalls: 3e3, timeoutMs: 6 * 60 * 1e3 }
+    };
+    return defaults[role] ?? { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 };
+  }
   async spawnAgent(role, taskBrief) {
+    const budget = this.budgetForRole(role);
     const cfg = {
       id: `${role}-${this.sessionId}`,
       name: role,
-      role
-      // No fleet_emit tool — agents output structured JSON, the Director parses
-      // results and emits FleetBus events. This keeps the agent simple and the
-      // routing deterministic.
+      role,
+      tools: ["fleet_emit", "fleet_status", "read", "grep", "glob", "bash", "write"],
+      maxIterations: budget.maxIterations,
+      maxToolCalls: budget.maxToolCalls,
+      timeoutMs: budget.timeoutMs
     };
     const subagentId = await this.director.spawn(cfg);
-    await this.director.assign({
-      id: randomUUID(),
-      subagentId,
-      description: taskBrief
-    });
+    await this.director.assign({ id: randomUUID(), subagentId, description: taskBrief });
     return subagentId;
   }
   buildBugHunterTask() {
-    this.options.targetPaths.join(", ");
     const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
     const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
 ${f.content}`).join("\n\n");
@@ -13634,13 +13831,17 @@ ${f.content}`).join("\n\n");
 Target files:
 ${fileContents}
 
-For each bug found, write ONE valid JSON line to the scratchpad with this exact structure:
-{ "finding": { "id": "<uuid>", "type": "<pattern>", "severity": "<critical|high|medium|low>", "location": { "file": "<path>", "line": <n> }, "description": "<explain>", "suggestedFix": "<optional>" } }.
-After scanning all files, write your full markdown bug report to the shared scratchpad at:
-${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
+For each bug found, emit it using the fleet_emit tool immediately:
+{ "type": "bug.found", "payload": { "finding": { "id": "<uuid>", "type": "<pattern>", "severity": "<critical|high|medium|low>", "location": { "file": "<path>", "line": <n> }, "description": "<explain>", "suggestedFix": "<optional>" } } }
+
+After scanning all files, write your full markdown bug report to:
+${scratchpad}/bug-hunter-report-${this.sessionId}.md
+
+Important: emit each finding as soon as you find it. Do not batch or wait until the end.`;
   }
   buildRefactorPlannerTask() {
     const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
     const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
 ${f.content}`).join("\n\n");
     return `You are RefactorPlanner. Plan refactorings for the following files.
@@ -13648,26 +13849,146 @@ ${f.content}`).join("\n\n");
 Target files:
 ${fileContents}
 
-Listen for bug.found events from BugHunter on the fleet bus. For each bug, create a refactor plan and write one JSON line per plan:
-{ "plan": { "id": "<uuid>", "basedOnBugIds": ["<bug-id>"], "phases": [...], "riskScore": "<low|medium|high>", "estimatedChangeCount": <n>, "rollbackStrategy": "<text>" } }.
-After planning, write your full markdown plan to:
-${scratchpad}/refactor-plan-${this.sessionId}.md`;
+Read the BugHunter report at: ${bugHunterReportPath}
+
+For each bug you can address, emit a refactor plan using fleet_emit:
+{ "type": "refactor.plan", "payload": { "plan": { "id": "<uuid>", "basedOnBugIds": ["<bug-id>"], "phases": [{ "number": 1, "title": "<phase>", "tasks": ["<task>"], "risk": "<low|medium|high>" }], "riskScore": "<low|medium|high>", "estimatedChangeCount": <n>, "rollbackStrategy": "<text>" } } }
+
+Also write your full markdown plan to:
+${scratchpad}/refactor-plan-${this.sessionId}.md
+
+Emit each plan immediately. Do not wait until planning is complete.`;
   }
   buildCriticTask() {
     const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
+    const refactorPlanPath = `${scratchpad}/refactor-plan-${this.sessionId}.md`;
     const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
 ${f.content}`).join("\n\n");
-    return `You are Critic. Evaluate bug findings and refactor plans as they arrive via fleet bus events.
+    return `You are Critic. Evaluate bug findings and refactor plans.
 
 Target files:
 ${fileContents}
 
-Subscribe to bug.found events (from BugHunter) and refactor.plan events (from RefactorPlanner). For each subject, write one JSON line per evaluation:
-{ "evaluation": { "id": "<uuid>", "subjectType": "<bug_finding|refactor_plan>", "subjectId": "<id>", "score": <0-10>, "verdict": "<approve|needs_revision|reject>", "strengths": [...], "weaknesses": [...], "concerns": [...] } }.
-After all evaluations, write your markdown critic report to:
-${scratchpad}/critic-report-${this.sessionId}.md`;
+Read the BugHunter report at: ${bugHunterReportPath}
+Read the RefactorPlanner report at: ${refactorPlanPath}
+
+For each bug and refactor plan, emit your evaluation using fleet_emit:
+{ "type": "critic.evaluation", "payload": { "evaluation": { "id": "<uuid>", "subjectType": "<bug_finding|refactor_plan>", "subjectId": "<id>", "score": <0-10>, "verdict": "<approve|needs_revision|reject>", "strengths": ["<strength>"], "weaknesses": ["<weakness>"], "concerns": [{ "description": "<concern>", "severity": "<blocking|advisory>" }] } } }
+
+After all evaluations, write your markdown report to:
+${scratchpad}/critic-report-${this.sessionId}.md
+
+Emit each evaluation immediately. Do not wait until you have read all reports.`;
   }
   wireFleetBus() {
+    const dTool = this.fleetBus.filter("tool.executed", (e) => {
+      this.progressBySubagent.set(e.subagentId, (this.progressBySubagent.get(e.subagentId) ?? 0) + 1);
+    });
+    this.disposers.push(dTool);
+    const dBudget = this.fleetBus.filter("budget.threshold_reached", (e) => {
+      const payload = e.payload;
+      const role = this.roleFromSubagentId(e.subagentId);
+      if (!role) return;
+      const btwNotes = this.director.getLeaderBtwNotes();
+      const alert = {
+        sessionId: this.sessionId,
+        subagentId: e.subagentId,
+        role,
+        level: "warning" /* WARNING */,
+        message: `${role} hit ${payload.kind} soft limit (${payload.used}/${payload.limit})`,
+        budgetKind: payload.kind,
+        elapsedMs: payload.timeoutMs,
+        limit: payload.limit,
+        btwNotes
+      };
+      this.alerts.push(alert);
+      this.fleetBus.emit({
+        subagentId: e.subagentId,
+        ts: Date.now(),
+        type: "collab.warning",
+        payload: alert
+      });
+      const decision = this.options.onBudgetWarning?.(alert) ?? "ignore";
+      if (decision === "cancel") {
+        this.cancel(`Director cancelled: ${role} ${payload.kind} threshold`);
+        return;
+      }
+      if (payload.kind === "timeout") {
+        const progress = this.progressBySubagent.get(e.subagentId) ?? 0;
+        const lastProgress = this.lastTimeoutProgress.get(e.subagentId) ?? -1;
+        if (progress <= lastProgress) {
+          payload.deny();
+          return;
+        }
+        this.lastTimeoutProgress.set(e.subagentId, progress);
+        const newLimit = Math.min(Math.ceil((payload.timeoutMs ?? payload.limit) * 2), 24 * 60 * 6e4);
+        setImmediate(() => {
+          payload.extend({ timeoutMs: newLimit });
+        });
+        return;
+      }
+      if (decision === "extend") {
+        setImmediate(() => {
+          const base = Math.max(payload.limit, payload.used);
+          const extra = {};
+          switch (payload.kind) {
+            case "iterations":
+              extra.maxIterations = Math.min(Math.ceil(base * 1.5), 5e4);
+              break;
+            case "tool_calls":
+              extra.maxToolCalls = Math.min(Math.ceil(base * 1.5), 1e5);
+              break;
+            case "tokens":
+              extra.maxTokens = Math.min(Math.ceil(base * 1.5), 5e6);
+              break;
+            case "cost":
+              extra.maxCostUsd = Math.min(base * 1.5, 100);
+              break;
+          }
+          payload.extend(extra);
+        });
+        return;
+      }
+      if (payload.kind !== "timeout") {
+        setImmediate(() => {
+          const base = Math.max(payload.limit, payload.used);
+          const extra = {};
+          switch (payload.kind) {
+            case "iterations":
+              extra.maxIterations = Math.min(Math.ceil(base * 1.25), 5e4);
+              break;
+            case "tool_calls":
+              extra.maxToolCalls = Math.min(Math.ceil(base * 1.25), 1e5);
+              break;
+            case "tokens":
+              extra.maxTokens = Math.min(Math.ceil(base * 1.25), 5e6);
+              break;
+            case "cost":
+              extra.maxCostUsd = Math.min(base * 1.25, 100);
+              break;
+          }
+          payload.extend(extra);
+        });
+      }
+    });
+    this.disposers.push(dBudget);
+    const dCancel = this.fleetBus.filter("director.cancel_collab", (e) => {
+      const payload = e.payload;
+      if (payload.sessionId !== this.sessionId) return;
+      this.cancelled = true;
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = void 0;
+      }
+      this.fleetBus.emit({
+        subagentId: this.director.id,
+        ts: Date.now(),
+        type: "collab.cancelled",
+        payload: { sessionId: this.sessionId, reason: payload.reason }
+      });
+    });
+    this.disposers.push(dCancel);
     const d1 = this.fleetBus.filter("bug.found", (e) => {
       const payload = e.payload;
       if (payload?.finding) {
@@ -13693,10 +14014,19 @@ ${scratchpad}/critic-report-${this.sessionId}.md`;
     });
     this.disposers.push(d3);
   }
+  roleFromSubagentId(subagentId) {
+    for (const [role, id] of this.subagentIds) {
+      if (id === subagentId) return role;
+    }
+    const match = subagentId.match(/^(bug-hunter|refactor-planner|critic)/);
+    return match?.[1] ?? null;
+  }
   assembleReport() {
     const bugList = Array.from(this.bugs.values());
     const planList = Array.from(this.plans.values());
     const evalList = Array.from(this.evaluations.values());
+    let disposition = "completed";
+    if (this.cancelled) disposition = "cancelled";
     const verdictOrder = {
       approve: 0,
       needs_revision: 1,
@@ -13710,33 +14040,41 @@ ${scratchpad}/critic-report-${this.sessionId}.md`;
       },
       "approve"
     );
-    const summary = this.buildMarkdownSummary(bugList, planList, evalList, overallVerdict);
+    const summary = this.buildMarkdownSummary(bugList, planList, evalList, overallVerdict, disposition);
     return {
       sessionId: this.sessionId,
       startedAt: this.snapshot.createdAt,
       completedAt: (/* @__PURE__ */ new Date()).toISOString(),
       targetPaths: this.options.targetPaths,
+      disposition,
       bugs: bugList,
       refactorPlans: planList,
       evaluations: evalList,
+      alerts: [...this.alerts],
       overallVerdict,
       summary
     };
   }
-  buildMarkdownSummary(bugs, plans, evals, overallVerdict) {
+  buildMarkdownSummary(bugs, plans, evals, overallVerdict, disposition) {
     const lines = [
       `## Collaborative Debugging Report \u2014 ${this.sessionId}`,
       "",
       `**Target:** ${this.options.targetPaths.join(", ")}`,
+      `**Disposition:** ${disposition.toUpperCase()}`,
       `**Overall Verdict:** **${overallVerdict.toUpperCase()}**`,
       ""
     ];
+    if (this.alerts.length > 0) {
+      lines.push("### Alerts", "");
+      for (const alert of this.alerts) {
+        lines.push(`- **[${alert.level.toUpperCase()}]** ${alert.role}: ${alert.message}`);
+      }
+      lines.push("");
+    }
     if (bugs.length > 0) {
       lines.push("### Bugs Found", "");
       for (const b of bugs) {
-        lines.push(
-          `- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`
-        );
+        lines.push(`- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`);
       }
       lines.push("");
     }
@@ -13755,9 +14093,7 @@ ${scratchpad}/critic-report-${this.sessionId}.md`;
       for (const e of evals) {
         lines.push(`- [${e.subjectType}] score=${e.score}/10 \u2014 **${e.verdict.toUpperCase()}**`);
         for (const c of e.concerns) {
-          if (c.severity === "blocking") {
-            lines.push(`  - ${c.description}`);
-          }
+          if (c.severity === "blocking") lines.push(`  - ${c.description}`);
         }
       }
       lines.push("");
@@ -13775,10 +14111,9 @@ var FleetSpawnBudgetError = class extends Error {
   kind;
   limit;
   observed;
-  constructor(kind, limit, observed) {
-    super(
-      kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`
-    );
+  constructor(kind, limit, observed, message) {
+    const defaultMsg = kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`;
+    super(message ?? defaultMsg);
     this.name = "FleetSpawnBudgetError";
     this.kind = kind;
     this.limit = limit;
@@ -13799,6 +14134,20 @@ var FleetCostCapError = class extends Error {
     this.observed = observed;
   }
 };
+var FleetContextOverflowError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Leader context overflow: leader has ${observed} tokens in flight (limit: ${limit}). Compact the leader context before spawning more subagents.`
+    );
+    this.name = "FleetContextOverflowError";
+    this.kind = "max_context_load";
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
 var Director = class {
   /** Alias for the ICoordinator contract. `id` is retained for backward compatibility. */
   get coordinatorId() {
@@ -13815,6 +14164,25 @@ var Director = class {
    * injected; otherwise own FleetUsageAggregator.
    */
   usage;
+  /**
+   * Update the leader agent's current context pressure (full request tokens:
+   * messages + systemPrompt + toolDefs). The director checks this before every
+   * spawn — if the pressure exceeds `maxLeaderContextLoad * maxContext`,
+   * spawning is refused with a `FleetContextOverflowError`.
+   *
+   * Call this after each leader agent iteration to keep the pressure current.
+   * The compactor's `CompactReport.fullRequestTokensAfter` is a natural source.
+   */
+  setLeaderContextPressure(tokens) {
+    this.leaderContextPressure = tokens;
+    this.fleetManager?.setLeaderContextPressure(tokens);
+  }
+  /**
+   * Read the leader agent's current context pressure.
+   */
+  getLeaderContextPressure() {
+    return this.leaderContextPressure;
+  }
   /**
    * Optional fleet-level policy container. When provided the Director
    * delegates spawn budgeting, manifest entries, and checkpointing to it
@@ -13900,6 +14268,23 @@ var Director = class {
   taskCompletedListener = null;
   /** Optional LLM classifier for smart dispatch. Passed from options. */
   dispatchClassifier;
+  /** Leader agent's current context pressure (full request tokens). */
+  leaderContextPressure = 0;
+  /** Maximum context load fraction before spawn is refused. */
+  maxLeaderContextLoad;
+  /** Provider's max context window in tokens. */
+  maxContext;
+  /**
+   * When set by `workComplete()`, the director stops dispatching new tasks
+   * and terminates all running subagents. Used when the director's LLM decides
+   * the goal is satisfied and no further spawns are needed — prevents the
+   * coordinator from keeping workers alive for tasks that will never arrive.
+   */
+  workCompleteFlag = false;
+  /** Pending /btw notes stashed by the leader agent (see setLeaderBtwNote). */
+  _leaderBtwNotes = [];
+  /** Active collab sessions tracked by sessionId (see spawnCollab). */
+  _activeCollabSessions = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID();
     this.manifestPath = opts.manifestPath;
@@ -13915,6 +14300,8 @@ var Director = class {
     this.dispatchClassifier = opts.dispatchClassifier;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
     this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
+    this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
+    this.maxContext = opts.maxContext ?? 128e3;
     this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? this.id;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
@@ -13942,7 +14329,7 @@ var Director = class {
       this.fleet = new FleetBus();
       this.usage = new FleetUsageAggregator(
         this.fleet,
-        (id, provider, model) => {
+        (_id, provider, model) => {
           if (provider && model) return this.priceLookups.get(`${provider}/${model}`);
           return void 0;
         },
@@ -14004,6 +14391,9 @@ var Director = class {
     });
     this.fleet.filter("budget.threshold_reached", (e) => {
       const payload = e.payload;
+      if (e.subagentId.startsWith("bug-hunter-") || e.subagentId.startsWith("refactor-planner-") || e.subagentId.startsWith("critic-")) {
+        return;
+      }
       if (payload.kind === "timeout") {
         const progress = progressBySubagent.get(e.subagentId) ?? 0;
         const lastProgress = lastTimeoutProgress.get(e.subagentId) ?? -1;
@@ -14082,6 +14472,107 @@ var Director = class {
   extensionsFor(subagentId) {
     return this.extendTotals.get(subagentId) ?? 0;
   }
+  /**
+   * Signal that the director's work is done. Once called:
+   * - `spawn()` throws `FleetSpawnBudgetError('max_spawns', …)` — no new
+   *   subagents can be created
+   * - Running subagents are NOT forcibly stopped — they finish naturally,
+   *   but no new tasks are dispatched to them
+   *
+   * This lets the director LLM say "I'm satisfied with the results, stop
+   * spawning and wind down" — without killing in-flight work mid-execution.
+   * Call `terminateAll()` separately if you need immediate teardown.
+   *
+   * Idempotent — calling twice is a no-op.
+   */
+  workComplete() {
+    this.workCompleteFlag = true;
+    this.fleet.emit({ subagentId: this.id, ts: Date.now(), type: "director.work_complete", payload: {} });
+  }
+  /** Returns true if `workComplete()` has been called on this director. */
+  isWorkComplete() {
+    return this.workCompleteFlag;
+  }
+  /**
+   * Stashes a /btw note on the leader agent's context. The leader's agent loop
+   * calls `consumeBtwNotes()` at each iteration boundary and folds pending notes
+   * into the conversation as a visible block — no abort, no restart, just a
+   * "by the way" nudge the model picks up on its next turn.
+   *
+   * This is the entry point for the host (CLI, TUI) to inject /btw notes
+   * programmatically without going through the slash-command path.
+   */
+  setLeaderBtwNote(note) {
+    const trimmed = note.trim();
+    if (!trimmed) return this._leaderBtwNotes.length;
+    this._leaderBtwNotes = [...this._leaderBtwNotes, trimmed].slice(-20);
+    return this._leaderBtwNotes.length;
+  }
+  /**
+   * Read and clear all pending /btw notes the leader has stashed.
+   * Returns them in FIFO order (empty array when none).
+   *
+   * Called by CollabSession when a budget threshold event fires so the
+   * Director can inspect accumulated /btw notes before deciding whether
+   * to cancel the collab session or let it continue.
+   */
+  getLeaderBtwNotes() {
+    const notes = this._leaderBtwNotes;
+    this._leaderBtwNotes = [];
+    return notes;
+  }
+  /**
+   * Peek at pending /btw notes without consuming them.
+   * Useful for UI to show "N pending notes" without clearing them.
+   */
+  peekLeaderBtwNotes() {
+    return [...this._leaderBtwNotes];
+  }
+  /**
+   * Drain (read + clear) all /btw notes in one call.
+   * Alias for getLeaderBtwNotes() — kept for symmetry with consumeBtwNotes()
+   * in the agent's btw.ts. The Director calls this at the point where it
+   * makes a cancellation decision, not on every budget event.
+   */
+  drainLeaderBtwNotes() {
+    return this.getLeaderBtwNotes();
+  }
+  /**
+   * Cancel an active collab session by its id.
+   * Emits `director.cancel_collab` on the FleetBus so the session's agents
+   * finish early with a 'cancelled' disposition.
+   *
+   * Returns silently if the session id is not tracked or already settled.
+   * The CollabDebugReport will reflect 'cancelled' disposition when awaited.
+   */
+  cancelCollabSession(sessionId, reason = "Director cancelled") {
+    const session = this._activeCollabSessions.get(sessionId);
+    if (!session || session.isCancelled()) return;
+    session.cancel(reason);
+    for (const [_role, subagentId] of session.getSubagentIds()) {
+      this.coordinator.stop(subagentId).catch(() => {
+      });
+    }
+  }
+  /**
+   * Subscribe a callback to be notified whenever a collab session raises
+   * an alert (warning level). The callback receives the full DirectorAlert
+   * payload so the host (CLI, TUI) can display it to the user.
+   * Returns an unsubscribe function.
+   */
+  onCollabAlert(handler) {
+    return this.fleet.filter("collab.warning", (e) => {
+      handler(e.payload);
+    });
+  }
+  /**
+   * Returns all active (not yet settled) collab session ids.
+   * Useful for the TUI to render a "N active sessions" badge and for
+   * the host to know what can be cancelled.
+   */
+  activeCollabSessions() {
+    return Array.from(this._activeCollabSessions.keys());
+  }
   /** Best-effort session-writer append. Swallows failures — the director
    *  must not break a fleet run because the session JSONL handle closed. */
   async appendSessionEvent(event) {
@@ -14120,12 +14611,21 @@ var Director = class {
    * it the `cost` column in `usage.snapshot()` stays at 0.
    */
   async spawn(config, priceLookup) {
+    if (this.workCompleteFlag) {
+      throw new FleetSpawnBudgetError(
+        "max_spawns",
+        this.maxSpawns,
+        this.spawnCount + 1,
+        "workComplete() has been called \u2014 director closed further spawning"
+      );
+    }
     if (this.fleetManager) {
       const rejection = this.fleetManager.canSpawn(config);
       if (rejection) {
         if (rejection.kind === "max_spawn_depth") throw new FleetSpawnBudgetError("max_spawn_depth", rejection.limit, rejection.observed);
         if (rejection.kind === "max_spawns") throw new FleetSpawnBudgetError("max_spawns", rejection.limit, rejection.observed);
         if (rejection.kind === "max_cost_usd") throw new FleetCostCapError(rejection.limit, rejection.observed);
+        if (rejection.kind === "max_context_load") throw new FleetContextOverflowError(rejection.limit, rejection.observed);
       }
     } else {
       if (this.spawnDepth >= this.maxSpawnDepth) {
@@ -14140,9 +14640,15 @@ var Director = class {
           throw new FleetCostCapError(this.maxFleetCostUsd, totalCost);
         }
       }
+      if (this.maxLeaderContextLoad < 1) {
+        const threshold = this.maxContext * this.maxLeaderContextLoad;
+        if (this.leaderContextPressure >= threshold) {
+          throw new FleetContextOverflowError(threshold, this.leaderContextPressure);
+        }
+      }
     }
     let result;
-    const needsNickname = config.name === config.role || !config.name || config.name === "subagent";
+    const needsNickname = config.name === config.role || !config.name || config.name === "subagent" || config.name === "adhoc";
     if (needsNickname) {
       const role = config.role ?? "subagent";
       if (this.fleetManager) {
@@ -14367,6 +14873,24 @@ var Director = class {
    */
   async assign(task) {
     const taskWithId = task.id ? task : { ...task, id: randomUUID() };
+    if (this.workCompleteFlag) {
+      const synthetic = {
+        subagentId: taskWithId.subagentId ?? "unassigned",
+        taskId: taskWithId.id,
+        status: "stopped",
+        error: { kind: "aborted_by_parent", message: "Director called workComplete() \u2014 no further tasks will run", retryable: false },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      };
+      this.completed.set(taskWithId.id, synthetic);
+      const waiter = this.taskWaiters.get(taskWithId.id);
+      if (waiter) {
+        waiter.resolve(synthetic);
+        this.taskWaiters.delete(taskWithId.id);
+      }
+      return taskWithId.id;
+    }
     if (task.subagentId) {
       if (this.fleetManager) {
         this.fleetManager.addTaskToSubagent(task.subagentId, taskWithId.id);
@@ -14589,12 +15113,14 @@ var Director = class {
       makeAskTool(this),
       makeRollUpTool(this),
       makeTerminateTool(this),
+      makeTerminateAllTool(this),
       makeFleetStatusTool(this),
       makeFleetUsageTool(this),
       makeFleetSessionTool(this),
       makeFleetHealthTool(this),
       makeCollabDebugTool(this),
-      makeFleetEmitTool(this)
+      makeFleetEmitTool(this),
+      makeWorkCompleteTool(this)
     ];
     return t2;
   }
@@ -14614,7 +15140,15 @@ var Director = class {
    * three agents complete or the session times out.
    */
   async spawnCollab(options) {
-    const session = new CollabSession(this, this.fleet, options);
+    const session = new CollabSession(this, this.fleet, {
+      ...options,
+      onBudgetWarning: (alert) => {
+        return options.onBudgetWarning?.(alert) ?? "ignore";
+      }
+    });
+    this._activeCollabSessions.set(session.sessionId, session);
+    session.on("session.done", () => this._activeCollabSessions.delete(session.sessionId));
+    session.on("session.error", () => this._activeCollabSessions.delete(session.sessionId));
     return session.start();
   }
   /**
@@ -15104,8 +15638,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path6.join(modesDir, entry);
-      const stat9 = await fsp2.stat(filePath);
-      if (!stat9.isFile()) continue;
+      const stat8 = await fsp2.stat(filePath);
+      if (!stat8.isFile()) continue;
       const content = await fsp2.readFile(filePath, "utf8");
       const id = path6.basename(entry, path6.extname(entry));
       modes.push({
@@ -16379,9 +16913,9 @@ var AISpecBuilder = class {
     if (!this.sessionPath) return;
     try {
       const fsp19 = await import('fs/promises');
-      const path31 = await import('path');
+      const path35 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp19.mkdir(path31.dirname(this.sessionPath), { recursive: true });
+      await fsp19.mkdir(path35.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -17033,7 +17567,7 @@ function analyzeCriticalPath(graph) {
     blockedTasks
   };
 }
-function getTransitiveBlocked(graph, taskId, blocksMap) {
+function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
@@ -17049,7 +17583,7 @@ function getTransitiveBlocked(graph, taskId, blocksMap) {
   }
   return visited;
 }
-function computeCriticalPath(graph, topoOrder, blockedByMap) {
+function computeCriticalPath(graph, _topoOrder, blockedByMap) {
   const allIds = Array.from(graph.nodes.keys());
   if (allIds.length === 0) return [];
   const dist = /* @__PURE__ */ new Map();
@@ -17091,15 +17625,15 @@ function computeCriticalPath(graph, topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path31 = [];
+  const path35 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path31.unshift(current);
+    path35.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path31;
+  return path35;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -17467,13 +18001,11 @@ function createAutoExecutor(opts) {
 
 // src/sdd/sdd-task-decomposer.ts
 var SddTaskDecomposer = class {
-  constructor(tracker, graph, opts = {}) {
+  constructor(tracker, _graph, opts = {}) {
     this.tracker = tracker;
-    this.graph = graph;
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
   }
   tracker;
-  graph;
   slots;
   wave = 0;
   // -------------------------------------------------------------------
@@ -17626,7 +18158,7 @@ var SddParallelRun = class {
     this.coordinator.setRunner?.(runner);
   }
   defaultFactory() {
-    return async (config) => ({
+    return async (_config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
     });
@@ -18079,7 +18611,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path31 = opts.path ?? "/metrics";
+  const path35 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -18089,7 +18621,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path31) {
+    if (url === path35) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -18153,7 +18685,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path31}`,
+    url: `${protocol}://${host}:${boundPort}${path35}`,
     close: () => new Promise((resolve9, reject) => {
       server.close((err) => err ? reject(err) : resolve9());
     })
@@ -18440,6 +18972,12 @@ function roughEstimate(messages) {
   return total;
 }
 function createContextManagerTool(opts = {}) {
+  const minCompactThreshold = opts.minCompactThreshold ?? 0;
+  const noopRetryDeltaTokens = opts.noopRetryDeltaTokens ?? 2e3;
+  const maxContext = opts.maxContext ?? 128e3;
+  const compactThresholdFraction = opts.compactThresholdFraction ?? 0.5;
+  const effectiveThreshold = minCompactThreshold > 0 ? minCompactThreshold : Math.floor(maxContext * compactThresholdFraction);
+  let lastNoopTokens = 0;
   return {
     name: CONTEXT_MANAGER_TOOL_NAME,
     description: 'Inspect or reorganize the conversation context window. Use "check" to see token budget. Use "summary" to collapse a message range into a concise note (provide "text" for custom summary). Use "prune" to remove specific messages by index. Use "add_note" to inject a summary note. Use "compact" to run aggressive compaction. Use "repair" to remove orphan tool_use/tool_result blocks after manual context surgery.',
@@ -18530,11 +19068,41 @@ function createContextManagerTool(opts = {}) {
               notes: "No compactor registered. Use /compact aggressive via slash command instead."
             };
           }
+          const fullEstimate = input.systemPrompt != null && Array.isArray(input.tools) ? estimateRequestTokens(messages, input.systemPrompt, input.tools) : { total: beforeTokens};
+          const currentTokens = fullEstimate.total;
+          if (lastNoopTokens > 0) {
+            const delta = currentTokens - lastNoopTokens;
+            if (delta < noopRetryDeltaTokens) {
+              return {
+                action: "compact",
+                beforeTokens,
+                afterTokens: beforeTokens,
+                messageCount: messages.length,
+                notes: `Compact is a NOOP retry: context grew only ${delta} tokens since the last no-op attempt (threshold: ${noopRetryDeltaTokens}). Skip until more content accumulates.`
+              };
+            }
+          }
+          if (currentTokens < effectiveThreshold) {
+            return {
+              action: "compact",
+              beforeTokens,
+              afterTokens: beforeTokens,
+              messageCount: messages.length,
+              notes: `Context tokens (${currentTokens}) below compact threshold (${effectiveThreshold}). Skipping.`
+            };
+          }
           const report = await opts.compactor.compact(ctx);
           ctx.clearFileTracking();
           const repair = applyMessages([...ctx.messages]);
           const afterTokens = repair.changed ? roughEstimate(ctx.messages) : report.after;
           const repaired = report.repaired ?? (repair.changed ? repair : void 0);
+          const reduced = report.fullRequestTokensBefore > report.fullRequestTokensAfter;
+          const repairedSomething = !!report.repaired;
+          if (reduced || repairedSomething) {
+            lastNoopTokens = 0;
+          } else {
+            lastNoopTokens = currentTokens;
+          }
           return {
             action: "compact",
             beforeTokens,
@@ -19000,10 +19568,10 @@ var SkillInstaller = class {
           if (!resolved.startsWith(path6.resolve(destDir))) {
             throw new Error(`Path traversal detected in skill file: ${file}`);
           }
-          const stat9 = await fsp2.stat(srcPath);
-          if (stat9.size > MAX_SKILL_FILE_SIZE) {
+          const stat8 = await fsp2.stat(srcPath);
+          if (stat8.size > MAX_SKILL_FILE_SIZE) {
             throw new Error(
-              `Skill file "${file}" is too large (${(stat9.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
+              `Skill file "${file}" is too large (${(stat8.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
             );
           }
           await fsp2.mkdir(path6.dirname(destPath), { recursive: true });
@@ -19042,7 +19610,7 @@ var SkillInstaller = class {
    * - Name: update that specific skill
    * - Name + newRef: update to a different ref
    */
-  async update(nameOrRef, opts) {
+  async update(nameOrRef, _opts) {
     const result = { updated: [], unchanged: [], errors: [] };
     const allEntries = await this.manifest.listAll();
     let targets;
@@ -19112,140 +19680,756 @@ var SkillInstaller = class {
     return result;
   }
   /**
-   * Uninstall a skill by name.
+   * Uninstall a skill by name.
+   */
+  async uninstall(name, opts) {
+    const scope = opts?.global ? "user" : "project";
+    const entries = await this.manifest.findByName(name);
+    const entry = entries.find((e) => e.scope === scope);
+    if (!entry) {
+      throw new Error(`Skill "${name}" is not installed${scope === "user" ? " (global)" : ""}.`);
+    }
+    await this.removeSkillFiles(name, scope);
+    await this.manifest.removeEntry(name, scope);
+    this.invalidateLoaderCache();
+  }
+  /**
+   * List all installed skills from the manifest.
+   */
+  async listInstalled() {
+    return this.manifest.listAll();
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  /**
+   * Detect skills in an extracted repository.
+   * Returns an array of detected skills with their files.
+   */
+  async detectSkills(baseDir) {
+    const results = [];
+    const rootSkillMd = path6.join(baseDir, "SKILL.md");
+    try {
+      await fsp2.access(rootSkillMd);
+      const content = await fsp2.readFile(rootSkillMd, "utf8");
+      const meta = parseFrontmatter2(content);
+      if (meta.name && meta.description) {
+        results.push({
+          name: meta.name,
+          baseDir,
+          files: ["SKILL.md"]
+        });
+        return results;
+      }
+    } catch {
+    }
+    const skillsDir = path6.join(baseDir, "skills");
+    try {
+      const entries = await fsp2.readdir(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillFile = path6.join(skillsDir, entry.name, "SKILL.md");
+        try {
+          const content = await fsp2.readFile(skillFile, "utf8");
+          const meta = parseFrontmatter2(content);
+          if (meta.name && meta.description) {
+            const skillDir = path6.join(skillsDir, entry.name);
+            const files = await collectFiles(skillDir, skillDir);
+            results.push({
+              name: meta.name,
+              baseDir: skillDir,
+              files
+            });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return results;
+  }
+  /**
+   * Remove all files for an installed skill.
+   */
+  async removeSkillFiles(name, scope) {
+    const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
+    const skillDir = path6.join(targetDir, name);
+    await fsp2.rm(skillDir, { recursive: true, force: true });
+  }
+  /**
+   * Invalidate the skill loader's cache so newly installed skills appear.
+   */
+  invalidateLoaderCache() {
+    const loader = this.opts.skillLoader;
+    if (loader && typeof loader.invalidateCache === "function") {
+      loader.invalidateCache();
+    }
+  }
+};
+function parseFrontmatter2(raw) {
+  if (!raw.startsWith("---")) return {};
+  const end = raw.indexOf("\n---", 4);
+  if (end === -1) return {};
+  const block = raw.slice(4, end);
+  const out = {};
+  let key = null;
+  let value = [];
+  const flush = () => {
+    if (key) {
+      out[key] = value.join("\n").trim();
+    }
+    key = null;
+    value = [];
+  };
+  for (const line of block.split("\n")) {
+    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
+    if (m) {
+      flush();
+      key = m[1] ?? "";
+      const pipe = m[2];
+      const rest = m[3] ?? "";
+      if (pipe === "|") {
+        value = [];
+      } else if (rest) {
+        value = [rest];
+      } else {
+        value = [];
+      }
+    } else if (key) {
+      value.push(line.replace(/^\s+/, ""));
+    }
+  }
+  flush();
+  return out;
+}
+async function collectFiles(dir, baseDir) {
+  const results = [];
+  const entries = await fsp2.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path6.join(dir, entry.name);
+    const relPath = path6.relative(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      results.push(...await collectFiles(fullPath, baseDir));
+    } else {
+      results.push(relPath);
+    }
+  }
+  return results;
+}
+
+// src/storage/annotations-store.ts
+init_atomic_write();
+var FILE_VERSION = 1;
+var MAX_TEXT_LENGTH = 2e3;
+var MAX_ANNOTATIONS = 1e3;
+var AnnotationsStore = class {
+  dir;
+  /** Per-session write queue. Created lazily on first add. */
+  writeChains = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.dir = opts.dir;
+  }
+  // ── Reads ──────────────────────────────────────────────────────────────
+  /**
+   * Return all annotations for `sessionId` in insertion order
+   * (oldest first). Returns an empty array when no file exists
+   * yet (the normal case for a fresh session).
+   */
+  async list(sessionId) {
+    const file = await this.readFile(sessionId);
+    return file ? file.annotations : [];
+  }
+  /**
+   * Convenience: only unresolved annotations, newest first — the
+   * common UI rendering for "what still needs attention?".
+   */
+  async listOpen(sessionId) {
+    const all = await this.list(sessionId);
+    return all.filter((a) => !a.resolved).reverse();
+  }
+  // ── Writes ─────────────────────────────────────────────────────────────
+  /**
+   * Add a new annotation. Returns the persisted record (with id
+   * and timestamps filled in). Throws when `text` is empty or
+   * exceeds `MAX_TEXT_LENGTH`.
+   */
+  async add(input) {
+    const text = input.text.trim();
+    if (text.length === 0) {
+      throw new Error("Annotation text must be non-empty");
+    }
+    if (text.length > MAX_TEXT_LENGTH) {
+      throw new Error(
+        `Annotation text exceeds ${MAX_TEXT_LENGTH} chars (got ${text.length})`
+      );
+    }
+    if (!Number.isInteger(input.atEventIndex) || input.atEventIndex < 0) {
+      throw new Error("atEventIndex must be a non-negative integer");
+    }
+    const annotation = {
+      id: randomUUID(),
+      sessionId: input.sessionId,
+      atEventIndex: input.atEventIndex,
+      authorId: input.authorId,
+      authorRole: "annotator",
+      text,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      resolved: false
+    };
+    await this.enqueue(input.sessionId, async () => {
+      const all = await this.list(input.sessionId);
+      all.push(annotation);
+      if (all.length > MAX_ANNOTATIONS) {
+        const sorted = all.map((a, i) => ({ a, i })).sort((x, y) => {
+          if (x.a.resolved !== y.a.resolved) return x.a.resolved ? 1 : -1;
+          return x.a.createdAt.localeCompare(y.a.createdAt);
+        });
+        const evictCount = all.length - MAX_ANNOTATIONS;
+        const toEvict = new Set(sorted.slice(0, evictCount).map((s) => s.a.id));
+        const kept = all.filter((a) => !toEvict.has(a.id));
+        await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: kept });
+      } else {
+        await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
+      }
+    });
+    return annotation;
+  }
+  /**
+   * Mark an annotation as resolved. Returns the updated record, or
+   * `null` if no annotation with that id exists in this session.
+   * Idempotent: resolving an already-resolved annotation refreshes
+   * `resolvedAt` / `resolvedBy` to the latest call.
+   */
+  async resolve(input) {
+    let updated = null;
+    await this.enqueue(input.sessionId, async () => {
+      const all = await this.list(input.sessionId);
+      const idx = all.findIndex((a) => a.id === input.annotationId);
+      if (idx === -1) {
+        updated = null;
+        return;
+      }
+      const next = {
+        ...all[idx],
+        resolved: true,
+        resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        resolvedBy: input.resolvedBy
+      };
+      all[idx] = next;
+      await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
+      updated = next;
+    });
+    return updated;
+  }
+  // ── Internals ──────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.annotations.json`);
+  }
+  async readFile(sessionId) {
+    const fp = this.filePath(sessionId);
+    try {
+      const raw = await fsp2.readFile(fp, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version !== FILE_VERSION) {
+        return { version: FILE_VERSION, annotations: [] };
+      }
+      return parsed;
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return { version: FILE_VERSION, annotations: [] };
+    }
+  }
+  async writeFile(sessionId, file) {
+    const fp = this.filePath(sessionId);
+    await atomicWrite(fp, JSON.stringify(file, null, 2));
+  }
+  /**
+   * Serialize writes per-sessionId. We chain promises instead of
+   * using a Mutex class so the contract is obvious from the
+   * call-site: `enqueue(sid, fn)` runs `fn` after every prior
+   * enqueue for `sid` has settled.
+   */
+  enqueue(sessionId, fn) {
+    const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.writeChains.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
+  }
+};
+
+// src/storage/replay-log-store.ts
+init_atomic_write();
+function stableStringify(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = sortKeys(obj[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function hashRequest(request) {
+  const payload = {
+    model: request.model,
+    system: request.system,
+    messages: request.messages,
+    tools: request.tools,
+    maxTokens: request.maxTokens,
+    temperature: request.temperature,
+    topP: request.topP,
+    stopSequences: request.stopSequences,
+    toolChoice: request.toolChoice
+  };
+  const json = stableStringify(payload);
+  const digest = createHash("sha256").update(json, "utf8").digest("hex");
+  return `sha256:${digest}`;
+}
+var DEFAULT_MAX_ENTRIES = 1e3;
+var ReplayLogStore = class {
+  dir;
+  writeChains = /* @__PURE__ */ new Map();
+  /** Per-session hash → entry index, kept in memory after the first load. */
+  cache = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+  // ── Writes ──────────────────────────────────────────────────────────────
+  /**
+   * Record a request/response pair. Idempotent on hash: a second
+   * `record` for the same hash is a no-op (the existing entry wins).
+   * Returns the hash.
+   */
+  async record(input) {
+    const hash = hashRequest(input.request);
+    await this.enqueue(input.sessionId, async () => {
+      const cache = await this.ensureCache(input.sessionId);
+      if (cache.has(hash)) return;
+      const entry = {
+        hash,
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        request: input.request,
+        response: input.response
+      };
+      let all = [...cache.values(), entry];
+      if (all.length > this.maxEntries) {
+        const evictCount = all.length - this.maxEntries;
+        all = all.slice(evictCount);
+      }
+      await this.writeAll(input.sessionId, all);
+      cache.clear();
+      for (const e of all) cache.set(e.hash, e);
+    });
+    return hash;
+  }
+  // ── Reads ───────────────────────────────────────────────────────────────
+  /**
+   * Look up an entry by hash. Returns `null` when the request has
+   * not been recorded for this session. O(1) after the first call
+   * per session (in-memory cache).
+   */
+  async lookup(sessionId, hash) {
+    const cache = await this.ensureCache(sessionId);
+    return cache.get(hash) ?? null;
+  }
+  /** All recorded entries for a session, in insertion order. */
+  async load(sessionId) {
+    const cache = await this.ensureCache(sessionId);
+    return [...cache.values()];
+  }
+  /**
+   * List every session id that has a replay log in the store dir.
+   * Returns an array of `{ sessionId, entryCount, path }` sorted
+   * by sessionId for stable output. Used by `wstack replay --list`.
+   */
+  async list() {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
+    }
+    const out = [];
+    for (const name of entries) {
+      if (!name.endsWith(".replay.jsonl")) continue;
+      const sessionId = name.slice(0, -".replay.jsonl".length);
+      const all = await this.load(sessionId);
+      out.push({
+        sessionId,
+        entryCount: all.length,
+        path: path6.join(this.dir, name)
+      });
+    }
+    return out.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+  }
+  // ── Internals ───────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.replay.jsonl`);
+  }
+  async readAll(sessionId) {
+    const fp = this.filePath(sessionId);
+    try {
+      const raw = await fsp2.readFile(fp, "utf8");
+      const out = [];
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if ("entry" in parsed && parsed.entry) {
+            out.push(parsed.entry);
+          } else {
+            out.push(parsed);
+          }
+        } catch {
+        }
+      }
+      return out;
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
+    }
+  }
+  async writeAll(sessionId, entries) {
+    const fp = this.filePath(sessionId);
+    const body = entries.map((e) => JSON.stringify(e)).join("\n") + (entries.length ? "\n" : "");
+    await atomicWrite(fp, body);
+  }
+  async ensureCache(sessionId) {
+    let cache = this.cache.get(sessionId);
+    if (cache) return cache;
+    const all = await this.readAll(sessionId);
+    cache = /* @__PURE__ */ new Map();
+    for (const e of all) cache.set(e.hash, e);
+    this.cache.set(sessionId, cache);
+    return cache;
+  }
+  enqueue(sessionId, fn) {
+    const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.writeChains.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
+  }
+};
+var SessionRecovery = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  /**
+   * Scan a session log and return a `StaleSession` if and only
+   * if the last event is an `in_flight_start` without a matching
+   * `in_flight_end`. Returns `null` when:
+   *   - the log does not exist;
+   *   - the log is empty;
+   *   - the last event is `in_flight_end` (clean shutdown);
+   *   - the last event is something else (e.g. an unannotated
+   *     legacy log without in-flight markers).
+   */
+  async detectStale(sessionId) {
+    const fp = this.filePath(sessionId);
+    let raw;
+    try {
+      raw = await fsp2.readFile(fp, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return null;
+    }
+    return this.parseForStale(sessionId, fp, raw);
+  }
+  /**
+   * Generate a recovery plan for a session. The plan describes
+   * "what would be re-executed" if the user chose to resume —
+   * everything after the last `checkpoint` event, plus the
+   * dangling in-flight marker if present.
+   *
+   * Returns a non-null plan for ANY session that has at least
+   * one event after a checkpoint (or, for legacy sessions, at
+   * least one event). Pure read; no mutation.
+   */
+  async recover(sessionId) {
+    const fp = this.filePath(sessionId);
+    let raw;
+    try {
+      raw = await fsp2.readFile(fp, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return null;
+    }
+    const events = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    if (events.length === 0) return null;
+    let lastCheckpoint = null;
+    let lastCheckpointIdx = -1;
+    for (let i = 0; i < events.length; i++) {
+      if (events[i].type === "checkpoint") {
+        lastCheckpoint = events[i];
+        lastCheckpointIdx = i;
+      }
+    }
+    const pendingEvents = lastCheckpointIdx >= 0 ? events.slice(lastCheckpointIdx + 1) : events;
+    const lastEv = events[events.length - 1];
+    const inFlightStart = lastEv.type === "in_flight_start" ? lastEv : null;
+    const context = inFlightStart && inFlightStart.type === "in_flight_start" ? inFlightStart.context : null;
+    return {
+      sessionId,
+      stale: inFlightStart !== null,
+      lastCheckpoint,
+      pendingEvents,
+      inFlightStart,
+      context
+    };
+  }
+  /**
+   * List every stale session in a directory. Returns an array
+   * (possibly empty) sorted by `lastEventTs` descending — most
+   * recent crash first.
    */
-  async uninstall(name, opts) {
-    const scope = opts?.global ? "user" : "project";
-    const entries = await this.manifest.findByName(name);
-    const entry = entries.find((e) => e.scope === scope);
-    if (!entry) {
-      throw new Error(`Skill "${name}" is not installed${scope === "user" ? " (global)" : ""}.`);
+  async listResumable() {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
     }
-    await this.removeSkillFiles(name, scope);
-    await this.manifest.removeEntry(name, scope);
-    this.invalidateLoaderCache();
+    const out = [];
+    for (const name of entries) {
+      if (!name.endsWith(".jsonl")) continue;
+      const sessionId = name.slice(0, -".jsonl".length);
+      if (sessionId.includes(".replay") || sessionId.includes(".annotations")) continue;
+      const stale = await this.detectStale(sessionId);
+      if (stale) out.push(stale);
+    }
+    return out.sort((a, b) => b.lastEventTs.localeCompare(a.lastEventTs));
   }
-  /**
-   * List all installed skills from the manifest.
-   */
-  async listInstalled() {
-    return this.manifest.listAll();
+  // ── Internals ──────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.jsonl`);
   }
-  // ── Private helpers ──────────────────────────────────────────────
   /**
-   * Detect skills in an extracted repository.
-   * Returns an array of detected skills with their files.
+   * Stream-parse the last few lines of a JSONL log. We do NOT load
+   * the whole file into memory — for long-running sessions the log
+   * can be megabytes. Instead we read tail-ward and find the last
+   * `in_flight_start` / `in_flight_end` pair.
    */
-  async detectSkills(baseDir) {
-    const results = [];
-    const rootSkillMd = path6.join(baseDir, "SKILL.md");
-    try {
-      await fsp2.access(rootSkillMd);
-      const content = await fsp2.readFile(rootSkillMd, "utf8");
-      const meta = parseFrontmatter2(content);
-      if (meta.name && meta.description) {
-        results.push({
-          name: meta.name,
-          baseDir,
-          files: ["SKILL.md"]
-        });
-        return results;
+  async parseForStale(sessionId, fp, raw) {
+    const lines = raw.split("\n");
+    let lastEvent = null;
+    let eventCount = 0;
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const ev = JSON.parse(line);
+        lastEvent = ev;
+        eventCount++;
+      } catch {
       }
-    } catch {
     }
-    const skillsDir = path6.join(baseDir, "skills");
-    try {
-      const entries = await fsp2.readdir(skillsDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const skillFile = path6.join(skillsDir, entry.name, "SKILL.md");
-        try {
-          const content = await fsp2.readFile(skillFile, "utf8");
-          const meta = parseFrontmatter2(content);
-          if (meta.name && meta.description) {
-            const skillDir = path6.join(skillsDir, entry.name);
-            const files = await collectFiles(skillDir, skillDir);
-            results.push({
-              name: meta.name,
-              baseDir: skillDir,
-              files
-            });
-          }
-        } catch {
-        }
-      }
-    } catch {
+    if (!lastEvent) return null;
+    if (lastEvent.type === "in_flight_start") {
+      return {
+        sessionId,
+        path: fp,
+        lastEventTs: lastEvent.ts,
+        context: lastEvent.context,
+        eventCount
+      };
     }
-    return results;
+    return null;
+  }
+};
+
+// src/storage/tool-audit-log.ts
+init_atomic_write();
+var GENESIS_PREV = "0".repeat(64);
+var ToolAuditLog = class {
+  dir;
+  /** In-memory cache of the last entry's hash (per session), to compute chains efficiently. */
+  tailHash = /* @__PURE__ */ new Map();
+  writeChains = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.dir = opts.dir;
   }
   /**
-   * Remove all files for an installed skill.
+   * Append a tool call/result pair to the chain. Returns the
+   * resulting entry. Idempotency is not guaranteed — if you
+   * record the same tool_use twice you get two entries. That's
+   * intentional: the audit log is a record, not a cache.
    */
-  async removeSkillFiles(name, scope) {
-    const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
-    const skillDir = path6.join(targetDir, name);
-    await fsp2.rm(skillDir, { recursive: true, force: true });
+  async record(input) {
+    let entry = null;
+    await this.enqueue(input.sessionId, async () => {
+      const prevHash = this.tailHash.get(input.sessionId) ?? GENESIS_PREV;
+      const id = randomUUID();
+      const ts = (/* @__PURE__ */ new Date()).toISOString();
+      const content = {
+        id,
+        ts,
+        prevHash,
+        toolName: input.toolName,
+        toolUseId: input.toolUseId,
+        input: input.input,
+        output: input.output,
+        isError: input.isError
+      };
+      const hash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
+      entry = {
+        index: this.tailHash.has(input.sessionId) ? -1 : 0,
+        // placeholder; recomputed below
+        id,
+        ts,
+        prevHash,
+        hash,
+        toolName: input.toolName,
+        toolUseId: input.toolUseId,
+        input: input.input,
+        output: input.output,
+        isError: input.isError
+      };
+      const existing = await this.readAll(input.sessionId);
+      const index = existing.length;
+      const finalContent = { ...content, index };
+      const finalHash = createHash("sha256").update(stableStringify2(finalContent), "utf8").digest("hex");
+      entry = { ...entry, index, hash: finalHash };
+      await this.appendLine(input.sessionId, entry);
+      this.tailHash.set(input.sessionId, finalHash);
+    });
+    return entry;
   }
   /**
-   * Invalidate the skill loader's cache so newly installed skills appear.
+   * Walk the chain and verify every entry's hash and prevHash.
+   * Returns a structured verdict — never throws.
    */
-  invalidateLoaderCache() {
-    const loader = this.opts.skillLoader;
-    if (loader && typeof loader.invalidateCache === "function") {
-      loader.invalidateCache();
+  async verify(sessionId) {
+    const entries = await this.readAll(sessionId);
+    if (entries.length === 0) return { ok: true, entries: 0 };
+    if (entries[0].prevHash !== GENESIS_PREV) {
+      return {
+        ok: false,
+        brokenAt: 0,
+        reason: "first entry is not the genesis (prevHash != 0\u20260)"
+      };
+    }
+    let prevHash = GENESIS_PREV;
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      if (e.prevHash !== prevHash) {
+        return {
+          ok: false,
+          brokenAt: i,
+          reason: `prevHash mismatch at entry ${i} (expected ${prevHash.slice(0, 8)}\u2026, got ${e.prevHash.slice(0, 8)}\u2026)`
+        };
+      }
+      const content = {
+        id: e.id,
+        ts: e.ts,
+        prevHash: e.prevHash,
+        toolName: e.toolName,
+        toolUseId: e.toolUseId,
+        input: e.input,
+        output: e.output,
+        isError: e.isError,
+        index: e.index
+      };
+      const expectedHash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
+      if (expectedHash !== e.hash) {
+        return {
+          ok: false,
+          brokenAt: i,
+          reason: `hash mismatch at entry ${i} (entry content was modified)`
+        };
+      }
+      prevHash = e.hash;
     }
+    return { ok: true, entries: entries.length };
   }
-};
-function parseFrontmatter2(raw) {
-  if (!raw.startsWith("---")) return {};
-  const end = raw.indexOf("\n---", 4);
-  if (end === -1) return {};
-  const block = raw.slice(4, end);
-  const out = {};
-  let key = null;
-  let value = [];
-  const flush = () => {
-    if (key) {
-      out[key] = value.join("\n").trim();
+  /** All entries for a session, in insertion order. */
+  async load(sessionId) {
+    return this.readAll(sessionId);
+  }
+  // ── Internals ────────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
     }
-    key = null;
-    value = [];
-  };
-  for (const line of block.split("\n")) {
-    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
-    if (m) {
-      flush();
-      key = m[1] ?? "";
-      const pipe = m[2];
-      const rest = m[3] ?? "";
-      if (pipe === "|") {
-        value = [];
-      } else if (rest) {
-        value = [rest];
-      } else {
-        value = [];
+    return path6.join(this.dir, `${sessionId}.audit.jsonl`);
+  }
+  async readAll(sessionId) {
+    const fp = this.filePath(sessionId);
+    try {
+      const raw = await fsp2.readFile(fp, "utf8");
+      const out = [];
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          out.push(JSON.parse(line));
+        } catch {
+        }
       }
-    } else if (key) {
-      value.push(line.replace(/^\s+/, ""));
+      return out;
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
     }
   }
-  flush();
-  return out;
+  async appendLine(sessionId, entry) {
+    const fp = this.filePath(sessionId);
+    const existing = await this.readAll(sessionId);
+    const all = [...existing, entry];
+    await atomicWrite(fp, all.map((e) => JSON.stringify(e)).join("\n") + (all.length ? "\n" : ""));
+  }
+  enqueue(sessionId, fn) {
+    const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.writeChains.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
+  }
+};
+function stableStringify2(value) {
+  return JSON.stringify(sortKeys2(value));
 }
-async function collectFiles(dir, baseDir) {
-  const results = [];
-  const entries = await fsp2.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path6.join(dir, entry.name);
-    const relPath = path6.relative(baseDir, fullPath);
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      results.push(...await collectFiles(fullPath, baseDir));
-    } else {
-      results.push(relPath);
+function sortKeys2(value) {
+  if (Array.isArray(value)) return value.map(sortKeys2);
+  if (value && typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = sortKeys2(obj[key]);
     }
+    return sorted;
   }
-  return results;
+  return value;
 }
 
 // src/storage/session-rewinder.ts
@@ -19421,7 +20605,7 @@ var DefaultPromptStore = class {
   }
   async list() {
     await ensureDir(this.dir);
-    let entries = [];
+    const entries = [];
     try {
       const files = await fsp2.readdir(this.dir);
       for (const file of files) {
@@ -19697,8 +20881,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat9 = await fsp2.stat(localPath);
-        if (stat9.isDirectory()) {
+        const stat8 = await fsp2.stat(localPath);
+        if (stat8.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file, "utf8");
@@ -19723,8 +20907,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat9 = await fsp2.stat(localPath);
-        if (stat9.isDirectory()) {
+        const stat8 = await fsp2.stat(localPath);
+        if (stat8.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file);
@@ -20325,7 +21509,7 @@ var SkillGenerator = class {
     };
     return [commonInjection, ...stackSpecific[stack] ?? []];
   }
-  getConfigPatterns(stack) {
+  getConfigPatterns(_stack) {
     const commonConfig = [
       {
         id: "insecure-tls",
@@ -20907,7 +22091,6 @@ var SecurityScannerOrchestrator = class {
   retryPolicy;
   errorHandler;
   detector = defaultTechStackDetector;
-  reportGenerator = defaultReportGenerator;
   gitignoreUpdater = defaultGitignoreUpdater;
   /**
    * Wraps provider.complete with retry logic using the injected RetryPolicy.
@@ -21091,7 +22274,7 @@ Return ONLY the JSON object, no markdown, no explanation.`;
   /**
    * Scan a batch of files using LLM.
    */
-  async scanFileBatchLLM(provider, model, files, skill, techStack) {
+  async scanFileBatchLLM(provider, model, files, skill, _techStack) {
     const fileContents = [];
     for (const file of files) {
       try {
@@ -21288,7 +22471,7 @@ Be specific about the vulnerabilities found and how to fix them.`;
   /**
    * Gather project info for skill generation.
    */
-  async gatherProjectInfo(projectRoot, techStack) {
+  async gatherProjectInfo(projectRoot, _techStack) {
     const info = [];
     const keyFiles = [
       "package.json",
@@ -21320,7 +22503,7 @@ ${dirs.join(", ")}`);
   /**
    * Gather files to scan based on patterns.
    */
-  async gatherFiles(root, patterns, depth) {
+  async gatherFiles(root, _patterns, depth) {
     const files = [];
     const maxDepth = depth === "quick" ? 2 : depth === "deep" ? 20 : 5;
     const extensions = [".ts", ".js", ".jsx", ".tsx", ".py", ".go", ".java", ".cs", ".rs"];
@@ -21579,22 +22762,22 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = Number.parseInt(reportId, 10) - 1;
     if (!Number.isNaN(index) && reports[index]) {
-      const { readFile: readFile35 } = await import('fs/promises');
-      const content = await readFile35(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile37 } = await import('fs/promises');
+      const content = await readFile37(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile35 } = await import('fs/promises');
-      const content = await readFile35(join(reportsDir, match), "utf-8");
+      const { readFile: readFile37 } = await import('fs/promises');
+      const content = await readFile37(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     return { message: `\u274C Report "${reportId}" not found. Use \`/security report\` to see available reports.` };
-  } catch (error) {
+  } catch (_error) {
     return { message: "\u{1F4ED} No security reports found. Run `/security scan` first." };
   }
 }
@@ -21647,7 +22830,6 @@ var FleetManager = class {
   /** Usage rollup across all subagents. */
   usage;
   manifestPath;
-  sessionsRoot;
   directorRunId;
   /** Spawn cap (lifetime total). Infinity means unlimited. */
   maxSpawns;
@@ -21675,9 +22857,14 @@ var FleetManager = class {
   _usedNicknames = /* @__PURE__ */ new Set();
   /** The coordinator (wired via setCoordinator by Director after construction). */
   coordinator = null;
+  /** Leader agent's current context pressure (full request tokens). */
+  leaderContextPressure = 0;
+  /** Maximum context load fraction before spawn is refused. */
+  maxLeaderContextLoad;
+  /** Provider's max context window in tokens. */
+  maxContext;
   constructor(opts = {}) {
     this.manifestPath = opts.manifestPath;
-    this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? randomUUID();
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
@@ -21685,6 +22872,8 @@ var FleetManager = class {
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
+    this.maxContext = opts.maxContext ?? 128e3;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(
       opts.stateCheckpointPath,
       {
@@ -21699,7 +22888,7 @@ var FleetManager = class {
     this.fleet = new FleetBus();
     this.usage = new FleetUsageAggregator(
       this.fleet,
-      (id, provider, model) => {
+      (_id, provider, model) => {
         if (provider && model) return this.priceLookups.get(`${provider}/${model}`);
         return void 0;
       },
@@ -21738,7 +22927,7 @@ var FleetManager = class {
    * which cap was exceeded. Does NOT throw — the caller decides
    * how to surface the rejection.
    */
-  canSpawn(config) {
+  canSpawn(_config) {
     if (this.spawnDepth >= this.maxSpawnDepth) {
       return { kind: "max_spawn_depth", limit: this.maxSpawnDepth, observed: this.spawnDepth };
     }
@@ -21751,8 +22940,21 @@ var FleetManager = class {
         return { kind: "max_cost_usd", limit: this.maxFleetCostUsd, observed: totalCost };
       }
     }
+    if (this.maxLeaderContextLoad < 1) {
+      const threshold = this.maxContext * this.maxLeaderContextLoad;
+      if (this.leaderContextPressure >= threshold) {
+        return {
+          kind: "max_context_load",
+          limit: threshold,
+          observed: this.leaderContextPressure
+        };
+      }
+    }
     return null;
   }
+  setLeaderContextPressure(tokens) {
+    this.leaderContextPressure = tokens;
+  }
   /**
    * Assign a memorable nickname (e.g. "Einstein (Bug Hunter)") to the config,
    * record it so the same name is never reused, then record the spawn.
@@ -21977,7 +23179,7 @@ function createMcpControlTool(opts) {
     mutating: true,
     riskTier: "standard",
     inputSchema,
-    async execute(raw, ctx) {
+    async execute(raw) {
       const input = raw;
       return mcpControlDispatch(input, { getConfig, configPath, registry });
     }
@@ -22525,7 +23727,6 @@ var Agent = class {
   pipelines;
   ctx;
   maxIterations;
-  iterationTimeoutMs;
   executionStrategy;
   perIterationOutputCapBytes;
   plugins = [];
@@ -22543,7 +23744,6 @@ var Agent = class {
     this.pipelines = init.pipelines;
     this.ctx = init.context;
     this.maxIterations = init.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-    this.iterationTimeoutMs = init.iterationTimeoutMs ?? 3e5;
     this.executionStrategy = init.executionStrategy ?? "smart";
     this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
     this.autoExtendLimit = init.autoExtendLimit ?? true;
@@ -22565,9 +23765,6 @@ var Agent = class {
   get permission() {
     return this.container.resolve(TOKENS.PermissionPolicy);
   }
-  get scrubber() {
-    return this.container.resolve(TOKENS.SecretScrubber);
-  }
   get renderer() {
     return this.container.has(TOKENS.Renderer) ? this.container.resolve(TOKENS.Renderer) : void 0;
   }
@@ -22697,6 +23894,11 @@ var Agent = class {
         if (controller.signal.aborted) {
           return { status: "aborted", iterations };
         }
+        await this.ctx.session.writeInFlightMarker(`iteration ${i} / max ${this.maxIterations}`).catch((err) => {
+          this.logger.debug?.(
+            `in-flight marker write failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
         if (autonomousContinue) {
           consumeAutonomousContinue(this.ctx);
         }
@@ -22778,6 +23980,7 @@ var Agent = class {
         finalText = responseResult.finalText;
         const toolUses = res.content.filter(isToolUseBlock);
         if (toolUses.length === 0) {
+          this.emitContextPct();
           this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
           if (autonomousContinue && responseResult.directive === "continue") {
             await this.compactContextIfNeeded();
@@ -22791,11 +23994,13 @@ var Agent = class {
         }
         await this.executeTools(toolUses);
         if (autonomousContinue && consumeAutonomousContinue(this.ctx)) {
+          this.emitContextPct();
           this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
           await this.compactContextIfNeeded();
           await this.extensions.runAfterIteration(this.ctx, i);
           continue;
         }
+        this.emitContextPct();
         this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
         await this.compactContextIfNeeded();
         await this.extensions.runAfterIteration(this.ctx, i);
@@ -22808,6 +24013,12 @@ var Agent = class {
       }
     } finally {
       offSubagentDone();
+      const reason = controller.signal.aborted ? "aborted" : "clean";
+      await this.ctx.session.clearInFlightMarker(reason).catch((err) => {
+        this.logger.debug?.(
+          `in-flight marker clear failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
     }
   }
   /**
@@ -23100,6 +24311,19 @@ var Agent = class {
   async compactContextIfNeeded() {
     await this.pipelines.contextWindow.run(this.ctx);
   }
+  /**
+   * Emit the current context window load as a `ctx.pct` event so subscribers
+   * (FleetBus → TUI) can render a live fill bar per agent.
+   */
+  emitContextPct() {
+    const maxContext = this.ctx.provider.capabilities.maxContext ?? 2e5;
+    const { total } = estimateRequestTokens(
+      this.ctx.messages,
+      this.ctx.systemPrompt,
+      this.ctx.tools ?? []
+    );
+    this.events.emit("ctx.pct", { load: total / maxContext, tokens: total, maxContext });
+  }
 };
 function toError(err) {
   return err instanceof Error ? err : new Error(String(err));
@@ -23776,8 +25000,8 @@ ${mem}`);
   }
   async dirExists(p) {
     try {
-      const stat9 = await fsp2.stat(p);
-      return stat9.isDirectory();
+      const stat8 = await fsp2.stat(p);
+      return stat8.isDirectory();
     } catch {
       return false;
     }
@@ -26113,6 +27337,203 @@ function assertSafePath(dir, projectRoot) {
   }
 }
 
+// src/coordination/collab-bus.ts
+var CollaborationBus = class {
+  pausePromise = null;
+  pauseResolve = null;
+  pausedAtMs = null;
+  pausedBy = null;
+  // ── State queries ──────────────────────────────────────────────────────
+  isPaused() {
+    return this.pausePromise !== null;
+  }
+  getState() {
+    return {
+      paused: this.isPaused(),
+      pausedAt: this.pausedAtMs ? new Date(this.pausedAtMs).toISOString() : null,
+      pausedBy: this.pausedBy
+    };
+  }
+  // ── Pause / resume control ─────────────────────────────────────────────
+  /**
+   * Pause the agent loop. Idempotent: a second `requestPause` while
+   * already paused is a no-op (the original pause wins; we do not
+   * overwrite `pausedBy`). Returns true when the state actually
+   * transitioned, false when it was already paused.
+   */
+  requestPause(byParticipant) {
+    if (this.isPaused()) return false;
+    this.pausedAtMs = Date.now();
+    this.pausedBy = byParticipant;
+    this.pausePromise = new Promise((resolve9) => {
+      this.pauseResolve = resolve9;
+    });
+    return true;
+  }
+  /**
+   * Resume the agent loop. Returns true when the state actually
+   * transitioned from paused → running, false when it was already
+   * running (no-op).
+   */
+  resume() {
+    if (!this.isPaused()) return false;
+    if (this.pauseResolve) this.pauseResolve();
+    this.pausePromise = null;
+    this.pauseResolve = null;
+    this.pausedAtMs = null;
+    this.pausedBy = null;
+    return true;
+  }
+  // ── Wait semantics (consumed by the middleware) ────────────────────────
+  /**
+   * Block until the bus is resumed or the timeout fires. Returns:
+   *   - `true`  → bus was resumed in time
+   *   - `false` → timeout fired; bus was auto-resumed as a side effect
+   *
+   * When `timeoutMs` is `0` the wait is unbounded (the middleware must
+   * be paired with an external AbortSignal in that case — we don't
+   * expose one here to keep the API simple).
+   */
+  async waitForResume(timeoutMs) {
+    if (!this.isPaused()) return true;
+    if (!this.pausePromise) return true;
+    if (timeoutMs === 0) {
+      await this.pausePromise;
+      return true;
+    }
+    let timer;
+    const timeoutPromise = new Promise((resolve9) => {
+      timer = setTimeout(() => resolve9("timeout"), timeoutMs);
+    });
+    const resumedPromise = this.pausePromise.then(() => "resumed");
+    const winner = await Promise.race([resumedPromise, timeoutPromise]);
+    if (timer) clearTimeout(timer);
+    if (winner === "timeout") {
+      this.resume();
+      return false;
+    }
+    return true;
+  }
+  // ── Manual tool-call injection (Phase 4) ─────────────────────────────────
+  //
+  // A controller can ask the agent loop to use a specific tool_result
+  // for a given tool_use_id — bypassing the real tool execution. This
+  // is "I want the agent to think the read returned THIS content" or
+  // "skip the bash call, just give it the answer I typed". The
+  // injection is matched by tool_use_id, consumed once, and discarded.
+  injectionQueue = /* @__PURE__ */ new Map();
+  /**
+   * Queue a manual tool result. The next time the agent's toolCall
+   * pipeline sees a matching `toolUse.id`, the
+   * `collabInjectMiddleware` consumes this entry and replaces the
+   * real tool execution. Returns `false` if an injection for the
+   * same id is already queued (idempotent — first write wins).
+   */
+  injectToolResult(input) {
+    if (this.injectionQueue.has(input.toolUseId)) return false;
+    this.injectionQueue.set(input.toolUseId, input);
+    return true;
+  }
+  /**
+   * Pop an injection from the queue. Returns the payload (and
+   * removes it) if one is pending, or `null` when nothing matches.
+   * Called by the middleware on every tool call.
+   */
+  takeInjection(toolUseId) {
+    const v = this.injectionQueue.get(toolUseId);
+    if (!v) return null;
+    this.injectionQueue.delete(toolUseId);
+    return v;
+  }
+  /** Inspect the queue size (for observability / tests). */
+  pendingInjectionCount() {
+    return this.injectionQueue.size;
+  }
+};
+
+// src/middleware/collab-pause.ts
+function collabPauseMiddleware(bus, opts = {}) {
+  const timeoutMs = opts.defaultTimeoutMs ?? 6e4;
+  const logger = opts.logger;
+  return async function collabPause(payload, next) {
+    if (!bus.isPaused()) {
+      return next();
+    }
+    const state = bus.getState();
+    logger?.debug?.(
+      `collab-pause: tool '${payload.toolUse.name}' blocked \u2014 bus paused by ${state.pausedBy ?? "?"} at ${state.pausedAt ?? "?"}, waiting up to ${timeoutMs}ms for resume`
+    );
+    const resumed = await bus.waitForResume(timeoutMs);
+    if (!resumed) {
+      logger?.warn?.(
+        `collab-pause: timeout after ${timeoutMs}ms \u2014 auto-resuming the bus to unblock the agent loop`
+      );
+    } else {
+      logger?.debug?.(`collab-pause: resumed \u2014 proceeding with tool '${payload.toolUse.name}'`);
+    }
+    return next();
+  };
+}
+function collabInjectMiddleware(bus, opts = {}) {
+  const logger = opts.logger;
+  return async function collabInject(payload, next) {
+    const injected = bus.takeInjection(payload.toolUse.id);
+    if (!injected) {
+      return next();
+    }
+    logger?.debug?.(
+      `collab-inject: tool '${payload.toolUse.name}' (id ${payload.toolUse.id}) \u2014 using controller-injected result (reason: ${injected.reason})`
+    );
+    payload.result = {
+      type: "tool_result",
+      tool_use_id: payload.toolUse.id,
+      content: typeof injected.content === "string" ? injected.content : JSON.stringify(injected.content),
+      is_error: injected.isError
+    };
+  };
+}
+
+// src/replay/replay-provider-runner.ts
+var ReplayProviderRunner = class {
+  constructor(inner, opts) {
+    this.inner = inner;
+    this.opts = opts;
+  }
+  inner;
+  opts;
+  async run(runOpts) {
+    const hash = hashRequest(runOpts.request);
+    const cached = await this.opts.log.lookup(this.opts.sessionId, hash);
+    if (this.opts.mode === "replay") {
+      if (!cached) {
+        this.opts.logger?.warn?.(
+          `replay: no recorded response for hash ${hash} (model ${runOpts.request.model})`
+        );
+        throw new Error(
+          `ReplayProviderRunner: no recorded response for hash ${hash} in session ${this.opts.sessionId}. Either the request changed since recording, or this session has no replay log.`
+        );
+      }
+      this.opts.logger?.debug?.(
+        `replay: served cached response for hash ${hash} (recorded ${cached.ts})`
+      );
+      return cached.response;
+    }
+    if (this.opts.mode === "auto" && cached) {
+      this.opts.logger?.debug?.(
+        `replay: auto-hit hash ${hash}, served cached response`
+      );
+      return cached.response;
+    }
+    const response = await this.inner.run(runOpts);
+    await this.opts.log.record({
+      sessionId: this.opts.sessionId,
+      request: runOpts.request,
+      response
+    });
+    return response;
+  }
+};
+
 // src/plugins/prompts-plugin.ts
 function createPromptsPlugin(opts) {
   let store = null;
@@ -27170,6 +28591,6 @@ ${formatPlan(updated)}`
   };
 }
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CheckpointManager, CloudSync, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSkillsPlugin, createSyncPlugin, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CheckpointManager, CloudSync, CollaborationBus, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionRecovery, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSkillsPlugin, createSyncPlugin, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, hashRequest, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map