@wrongstack/core 0.9.19 → 0.10.0

package/dist/defaults/index.js

@@ -640,7 +640,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();
@@ -731,7 +730,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(),
@@ -827,6 +825,38 @@ var FileSessionWriter = class {
 `;
     await fsp.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(" ");
@@ -889,7 +919,7 @@ function isPersistedQueueItem(v) {
 // src/storage/attachment-store.ts
 init_atomic_write();
 var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
-var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)\]/g;
+var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)[^\]]*\]|\[file:([^\]]+)\]/g;
 var DefaultAttachmentStore = class {
   items = /* @__PURE__ */ new Map();
   refs = [];
@@ -943,9 +973,15 @@ var DefaultAttachmentStore = class {
       const idx = m.index ?? 0;
       const before = text.slice(lastIndex, idx);
       if (before) blocks.push({ type: "text", text: before });
-      const kind = prefixToKind(m[1]);
-      const seq = Number(m[2]);
-      const ref = this.refs.find((r) => r.kind === kind && r.seq === seq);
+      let ref;
+      if (m[3] !== void 0) {
+        const wantPath = m[3];
+        ref = findLast(this.refs, (r) => r.kind === "file" && refPath(r) === wantPath);
+      } else {
+        const kind = prefixToKind(m[1]);
+        const seq = Number(m[2]);
+        ref = this.refs.find((r) => r.kind === kind && r.seq === seq);
+      }
       const att = ref ? this.items.get(ref.id) : void 0;
       if (!att) {
         blocks.push({ type: "text", text: m[0] });
@@ -998,6 +1034,15 @@ function prefixToKind(prefix) {
   if (prefix === "image") return "image";
   return "file";
 }
+function refPath(ref) {
+  return ref.meta.filename ?? ref.meta.label;
+}
+function findLast(arr, pred) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (pred(arr[i])) return arr[i];
+  }
+  return void 0;
+}
 function mergeAdjacentText(blocks) {
   const out = [];
   for (const b of blocks) {
@@ -1382,6 +1427,14 @@ var DEFAULT_CONTEXT_CONFIG = Object.freeze({
 var DEFAULT_AUTONOMY_CONFIG = Object.freeze({
   autoProceedDelayMs: 45e3
 });
+var DEFAULT_SESSION_LOGGING_CONFIG = Object.freeze({
+  auditLevel: "standard",
+  sampling: {
+    toolProgress: {
+      sampleRate: 8
+    }
+  }
+});
 
 // src/storage/config-loader.ts
 var BEHAVIOR_DEFAULTS = {
@@ -1410,7 +1463,8 @@ var BEHAVIOR_DEFAULTS = {
     memory: true,
     modelsRegistry: true,
     skills: true
-  }
+  },
+  session: { ...DEFAULT_SESSION_LOGGING_CONFIG }
 };
 var ENV_MAP = {
   WRONGSTACK_PROVIDER: (c, v) => {
@@ -2214,6 +2268,101 @@ var SessionAnalyzer = class {
   }
 };
 
+// src/storage/session-event-bridge.ts
+var CORE_RECONSTRUCT_EVENTS = /* @__PURE__ */ new Set([
+  "session_start",
+  "session_resumed",
+  "user_input",
+  "llm_response",
+  "tool_result",
+  "checkpoint",
+  "file_snapshot",
+  "rewound",
+  "in_flight_start",
+  "in_flight_end",
+  "session_end"
+]);
+var STANDARD_AUDIT_EVENTS = /* @__PURE__ */ new Set([
+  "llm_request",
+  "tool_use",
+  "tool_call_start",
+  "tool_call_end",
+  "compaction",
+  "error",
+  "message_truncated",
+  "provider_retry",
+  "provider_error"
+]);
+var FULL_ONLY_EVENTS = /* @__PURE__ */ new Set([
+  "tool_progress"
+]);
+function isAllowed(type, level) {
+  if (CORE_RECONSTRUCT_EVENTS.has(type)) return true;
+  if (level === "minimal") return false;
+  if (STANDARD_AUDIT_EVENTS.has(type)) return true;
+  if (level === "standard") return false;
+  if (FULL_ONLY_EVENTS.has(type)) {
+    return level === "full";
+  }
+  return true;
+}
+function createSessionEventBridge(writer, level = "standard", options = {}) {
+  const normalizedLevel = level ?? "standard";
+  const progressCounters = /* @__PURE__ */ new Map();
+  const toolProgressConfig = options.sampling?.toolProgress ?? {};
+  const TOOL_PROGRESS_SAMPLE_RATE = toolProgressConfig.sampleRate ?? 8;
+  function shouldSample(event) {
+    if (event.type !== "tool_progress") return true;
+    const progEvent = event;
+    const innerType = progEvent.event?.type;
+    if (innerType === "warning" || innerType === "metric" || innerType === "file_changed") {
+      return true;
+    }
+    if (innerType === "log" || innerType === "partial_output") {
+      const key = progEvent.id || progEvent.name;
+      const count = (progressCounters.get(key) || 0) + 1;
+      progressCounters.set(key, count);
+      return count === 1 || count % TOOL_PROGRESS_SAMPLE_RATE === 0;
+    }
+    return true;
+  }
+  return {
+    level: normalizedLevel,
+    allows(type) {
+      return isAllowed(type, normalizedLevel);
+    },
+    async append(event) {
+      if (!writer) return;
+      if (!isAllowed(event.type, normalizedLevel)) return;
+      if (!shouldSample(event)) return;
+      try {
+        await writer.append(event);
+      } catch (err) {
+      }
+    }
+  };
+}
+function resolveAuditLevel(cfg) {
+  const raw = cfg?.session?.auditLevel;
+  if (raw === "minimal" || raw === "standard" || raw === "full") {
+    return raw;
+  }
+  return "standard";
+}
+function resolveSessionLoggingConfig(cfg) {
+  const session = cfg?.session ?? {};
+  const auditLevel = resolveAuditLevel(cfg);
+  const toolProgressSampleRate = session.sampling?.toolProgress?.sampleRate ?? 8;
+  return {
+    auditLevel,
+    sampling: {
+      toolProgress: {
+        sampleRate: Math.max(1, Math.floor(toolProgressSampleRate))
+      }
+    }
+  };
+}
+
 // src/storage/todos-checkpoint.ts
 init_atomic_write();
 async function loadTodosCheckpoint(filePath) {
@@ -3022,6 +3171,47 @@ function deepMerge2(a, b) {
   return out;
 }
 
+// src/security/capabilities.ts
+var ToolCapabilities = {
+  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
+  SHELL_ARBITRARY: "shell.arbitrary",
+  /** Can write / modify / delete files inside the project. */
+  FS_WRITE: "fs.write",
+  /** Can write files outside the current project root (very high risk). */
+  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Proxies tools from external MCP servers (unknown capability). */
+  MCP_PROXY: "mcp.proxy",
+  /** Can spawn or manage subagents / multi-agent tasks. */
+  SUBAGENT_SPAWN: "subagent.spawn",
+  /** Can mutate global or session configuration / trust state. */
+  CONFIG_MUTATE: "config.mutate",
+  /** Can install packages or run package managers with side effects. */
+  PACKAGE_INSTALL: "package.install"
+};
+var DANGEROUS_FOR_SUBAGENTS = [
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
+  ToolCapabilities.MCP_PROXY,
+  ToolCapabilities.SUBAGENT_SPAWN,
+  ToolCapabilities.CONFIG_MUTATE,
+  ToolCapabilities.PACKAGE_INSTALL
+];
+function hasDangerousCapabilityForSubagents(toolOrCaps) {
+  if (!toolOrCaps) return false;
+  const input = toolOrCaps;
+  const caps = Array.isArray(input) ? input : input?.capabilities ?? [];
+  return caps.some((c) => DANGEROUS_FOR_SUBAGENTS.includes(c));
+}
+function getDangerousCapabilities(toolOrCaps) {
+  if (!toolOrCaps) return [];
+  const input = toolOrCaps;
+  const caps = Array.isArray(input) ? input : input?.capabilities ?? [];
+  return caps.filter(
+    (c) => DANGEROUS_FOR_SUBAGENTS.includes(c)
+  );
+}
+
 // src/security/permission-policy.ts
 init_atomic_write();
 
@@ -3341,31 +3531,21 @@ var DefaultPermissionPolicy = class {
 };
 var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
   /**
-   * Tools that are too dangerous to auto-approve even in a delegated
-   * subagent context. Subagents run non-interactively under a director
-   * and cannot answer prompts, but inherited authorization does not
-   * imply blanket permission for destructive or privilege-escalating
-   * operations. These tools remain at their declared `permission`
-   * level so the leader must explicitly allow them per-spawn.
+   * Legacy name-based denylist.
+   * @deprecated Prefer declaring `capabilities` on the Tool and using capability-based checks.
    */
-  static DENY = /* @__PURE__ */ new Set([
+  static LEGACY_NAME_DENY = /* @__PURE__ */ new Set([
     "bash",
-    // arbitrary shell — use exec for constrained shell
     "write",
-    // arbitrary file write
     "edit",
-    // arbitrary in-project file modification (equivalent to write)
     "replace",
-    // arbitrary multi-file find/replace (equivalent to write)
     "scaffold",
-    // arbitrary file generation outside project root
     "patch",
-    // arbitrary diff application
     "install",
-    // installs from arbitrary package sources
     "exec"
-    // restricted shell but with arbitrary command args
   ]);
+  // Note: hasDangerousCapabilityForSubagents is now the shared helper from capabilities.ts
+  // The old private method was removed in favor of the centralized utility.
   /**
    * Tools from MCP servers (`mcp__<server>__<tool>`) are external code of
    * unknown capability — they may wrap a shell or filesystem. They are
@@ -3376,12 +3556,16 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
     return name.startsWith("mcp__");
   }
   async evaluate(tool) {
-    const blocked = _AutoApprovePermissionPolicy.DENY.has(tool.name) || _AutoApprovePermissionPolicy.isMcpTool(tool.name);
-    if (tool.permission === "deny" || blocked) {
+    const hasDangerousCap = hasDangerousCapabilityForSubagents(tool);
+    const legacyNameBlock = _AutoApprovePermissionPolicy.LEGACY_NAME_DENY.has(tool.name);
+    const isMcp = _AutoApprovePermissionPolicy.isMcpTool(tool.name);
+    const blocked = tool.permission === "deny" || hasDangerousCap || legacyNameBlock || isMcp;
+    if (blocked) {
+      const reason = hasDangerousCap ? `tool declares dangerous capability (${tool.capabilities?.join(", ")}) \u2014 not auto-approved for subagents` : legacyNameBlock || isMcp ? `tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny";
       return {
         permission: "deny",
         source: "subagent_guard",
-        reason: blocked ? `tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny"
+        reason
       };
     }
     return { permission: "auto", source: "yolo" };
@@ -3798,80 +3982,85 @@ function parseDescription(raw) {
 
 // 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) };
@@ -4281,6 +4470,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;
@@ -4296,9 +4486,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,
@@ -4307,6 +4500,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;
@@ -4452,8 +4653,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 });
@@ -4467,9 +4669,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,
@@ -4478,6 +4683,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);
@@ -4490,29 +4703,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",
@@ -4758,7 +4968,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);
@@ -4850,15 +5060,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 });
@@ -4870,7 +5089,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);
@@ -5060,7 +5295,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;
@@ -5070,19 +5306,7 @@ 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;
+  sessionBridge;
   /**
    * Once a compaction attempt reduces nothing (preserveK protects everything,
    * no oversized tool_results remain to elide), retrying on every iteration
@@ -5095,8 +5319,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
@@ -5104,11 +5331,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;
@@ -5116,6 +5343,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     this.events = opts.events;
     this.failureMode = opts.failureMode ?? "throw_on_hard";
     this.policyProvider = opts.policyProvider;
+    this.sessionBridge = opts.sessionBridge;
   }
   /** Allow callers (e.g. model-switch in WebUI) to update the context window
    *  denominator when the active model changes. */
@@ -5124,8 +5352,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 ?? {
@@ -5160,7 +5387,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;
@@ -5180,6 +5407,15 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         report,
         aggressive
       });
+      await this.sessionBridge?.append({
+        type: "compaction",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        before: report.before,
+        after: report.after,
+        level: pressure.level,
+        aggressive,
+        reductions: report.reductions?.map((r) => ({ phase: r.phase, saved: r.saved }))
+      });
       ctx.clearFileTracking();
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
@@ -5210,6 +5446,100 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   }
 };
 
+// src/utils/json-schema-validate.ts
+function validateAgainstSchema(value, schema) {
+  const errors = [];
+  walk3(value, schema, "", errors);
+  return { ok: errors.length === 0, errors };
+}
+function walk3(value, schema, path18, errors) {
+  if (schema.enum !== void 0) {
+    if (!schema.enum.some((e) => deepEqual(e, value))) {
+      errors.push({
+        path: path18 || "<root>",
+        message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
+      });
+      return;
+    }
+  }
+  if (typeof schema.type === "string") {
+    if (!checkType(value, schema.type)) {
+      errors.push({
+        path: path18 || "<root>",
+        message: `expected ${schema.type}, got ${describeType(value)}`
+      });
+      return;
+    }
+  }
+  if (schema.type === "object" && isPlainObject(value)) {
+    const obj = value;
+    for (const req of schema.required ?? []) {
+      if (!(req in obj)) {
+        errors.push({ path: joinPath(path18, req), message: "required property missing" });
+      }
+    }
+    if (schema.properties) {
+      for (const [key, subSchema] of Object.entries(schema.properties)) {
+        if (key in obj) {
+          walk3(obj[key], subSchema, joinPath(path18, key), errors);
+        }
+      }
+    }
+  }
+  if (schema.type === "array" && Array.isArray(value) && schema.items) {
+    value.forEach((item, i) => walk3(item, schema.items, `${path18}[${i}]`, errors));
+  }
+}
+function checkType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainObject(value);
+    default:
+      return true;
+  }
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function describeType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function joinPath(parent, key) {
+  if (!parent) return key;
+  return `${parent}.${key}`;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length) return false;
+    return ak.every(
+      (k) => deepEqual(a[k], b[k])
+    );
+  }
+  return false;
+}
+
 // src/utils/tool-output-serializer.ts
 function createToolOutputSerializer(opts = {}) {
   const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
@@ -5291,18 +5621,45 @@ var ToolExecutor = class {
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
+      const validation = validateAgainstSchema(use.input, tool.inputSchema);
+      if (!validation.ok) {
+        const errorDetails = validation.errors.map((e) => `  - ${e.path || "input"}: ${e.message}`).join("\n");
+        const result = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Invalid arguments for tool "${tool.name}".
+
+Validation errors:
+${errorDetails}
+
+Please call the tool again with arguments that match its inputSchema. You can use the "tool-help" tool with name="${tool.name}" to see the exact expected schema.`,
+          is_error: true
+        };
+        budget = this.decrementBudget(result, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
+      const toolDangerousCaps = getDangerousCapabilities(tool);
+      if (toolDangerousCaps.length > 0) {
+        if (this.opts.events) ;
+      }
       if (hasMalformedArguments(use.input)) {
         const result = this.malformedInputResult(use, extractMalformedRaw(use.input));
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
-      if (decision.permission === "deny") {
+      let effectivePermission = decision.permission;
+      const policy = this.opts.permissionPolicy;
+      const yolo = policy.getYolo?.() === true || policy.getForceAllYolo?.() === true;
+      if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo) {
+        effectivePermission = "confirm";
+      }
+      if (effectivePermission === "deny") {
         const result = this.deniedResult(use, decision.reason);
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
-      if (decision.permission === "confirm") {
+      if (effectivePermission === "confirm") {
         if (this.opts.confirmAwaiter) {
           const choice = await this.opts.confirmAwaiter(tool, use.input, use.id, tool.name);
           if (choice !== "yes" && choice !== "always") {
@@ -5327,10 +5684,13 @@ var ToolExecutor = class {
           return { result: pending, tool, durationMs: Date.now() - start };
         }
       }
+      const toolCapsForAudit = hasDangerousCapabilityForSubagents(tool) ? tool.capabilities ?? [] : [];
       const span = this.opts.tracer?.startSpan(`tool.${tool.name}`, {
         "tool.name": tool.name,
         "tool.mutating": tool.mutating,
-        "tool.permission": tool.permission
+        "tool.permission": tool.permission,
+        "tool.capabilities": JSON.stringify(tool.capabilities ?? []),
+        "tool.has_dangerous_capabilities": toolCapsForAudit.length > 0
       });
       try {
         const result = await this.executeTool(tool, use, ctx, budget);
@@ -6403,19 +6763,16 @@ var SubagentBudget = class _SubagentBudget {
   tokenOutput = 0;
   costUsd = 0;
   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`.
+   * Timestamp of the most recent activity (iteration / tool call / token
+   * usage / streamed progress). Drives the idle timeout — reset by
+   * `markActivity()`. Initialised to `start()` time so a never-active agent
+   * still eventually trips its idle window.
    */
-  pendingExtensions = /* @__PURE__ */ new Set();
+  lastActivityTime = null;
+  _onThreshold;
   /**
-   * 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.
@@ -6456,6 +6813,24 @@ var SubagentBudget = class _SubagentBudget {
   }
   start() {
     this.startTime = Date.now();
+    this.lastActivityTime = this.startTime;
+  }
+  /**
+   * Reset the idle clock. Called on any sign of forward progress —
+   * iterations, tool calls, token usage, and streamed tool/text progress —
+   * so a long-but-productive subagent never trips its `idleTimeoutMs`.
+   */
+  markActivity() {
+    this.lastActivityTime = Date.now();
+  }
+  /**
+   * Milliseconds since the last activity signal. Returns 0 before `start()`
+   * (nothing to measure yet). Used by the coordinator watchdog to decide
+   * whether to re-arm (still active) or reap (genuinely idle).
+   */
+  idleMs() {
+    const since = this.lastActivityTime ?? this.startTime;
+    return since === null ? 0 : Date.now() - since;
   }
   /** Returns true if we're within 10% of any limit — useful for pre-flight checks. */
   isNearLimit() {
@@ -6477,38 +6852,88 @@ 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) {
+      const idle = this.idleMs();
+      if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
+        exceeded.push({ kind: "timeout", used: idle, limit: this.limits.idleTimeoutMs });
+      } else if (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);
     }
-    if (this.pendingExtensions.has(kind)) return;
-    this.pendingExtensions.add(kind);
-    const decision = this.negotiateExtension(kind, used, limit);
-    throw new BudgetThresholdSignal(kind, limit, used, decision);
+    for (const entry of exceeded) {
+      if (this._pendingNegotiations.has(entry.kind)) continue;
+      const decision2 = this._negotiateExtension(entry.kind, exceeded);
+      this._pendingNegotiations.set(entry.kind, decision2);
+    }
+    const 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")) {
@@ -6525,20 +6950,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");
+                }
+              });
+            }
           });
         }
       });
@@ -6562,54 +6989,59 @@ var SubagentBudget = class _SubagentBudget {
       if (ext.timeoutMs !== void 0) {
         this.limits.timeoutMs = ext.timeoutMs;
       }
+      if (ext.idleTimeoutMs !== void 0) {
+        this.limits.idleTimeoutMs = ext.idleTimeoutMs;
+      }
       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);
-    }
+    this.markActivity();
+    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);
-    }
+    this.markActivity();
+    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);
-    }
+    this.markActivity();
+    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;
+    if (this.startTime === null) return;
+    const { timeoutMs, idleTimeoutMs } = this.limits;
+    if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
-    if (elapsed > this.limits.timeoutMs) {
-      void this.checkLimit("timeout", elapsed, this.limits.timeoutMs);
-    }
+    const wallTripped = timeoutMs !== void 0 && elapsed > timeoutMs;
+    const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
+    if (!wallTripped && !idleTripped) return;
+    void this.checkLimits(elapsed);
   }
-  /** Returns true if a timeout has occurred without throwing. Useful for races. */
+  /** Returns true if a wall-clock or idle timeout has occurred without throwing. */
   isTimedOut() {
-    if (this.startTime === null || this.limits.timeoutMs === void 0) return false;
-    return Date.now() - this.startTime > this.limits.timeoutMs;
+    if (this.startTime === null) return false;
+    const { timeoutMs, idleTimeoutMs } = this.limits;
+    if (timeoutMs !== void 0 && Date.now() - this.startTime > timeoutMs) return true;
+    if (idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs) return true;
+    return false;
   }
   usage() {
     return {
@@ -6716,6 +7148,7 @@ function makeAgentSubagentRunner(opts) {
       // Cheap: O(1) per progress event, and the budget short-circuits
       // when timeoutMs is unset (most subagents have one set anyway).
       events.on("tool.progress", () => {
+        ctx.budget.markActivity();
         try {
           ctx.budget.checkTimeout();
         } catch (e) {
@@ -6732,6 +7165,7 @@ function makeAgentSubagentRunner(opts) {
         currentToolName = e.name;
       }),
       events.on("provider.text_delta", (e) => {
+        ctx.budget.markActivity();
         streamingTextAcc = (streamingTextAcc + e.text).slice(-200);
       })
     );
@@ -9301,6 +9735,7 @@ var FLEET_ROSTER = {
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
 };
+var DEFAULT_IDLE_TIMEOUT_MS = 15 * 60 * 1e3;
 var FLEET_ROSTER_BUDGETS = {
   "audit-log": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 5e3, maxToolCalls: 15e3 },
   "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
@@ -9312,7 +9747,7 @@ var FLEET_ROSTER_BUDGETS = {
   )
 };
 var GENERIC_SUBAGENT_BUDGET = {
-  timeoutMs: 3 * 60 * 60 * 1e3,
+  idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
   maxIterations: 5e3,
   maxToolCalls: 15e3
 };
@@ -9322,7 +9757,13 @@ function applyRosterBudget(cfg) {
   if (!defaultBudget) return cfg;
   return {
     ...cfg,
-    timeoutMs: cfg.timeoutMs ?? defaultBudget.timeoutMs,
+    // Wall-clock cap is opt-in only: forward an explicit `cfg.timeoutMs`, but
+    // do NOT impose the roster's historical multi-hour wall-clock default — it
+    // killed agents that were still actively working. Reaping is idle-based.
+    timeoutMs: cfg.timeoutMs,
+    // Idle window is the default reaper. Resets on activity, so a long-but-
+    // productive run is never killed; only a genuine stall is reaped.
+    idleTimeoutMs: cfg.idleTimeoutMs ?? defaultBudget.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS,
     maxIterations: cfg.maxIterations ?? defaultBudget.maxIterations,
     maxToolCalls: cfg.maxToolCalls ?? defaultBudget.maxToolCalls,
     maxTokens: cfg.maxTokens ?? defaultBudget.maxTokens,
@@ -9392,74 +9833,203 @@ FLEET_ROSTER_BUDGETS["goose"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations:
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
 });
 
-// src/coordination/multi-agent-coordinator.ts
-var DefaultMultiAgentCoordinator = class extends EventEmitter {
-  coordinatorId;
-  config;
-  runner;
-  fleetBus;
-  subagents = /* @__PURE__ */ new Map();
-  pendingTasks = [];
-  completedResults = [];
-  totalIterations = 0;
-  inFlight = 0;
-  /**
-   * Subagents currently being stopped. Set on entry to `stop()`, cleared
-   * once `recordCompletion` lands the terminal TaskResult. Used by
-   * `runDispatched` and `findIdleSubagent` to refuse mid-flight dispatch
-   * to a subagent the caller has already asked to terminate — closes the
-   * assign+terminate race where a fresh task could land on a worker that
-   * was about to be killed.
-   */
-  terminating = /* @__PURE__ */ new Set();
-  constructor(config, options = {}) {
-    super();
-    this.coordinatorId = config.coordinatorId;
-    this.config = config;
-    this.runner = options.runner;
-  }
-  /**
-   * Replace the runner after construction. Used when the runner depends
-   * on infrastructure (e.g. FleetBus) that isn't available until after
-   * the coordinator's owning Director is built.
-   */
-  setRunner(runner) {
-    this.runner = runner;
-  }
-  /**
-   * Wire a FleetBus for director-mode event emission. Call after the
-   * FleetManager is constructed so the coordinator can emit lifecycle
-   * events the TUI and monitoring tools subscribe to.
-   */
-  setFleetBus(fleet) {
-    this.fleetBus = fleet;
-  }
-  /**
-   * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
-   * preempt running tasks — already-dispatched subagents finish their
-   * current task; only future dispatches respect the new cap. Raising
-   * immediately tries to fill the freed slots from the pending queue.
-   */
-  setMaxConcurrent(n) {
-    if (!Number.isFinite(n) || n < 1) {
-      throw new Error(`maxConcurrent must be a finite integer >= 1, got ${n}`);
-    }
-    this.config.maxConcurrent = Math.floor(n);
-    this.tryDispatchNext();
-  }
-  async spawn(subagent) {
-    const id = subagent.id || randomUUID();
-    if (this.subagents.has(id)) {
-      throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
-    }
-    const context = {
-      subagentId: id,
-      tasks: [],
-      // Wired later by the caller via setSubagentBridge() once the
-      // bidirectional bridge is created. Readers must null-check / use
-      // hasParentBridge() — the type now reflects this.
-      parentBridge: null,
-      doneCondition: this.config.doneCondition,
+// 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;
+  config;
+  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;
+  inFlight = 0;
+  /**
+   * Subagents currently being stopped. Set on entry to `stop()`, cleared
+   * once `recordCompletion` lands the terminal TaskResult. Used by
+   * `runDispatched` and `findIdleSubagent` to refuse mid-flight dispatch
+   * to a subagent the caller has already asked to terminate — closes the
+   * assign+terminate race where a fresh task could land on a worker that
+   * was about to be killed.
+   */
+  terminating = /* @__PURE__ */ new Set();
+  constructor(config, options = {}) {
+    super();
+    this.coordinatorId = config.coordinatorId;
+    this.config = config;
+    this.runner = options.runner;
+  }
+  /**
+   * Replace the runner after construction. Used when the runner depends
+   * on infrastructure (e.g. FleetBus) that isn't available until after
+   * the coordinator's owning Director is built.
+   */
+  setRunner(runner) {
+    this.runner = runner;
+  }
+  /**
+   * Wire a FleetBus for director-mode event emission. Call after the
+   * FleetManager is constructed so the coordinator can emit lifecycle
+   * events the TUI and monitoring tools subscribe to.
+   */
+  setFleetBus(fleet) {
+    this.fleetBus = fleet;
+  }
+  /**
+   * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
+   * preempt running tasks — already-dispatched subagents finish their
+   * current task; only future dispatches respect the new cap. Raising
+   * immediately tries to fill the freed slots from the pending queue.
+   */
+  setMaxConcurrent(n) {
+    if (!Number.isFinite(n) || n < 1) {
+      throw new Error(`maxConcurrent must be a finite integer >= 1, got ${n}`);
+    }
+    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`);
+    }
+    const context = {
+      subagentId: id,
+      tasks: [],
+      // Wired later by the caller via setSubagentBridge() once the
+      // bidirectional bridge is created. Readers must null-check / use
+      // hasParentBridge() — the type now reflects this.
+      parentBridge: null,
+      doneCondition: this.config.doneCondition,
       maxConcurrent: this.config.maxConcurrent ?? 16
     };
     this.subagents.set(id, {
@@ -9755,13 +10325,17 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     const rawMaxTokens = subagent.config.maxTokens;
     const rawMaxCostUsd = subagent.config.maxCostUsd;
     const rawTimeoutMs = subagent.config.timeoutMs;
+    const rawIdleTimeoutMs = subagent.config.idleTimeoutMs;
     const configWithRosterDefaults = applyRosterBudget(subagent.config);
     const budget = new SubagentBudget({
       maxIterations: rawMaxIterations ?? this.config.defaultBudget?.maxIterations ?? configWithRosterDefaults.maxIterations,
       maxToolCalls: rawMaxToolCalls ?? this.config.defaultBudget?.maxToolCalls ?? configWithRosterDefaults.maxToolCalls,
       maxTokens: rawMaxTokens ?? this.config.defaultBudget?.maxTokens ?? configWithRosterDefaults.maxTokens,
       maxCostUsd: rawMaxCostUsd ?? this.config.defaultBudget?.maxCostUsd ?? configWithRosterDefaults.maxCostUsd,
-      timeoutMs: rawTimeoutMs ?? this.config.defaultBudget?.timeoutMs ?? configWithRosterDefaults.timeoutMs
+      // Wall-clock cap is opt-in (explicit config / defaultBudget only); the
+      // roster no longer supplies one. Idle is the default reaper.
+      timeoutMs: rawTimeoutMs ?? this.config.defaultBudget?.timeoutMs ?? configWithRosterDefaults.timeoutMs,
+      idleTimeoutMs: rawIdleTimeoutMs ?? this.config.defaultBudget?.idleTimeoutMs ?? configWithRosterDefaults.idleTimeoutMs
     });
     subagent.activeBudget = budget;
     if (!this.runner) {
@@ -9808,63 +10382,79 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   }
   async executeWithTimeout(runner, task, ctx, budget) {
     const initialTimeoutMs = budget.limits.timeoutMs;
-    if (initialTimeoutMs === void 0) return runner(task, ctx);
+    const idleLimitMs = budget.limits.idleTimeoutMs;
+    if (initialTimeoutMs === void 0 && idleLimitMs === void 0) {
+      return runner(task, ctx);
+    }
     const start = Date.now();
     let timer = null;
     const timeoutPromise = new Promise((_, reject) => {
       const armFor = (ms) => {
         if (timer) clearTimeout(timer);
-        timer = setTimeout(async () => {
-          const elapsed = Date.now() - start;
-          const limit = budget.limits.timeoutMs ?? initialTimeoutMs;
-          if (!budget.onThreshold) {
-            this.subagents.get(ctx.subagentId)?.abortController.abort();
-            reject(new BudgetExceededError("timeout", limit, elapsed));
+        timer = setTimeout(onTick, Math.max(0, ms));
+      };
+      const scheduleNext = () => {
+        const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.timeoutMs ?? initialTimeoutMs) - (Date.now() - start);
+        const idleRemaining = idleLimitMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
+        armFor(Math.max(25, Math.min(wallRemaining, idleRemaining)));
+      };
+      const onTick = async () => {
+        const elapsed = Date.now() - start;
+        const wallLimit = initialTimeoutMs === void 0 ? void 0 : budget.limits.timeoutMs ?? initialTimeoutMs;
+        const idleLimit = idleLimitMs === void 0 ? void 0 : budget.limits.idleTimeoutMs ?? idleLimitMs;
+        const wallExceeded = wallLimit !== void 0 && elapsed >= wallLimit;
+        const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
+        if (idleExceeded && !wallExceeded) {
+          this.subagents.get(ctx.subagentId)?.abortController.abort();
+          reject(new BudgetExceededError("timeout", idleLimit, budget.idleMs()));
+          return;
+        }
+        if (!wallExceeded) {
+          scheduleNext();
+          return;
+        }
+        const limit = wallLimit;
+        if (!budget.onThreshold) {
+          this.subagents.get(ctx.subagentId)?.abortController.abort();
+          reject(new BudgetExceededError("timeout", limit, elapsed));
+          return;
+        }
+        try {
+          const result = budget.onThreshold({
+            kind: "timeout",
+            used: elapsed,
+            limit,
+            requestDecision: () => new Promise((resolveDecision) => {
+              budget._events?.emit("budget.threshold_reached", {
+                kind: "timeout",
+                used: elapsed,
+                limit,
+                timeoutMs: 6e4,
+                extend: (extra) => resolveDecision({ extend: extra }),
+                deny: () => resolveDecision("stop")
+              });
+            })
+          });
+          const decision = typeof result === "string" ? result : await result;
+          if (decision === "continue" || decision === "throw" || decision === "stop") {
+            armFor(Math.max(1e3, limit));
             return;
           }
-          try {
-            const result = budget.onThreshold({
-              kind: "timeout",
-              used: elapsed,
-              limit,
-              requestDecision: () => new Promise((resolveDecision) => {
-                budget._events?.emit("budget.threshold_reached", {
-                  kind: "timeout",
-                  used: elapsed,
-                  limit,
-                  timeoutMs: 6e4,
-                  extend: (extra) => resolveDecision({ extend: extra }),
-                  deny: () => resolveDecision("stop")
-                });
-              })
-            });
-            const decision = typeof result === "string" ? result : await result;
-            if (decision === "continue") {
-              armFor(Math.max(1e3, limit));
-              return;
-            }
-            if (decision === "throw" || decision === "stop") {
-              armFor(Math.max(1e3, limit));
-              return;
-            }
-            if (decision.extend.timeoutMs !== void 0) {
-              budget.limits.timeoutMs = decision.extend.timeoutMs;
-              const newLimit = decision.extend.timeoutMs;
-              const remaining = Math.max(1e3, newLimit - elapsed);
-              armFor(remaining);
-              return;
-            }
-            this.subagents.get(ctx.subagentId)?.abortController.abort();
-            reject(new BudgetExceededError("timeout", limit, elapsed));
-          } catch (err) {
-            this.subagents.get(ctx.subagentId)?.abortController.abort();
-            reject(
-              err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
-            );
+          if (decision.extend.timeoutMs !== void 0) {
+            budget.limits.timeoutMs = decision.extend.timeoutMs;
+            scheduleNext();
+            return;
           }
-        }, ms);
+          this.subagents.get(ctx.subagentId)?.abortController.abort();
+          reject(new BudgetExceededError("timeout", limit, elapsed));
+        } catch (err) {
+          this.subagents.get(ctx.subagentId)?.abortController.abort();
+          reject(
+            err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
+          );
+        }
       };
-      armFor(initialTimeoutMs);
+      scheduleNext();
     });
     try {
       return await Promise.race([runner(task, ctx), timeoutPromise]);
@@ -10041,12 +10631,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
     }));
@@ -10140,7 +10730,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);
@@ -10161,6 +10750,7 @@ var ParallelEternalEngine = class {
     });
     if (fanOut.goalComplete) {
       this.stopRequested = true;
+      this.state = "stopped";
       return true;
     }
     await this.maybeCompact();
@@ -10341,7 +10931,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 [];
     }
   }
@@ -10702,7 +11296,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.
 
@@ -10847,14 +11445,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();
@@ -10900,128 +11496,28 @@ var FleetUsageAggregator = class {
     snap.cacheRead += usage.cacheRead ?? 0;
     snap.cacheWrite += usage.cacheWrite ?? 0;
     this.total.input += usage.input ?? 0;
-    this.total.output += usage.output ?? 0;
-    this.total.cacheRead += usage.cacheRead ?? 0;
-    this.total.cacheWrite += usage.cacheWrite ?? 0;
-    const price = this.priceLookup?.(e.subagentId, snap.provider, snap.model);
-    if (price) {
-      const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
-      snap.cost += delta;
-      this.total.cost += delta;
-    }
-    snap.lastEventAt = e.ts;
-  }
-  onToolExecuted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.toolCalls += 1;
-    snap.lastEventAt = e.ts;
-  }
-  onIterationStarted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.iterations += 1;
-    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)})`;
+    this.total.output += usage.output ?? 0;
+    this.total.cacheRead += usage.cacheRead ?? 0;
+    this.total.cacheWrite += usage.cacheWrite ?? 0;
+    const price = this.priceLookup?.(e.subagentId, snap.provider, snap.model);
+    if (price) {
+      const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
+      snap.cost += delta;
+      this.total.cost += delta;
     }
+    snap.lastEventAt = e.ts;
   }
-  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)})`;
-    }
+  onToolExecuted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.toolCalls += 1;
+    snap.lastEventAt = e.ts;
   }
-  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(" ");
-}
+  onIterationStarted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.iterations += 1;
+    snap.lastEventAt = e.ts;
+  }
+};
 function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
@@ -11192,7 +11688,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"] },
@@ -11203,6 +11699,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",
@@ -11345,7 +11854,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: {
@@ -11353,14 +11862,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;
@@ -11368,12 +11877,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;
@@ -11388,6 +11910,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();
@@ -11405,11 +11935,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) {
@@ -11425,9 +11967,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;
@@ -11442,10 +12005,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 {
@@ -11458,6 +12021,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);
@@ -11471,17 +12038,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);
@@ -11497,12 +12053,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;
@@ -11539,25 +12089,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");
@@ -11566,13 +12124,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.
@@ -11580,26 +12142,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) {
@@ -11625,10 +12307,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,
@@ -11642,33 +12333,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("");
     }
@@ -11687,9 +12386,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("");
@@ -11707,10 +12404,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;
@@ -11731,6 +12427,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() {
@@ -11747,6 +12457,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
@@ -11832,6 +12561,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;
@@ -11847,6 +12593,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, {
@@ -11874,7 +12622,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;
         },
@@ -11936,6 +12684,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;
@@ -12014,6 +12765,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) {
@@ -12052,12 +12904,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) {
@@ -12072,9 +12933,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) {
@@ -12299,6 +13166,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);
@@ -12521,12 +13406,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 t;
   }
@@ -12546,7 +13433,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();
   }
   /**
@@ -12963,6 +13858,71 @@ var NULL_FLEET_BUS = new FleetBus();
 
 // src/models/models-registry.ts
 init_atomic_write();
+
+// src/utils/merge-models-payload.ts
+function mergeModelsPayload(base, overlay) {
+  const out = {};
+  for (const [id, provider] of Object.entries(base)) {
+    out[id] = cloneProvider(provider);
+  }
+  for (const [id, ovProvider] of Object.entries(overlay)) {
+    const existing = out[id];
+    out[id] = existing ? mergeProvider(existing, ovProvider) : cloneProvider(ovProvider);
+  }
+  return out;
+}
+function mergeProvider(base, overlay) {
+  const models = {};
+  for (const [mid, m] of Object.entries(base.models ?? {})) {
+    models[mid] = { ...m };
+  }
+  for (const [mid, ovModel] of Object.entries(overlay.models ?? {})) {
+    const existing = models[mid];
+    models[mid] = existing ? mergeModel(existing, ovModel) : { ...ovModel };
+  }
+  return {
+    ...base,
+    // Overlay scalar fields win when explicitly provided; otherwise keep base.
+    ...stripUndefined({
+      id: overlay.id,
+      name: overlay.name,
+      npm: overlay.npm,
+      api: overlay.api,
+      env: overlay.env,
+      doc: overlay.doc
+    }),
+    models
+  };
+}
+function mergeModel(base, overlay) {
+  const merged = { ...base, ...overlay };
+  if (base.limit || overlay.limit) {
+    merged.limit = { ...base.limit, ...overlay.limit };
+  }
+  if (base.cost || overlay.cost) {
+    merged.cost = { ...base.cost, ...overlay.cost };
+  }
+  if (base.modalities || overlay.modalities) {
+    merged.modalities = { ...base.modalities, ...overlay.modalities };
+  }
+  return merged;
+}
+function cloneProvider(p) {
+  const models = {};
+  for (const [mid, m] of Object.entries(p.models ?? {})) {
+    models[mid] = { ...m };
+  }
+  return { ...p, models };
+}
+function stripUndefined(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+
+// src/models/models-registry.ts
 var DEFAULT_URL = "https://models.dev/api.json";
 var DEFAULT_TTL_SECONDS = 24 * 3600;
 var FAMILY_BY_NPM = {
@@ -12990,7 +13950,10 @@ function classifyFamily(npm) {
   return FAMILY_BY_NPM[npm] ?? "unsupported";
 }
 var DefaultModelsRegistry = class {
+  /** Merged (base + overlay) payload — what every reader sees. */
   payload;
+  /** Memoised overlay payload (in-memory / fetched / file). */
+  overlayPayload;
   fetchedAt;
   cacheFile;
   url;
@@ -12998,6 +13961,10 @@ var DefaultModelsRegistry = class {
   fetchImpl;
   seed;
   maxStaleAgeMs;
+  overlay;
+  overlayUrl;
+  overlayFile;
+  overlayCacheFile;
   constructor(opts) {
     this.cacheFile = opts.cacheFile;
     this.url = opts.url ?? DEFAULT_URL;
@@ -13006,6 +13973,10 @@ var DefaultModelsRegistry = class {
     this.seed = opts.seed;
     const maxStaleSeconds = opts.maxStaleAgeSeconds ?? 7 * 24 * 3600;
     this.maxStaleAgeMs = maxStaleSeconds * 1e3;
+    this.overlay = opts.overlay;
+    this.overlayUrl = opts.overlayUrl;
+    this.overlayFile = opts.overlayFile;
+    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path15.join(path15.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
   }
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
@@ -13014,27 +13985,45 @@ var DefaultModelsRegistry = class {
       this.fetchedAt = /* @__PURE__ */ new Date();
       return this.payload;
     }
+    const overlay = await this.loadOverlay(opts);
+    const base = await this.loadBase(opts, Object.keys(overlay).length > 0);
+    this.payload = mergeModelsPayload(base, overlay);
+    return this.payload;
+  }
+  /**
+   * Load the models.dev base payload: fresh cache → network → stale cache.
+   * On total failure, degrade to `{}` (so a non-empty overlay still drives
+   * the catalog) rather than throwing — unless there's no curated overlay to
+   * fall back on, in which case the original error propagates so pure-
+   * models.dev setups still surface the problem.
+   */
+  async loadBase(opts = {}, overlayAvailable = false) {
     if (!opts.force) {
-      const cached = await this.readCache();
+      const cached = await this.readCacheAt(this.cacheFile);
       if (cached && this.isFresh(cached.fetchedAt)) {
-        this.payload = cached.payload;
         this.fetchedAt = new Date(cached.fetchedAt);
         return cached.payload;
       }
     }
     try {
-      return await this.refresh();
+      return await this.refreshBase();
     } catch (err) {
-      const cached = await this.readCache();
+      const cached = await this.readCacheAt(this.cacheFile);
       if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
-        this.payload = cached.payload;
         this.fetchedAt = new Date(cached.fetchedAt);
         return cached.payload;
       }
+      if (overlayAvailable) {
+        console.warn(
+          `ModelsRegistry: models.dev unavailable (${err instanceof Error ? err.message : String(err)}); serving curated overlay only.`
+        );
+        return {};
+      }
       throw err;
     }
   }
-  async refresh() {
+  /** Fetch + cache the models.dev base. Throws on failure (used by `refresh`). */
+  async refreshBase() {
     const res = await this.fetchImpl(this.url, {
       method: "GET",
       headers: { accept: "application/json" }
@@ -13043,7 +14032,6 @@ var DefaultModelsRegistry = class {
       throw new Error(`ModelsRegistry: HTTP ${res.status} fetching ${this.url}`);
     }
     const json = await res.json();
-    this.payload = json;
     this.fetchedAt = /* @__PURE__ */ new Date();
     const envelope = {
       fetchedAt: this.fetchedAt.toISOString(),
@@ -13053,6 +14041,68 @@ var DefaultModelsRegistry = class {
     await atomicWrite(this.cacheFile, JSON.stringify(envelope));
     return json;
   }
+  /**
+   * Resolve the curated overlay, memoised. Order: in-memory `overlay` →
+   * fetched `overlayUrl` (cached, same TTL/stale rules) → `overlayFile` on
+   * disk. Never throws — a missing/broken overlay yields `{}`.
+   */
+  async loadOverlay(opts = {}) {
+    if (this.overlayPayload && !opts.force) return this.overlayPayload;
+    if (this.overlay) {
+      this.overlayPayload = this.overlay;
+      return this.overlayPayload;
+    }
+    const fetched = await this.loadOverlayFromUrl(opts);
+    if (fetched) {
+      this.overlayPayload = fetched;
+      return fetched;
+    }
+    const fromFile = await this.readOverlayFile();
+    this.overlayPayload = fromFile ?? {};
+    return this.overlayPayload;
+  }
+  async loadOverlayFromUrl(opts) {
+    if (!this.overlayUrl || !this.overlayCacheFile) return void 0;
+    if (!opts.force) {
+      const cached = await this.readCacheAt(this.overlayCacheFile);
+      if (cached && this.isFresh(cached.fetchedAt)) return cached.payload;
+    }
+    try {
+      const res = await this.fetchImpl(this.overlayUrl, {
+        method: "GET",
+        headers: { accept: "application/json" }
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const json = await res.json();
+      const envelope = {
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        url: this.overlayUrl,
+        payload: json
+      };
+      await atomicWrite(this.overlayCacheFile, JSON.stringify(envelope)).catch(() => {
+      });
+      return json;
+    } catch {
+      const cached = await this.readCacheAt(this.overlayCacheFile);
+      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) return cached.payload;
+      return void 0;
+    }
+  }
+  async readOverlayFile() {
+    if (!this.overlayFile) return void 0;
+    try {
+      const raw = await fsp.readFile(this.overlayFile, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async refresh() {
+    const base = await this.refreshBase();
+    const overlay = await this.loadOverlay({ force: true });
+    this.payload = mergeModelsPayload(base, overlay);
+    return this.payload;
+  }
   async listProviders() {
     const payload = await this.load();
     return Object.values(payload).map((p) => this.resolveProvider(p));
@@ -13093,7 +14143,7 @@ var DefaultModelsRegistry = class {
   }
   async ageSeconds() {
     if (!this.fetchedAt) {
-      const cached = await this.readCache();
+      const cached = await this.readCacheAt(this.cacheFile);
       if (!cached) return Number.POSITIVE_INFINITY;
       return (Date.now() - new Date(cached.fetchedAt).getTime()) / 1e3;
     }
@@ -13117,9 +14167,9 @@ var DefaultModelsRegistry = class {
   isWithinMaxStaleAge(fetchedAtIso) {
     return Date.now() - new Date(fetchedAtIso).getTime() < this.maxStaleAgeMs;
   }
-  async readCache() {
+  async readCacheAt(file) {
     try {
-      const raw = await fsp.readFile(this.cacheFile, "utf8");
+      const raw = await fsp.readFile(file, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -15437,7 +16487,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) {
@@ -15453,7 +16503,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();
@@ -15871,13 +16921,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;
   // -------------------------------------------------------------------
@@ -16030,7 +17078,7 @@ var SddParallelRun = class {
     this.coordinator.setRunner?.(runner);
   }
   defaultFactory() {
-    return async (config) => ({
+    return async (_config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
     });
@@ -16844,6 +17892,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.',
@@ -16934,11 +17988,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,
@@ -17177,6 +18261,6 @@ var allServers = () => ({
   "minimax-vision": { ...miniMaxVisionServer(), enabled: false }
 });
 
-export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SddParallelRun, SddTaskDecomposer, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, dispatchAgent, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getAgentDefinition, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, scoreAgents, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
+export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SddParallelRun, SddTaskDecomposer, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, createSessionEventBridge, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, dispatchAgent, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getAgentDefinition, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, resolveAuditLevel, resolveSessionLoggingConfig, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, scoreAgents, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map