@wrongstack/core 0.9.19 → 0.10.0

package/dist/index.js

@@ -56,8 +56,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat9 = await fsp2.stat(targetPath);
-      mode = stat9.mode & 511;
+      const stat8 = await fsp2.stat(targetPath);
+      mode = stat8.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -142,8 +142,10 @@ var ERROR_CODES = {
   // Container / Registry
   CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
   CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
   REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
   REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  REGISTRY_INVALID: "REGISTRY_INVALID",
   // File system
   FS_READ_FAILED: "FS_READ_FAILED",
   FS_WRITE_FAILED: "FS_WRITE_FAILED",
@@ -306,6 +308,16 @@ function isFsError(err) {
 // src/kernel/container.ts
 var Container = class {
   entries = /* @__PURE__ */ new Map();
+  /**
+   * Tokens currently mid-resolve. Tracked so we can detect circular
+   * dependencies (A → B → A) and throw a structured error instead of
+   * overflowing the call stack with "Maximum call stack size exceeded".
+   *
+   * Not a memoization cache — the per-entry `cache` field is the source
+   * of truth for "have I built this before?". This set only lives for
+   * the duration of a single resolve call.
+   */
+  resolving = /* @__PURE__ */ new Set();
   bind(token, factory, opts = {}) {
     if (this.entries.has(token)) {
       throw new WrongStackError({
@@ -366,14 +378,43 @@ var Container = class {
     if (entry.singleton && entry.cache !== void 0) {
       return entry.cache;
     }
-    let value = entry.factory(this);
-    for (const d of entry.decorators) {
-      value = d(value, this);
+    if (this.resolving.has(token)) {
+      const cycle = this.describeCycle(token);
+      throw new WrongStackError({
+        message: `Container: circular dependency detected \u2014 ${cycle}`,
+        code: ERROR_CODES.CONTAINER_CIRCULAR_DEPENDENCY,
+        subsystem: "container",
+        context: { token: token.description, cycle }
+      });
+    }
+    this.resolving.add(token);
+    try {
+      let value = entry.factory(this);
+      for (const d of entry.decorators) {
+        value = d(value, this);
+      }
+      if (entry.singleton) {
+        entry.cache = value;
+      }
+      return value;
+    } finally {
+      this.resolving.delete(token);
     }
-    if (entry.singleton) {
-      entry.cache = value;
+  }
+  /**
+   * Build a human-readable description of the dependency cycle that
+   * caused the resolution to re-enter. Lists the tokens in the order
+   * they were entered, then appends the re-entered token to close the
+   * loop. Falls back to a generic message if the resolving set is
+   * somehow empty (shouldn't happen, but defensive).
+   */
+  describeCycle(reentry) {
+    const descs = [];
+    for (const t2 of this.resolving) {
+      descs.push(t2.description ?? "unknown");
     }
-    return value;
+    descs.push(reentry.description ?? "unknown");
+    return descs.join(" \u2192 ");
   }
   has(token) {
     return this.entries.has(token);
@@ -644,7 +685,8 @@ var EventBus = class {
     }
     if (this.wildcards.length > 0) {
       const name = event;
-      for (const { match, fn } of this.wildcards) {
+      const snapshot = this.wildcards.slice();
+      for (const { match, fn } of snapshot) {
         if (!match(name)) continue;
         try {
           fn(name, payload);
@@ -715,11 +757,19 @@ var ScopedEventBus = class extends EventBus {
    * Uses EventBus's public API directly to avoid triggering our own `on()`
    * override (which would consume a key slot for the wrapper, then orphan
    * our registration entry under a different key).
+   *
+   * When the wrapper fires, it cleans up BOTH the underlying EventBus
+   * listener AND the tracking entry — so `scopedListenerCount` returns to
+   * its pre-`once()` value without requiring the caller to invoke the
+   * returned unsubscribe. The returned `unsub` is still safe to call
+   * after auto-removal (its delete is a no-op and its off() finds
+   * nothing to remove).
    */
   once(event, fn) {
     const key = this.nextKey++;
     const wrapper = (payload) => {
       EventBus.prototype.off.call(this, event, wrapper);
+      this.registrations.delete(key);
       fn(payload);
     };
     EventBus.prototype.on.call(this, event, wrapper);
@@ -1024,6 +1074,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/types/secret-vault.ts
 var ENCRYPTED_PREFIX = "enc:v1:";
@@ -1676,6 +1734,7 @@ var HybridCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateMessages(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
     const policy = readContextWindowPolicy(ctx);
     const preserveK = policy?.preserveK ?? this.preserveK;
@@ -1691,9 +1750,12 @@ var HybridCompactor = class {
       ctx.state.replaceMessages(repaired.messages);
     }
     const afterTokens = this.estimateMessages(ctx.messages);
+    const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
       after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
       reductions,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
@@ -1702,6 +1764,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;
@@ -2128,6 +2198,71 @@ var DefaultSecretScrubber = class {
 
 // 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 = {
@@ -2155,7 +2290,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;
@@ -2163,6 +2301,10 @@ var DefaultModelsRegistry = class {
   fetchImpl;
   seed;
   maxStaleAgeMs;
+  overlay;
+  overlayUrl;
+  overlayFile;
+  overlayCacheFile;
   constructor(opts) {
     this.cacheFile = opts.cacheFile;
     this.url = opts.url ?? DEFAULT_URL;
@@ -2171,6 +2313,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 ? path6.join(path6.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
   }
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
@@ -2179,27 +2325,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" }
@@ -2208,7 +2372,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(),
@@ -2218,6 +2381,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 fsp2.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));
@@ -2258,7 +2483,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;
     }
@@ -2282,9 +2507,9 @@ var DefaultModelsRegistry = class {
   isWithinMaxStaleAge(fetchedAtIso) {
     return Date.now() - new Date(fetchedAtIso).getTime() < this.maxStaleAgeMs;
   }
-  async readCache() {
+  async readCacheAt(file) {
     try {
-      const raw = await fsp2.readFile(this.cacheFile, "utf8");
+      const raw = await fsp2.readFile(file, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -2856,6 +3081,141 @@ function topologicalSort(graph) {
   return result;
 }
 
+// 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/utils/json-schema-validate.ts
+function validateAgainstSchema(value, schema) {
+  const errors = [];
+  walk2(value, schema, "", errors);
+  return { ok: errors.length === 0, errors };
+}
+function walk2(value, schema, path35, errors) {
+  if (schema.enum !== void 0) {
+    if (!schema.enum.some((e) => deepEqual(e, value))) {
+      errors.push({
+        path: path35 || "<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: path35 || "<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(path35, req), message: "required property missing" });
+      }
+    }
+    if (schema.properties) {
+      for (const [key, subSchema] of Object.entries(schema.properties)) {
+        if (key in obj) {
+          walk2(obj[key], subSchema, joinPath(path35, key), errors);
+        }
+      }
+    }
+  }
+  if (schema.type === "array" && Array.isArray(value) && schema.items) {
+    value.forEach((item, i) => walk2(item, schema.items, `${path35}[${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;
@@ -2937,18 +3297,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") {
@@ -2973,10 +3360,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);
@@ -3919,9 +4309,11 @@ function resolveWstackPaths(opts) {
     globalPrompts: path6.join(globalRoot, "prompts"),
     cacheDir: path6.join(globalRoot, "cache"),
     modelsCache: path6.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path6.join(globalRoot, "cache", "models-overlay.json"),
     historyFile: path6.join(globalRoot, "history"),
     logFile: path6.join(globalRoot, "logs", "wrongstack.log"),
     projectDir,
+    projectCodebaseIndex: path6.join(projectDir, "codebase-index"),
     projectMemory: path6.join(projectDir, "memory.md"),
     projectSessions: path6.join(projectDir, "sessions"),
     projectTrust: path6.join(projectDir, "trust.json"),
@@ -4030,175 +4422,86 @@ function buildChildEnv(optsOrSessionId) {
   return out;
 }
 
-// src/utils/json-schema-validate.ts
-function validateAgainstSchema(value, schema) {
-  const errors = [];
-  walk2(value, schema, "", errors);
-  return { ok: errors.length === 0, errors };
-}
-function walk2(value, schema, path31, errors) {
-  if (schema.enum !== void 0) {
-    if (!schema.enum.some((e) => deepEqual(e, value))) {
-      errors.push({
-        path: path31 || "<root>",
-        message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
-      });
-      return;
+// src/utils/json-repair.ts
+function completePartialObject(s) {
+  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 === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = false;
+        prevSig = '"';
+        stringBraceDepth = 0;
+        continue;
+      }
+      if (ch === "{") stringBraceDepth++;
+      else if (ch === "}" && stringBraceDepth > 0) stringBraceDepth--;
+      continue;
     }
-  }
-  if (typeof schema.type === "string") {
-    if (!checkType(value, schema.type)) {
-      errors.push({
-        path: path31 || "<root>",
-        message: `expected ${schema.type}, got ${describeType(value)}`
-      });
-      return;
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") continue;
+    contentEnd = i + 1;
+    if (ch === '"') {
+      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 (schema.type === "object" && isPlainObject(value)) {
-    const obj = value;
-    for (const req of schema.required ?? []) {
-      if (!(req in obj)) {
-        errors.push({ path: joinPath(path31, req), message: "required property missing" });
-      }
-    }
-    if (schema.properties) {
-      for (const [key, subSchema] of Object.entries(schema.properties)) {
-        if (key in obj) {
-          walk2(obj[key], subSchema, joinPath(path31, key), errors);
-        }
-      }
+  if (!sawKey && !inString) return s;
+  let result = s.slice(0, contentEnd);
+  if (inString) {
+    if (escaped) {
+      result = result.slice(0, -1);
+    } else if (endsWithInvalidEscape(result)) {
+      result = result.slice(0, -2);
     }
+    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
+    result += '"';
+  } else if (prevSig === ":") {
+    result += "null";
   }
-  if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk2(item, schema.items, `${path31}[${i}]`, errors));
+  for (let k = stack.length - 1; k >= 0; k--) {
+    result += stack[k] === "{" ? "}" : "]";
   }
-}
-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;
+  if (!tryParse(result).ok) {
+    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
+    if (tryParse(patched).ok) result = patched;
   }
+  return result;
 }
-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/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;
-        continue;
-      }
-      if (ch === "\\") {
-        escaped2 = true;
-        continue;
-      }
-      if (ch === '"') {
-        inString2 = !inString2;
-        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;
-      continue;
-    }
-    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;
-      }
-    }
-  }
-  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);
-    }
-    result += '"' + "}".repeat(Math.max(1, depth));
-  }
-  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 {
@@ -4340,8 +4643,8 @@ var DefaultSessionStore = class {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat9 = await fsp2.stat(full);
-      const summary = await this.summarize(id, stat9.mtime.toISOString());
+      const stat8 = await fsp2.stat(full);
+      const summary = await this.summarize(id, stat8.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
@@ -4534,7 +4837,6 @@ var FileSessionWriter = class {
     }
     return event;
   }
-  promptIndex = 0;
   pendingFileSnapshots = [];
   /** Tracks open tool_use IDs during the current run to serialize on close for resume. */
   openToolUses = /* @__PURE__ */ new Set();
@@ -4625,7 +4927,6 @@ var FileSessionWriter = class {
       await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
-    this.promptIndex = promptIndex + 1;
     await this.append({
       type: "checkpoint",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4721,6 +5022,38 @@ var FileSessionWriter = class {
 `;
     await fsp2.writeFile(this.filePath, record, "utf8");
   }
+  /**
+   * Idea #1 — write an in-flight marker. The agent loop should call
+   * this at the start of each long-running operation; a matching
+   * `clearInFlightMarker` follows on clean exit. A stale marker
+   * (no end) is what `SessionRecovery.detectStale` looks for.
+   */
+  async writeInFlightMarker(context) {
+    if (!context || context.length > 500) {
+      throw new Error("In-flight context must be 1..500 chars");
+    }
+    await this.append({
+      type: "in_flight_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      context
+    });
+    this.events?.emit("in_flight.started", { context, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  /**
+   * Idea #1 — close the in-flight marker. Idempotent in spirit
+   * (you can call it after a successful iteration even if you
+   * didn't open one this round) — but the session log records
+   * every call so postmortem tooling can see "the agent finished
+   * cleanly X times, then died without finishing Y".
+   */
+  async clearInFlightMarker(reason) {
+    await this.append({
+      type: "in_flight_end",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      reason
+    });
+    this.events?.emit("in_flight.ended", { reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  }
 };
 function userInputTitle(content) {
   const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
@@ -4783,7 +5116,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 = [];
@@ -4837,9 +5170,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] });
@@ -4892,6 +5231,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) {
@@ -5219,7 +5567,8 @@ var BEHAVIOR_DEFAULTS = {
     memory: true,
     modelsRegistry: true,
     skills: true
-  }
+  },
+  session: { ...DEFAULT_SESSION_LOGGING_CONFIG }
 };
 var ENV_MAP = {
   WRONGSTACK_PROVIDER: (c, v) => {
@@ -5727,6 +6076,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) {
@@ -6215,8 +6659,6 @@ var DirectorStateCheckpoint = class {
     }
   }
 };
-
-// src/security/permission-policy.ts
 init_atomic_write();
 var DefaultPermissionPolicy = class {
   policy = {};
@@ -6457,31 +6899,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
@@ -6492,12 +6924,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" };
@@ -6976,8 +7412,9 @@ var IntelligentCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateTokens(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
-    const load = beforeTokens / this.maxContext;
+    const load = beforeFull / this.maxContext;
     const aggressive = load >= this.hardThreshold ? true : opts.aggressive ?? load >= this.softThreshold;
     const saved1 = this.eliseOldToolResults(ctx);
     if (saved1 > 0) reductions.push({ phase: "elision", saved: saved1 });
@@ -6991,9 +7428,12 @@ var IntelligentCompactor = class {
     const repaired = repairToolUseAdjacency(ctx.messages);
     if (repaired.report.changed) ctx.state.replaceMessages(repaired.messages);
     const afterTokens = this.estimateTokens(ctx.messages);
+    const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
       after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
       reductions,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
@@ -7002,6 +7442,14 @@ var IntelligentCompactor = class {
       } : void 0
     };
   }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
+  }
   async summarizeAncientTurns(ctx) {
     const messages = ctx.messages;
     const cutoff = Math.max(0, messages.length - this.preserveK * 2);
@@ -7014,29 +7462,26 @@ var IntelligentCompactor = class {
     try {
       summaryText = await this.callSummarizer(toSummarize, ctx);
     } catch {
-      const toolNames = /* @__PURE__ */ new Set();
-      const filePaths = /* @__PURE__ */ new Set();
-      let userTurns = 0;
-      let assistantTurns = 0;
+      const preservedMessages = [];
       for (const m of toSummarize) {
-        if (m.role === "user") userTurns++;
-        else if (m.role === "assistant") {
-          assistantTurns++;
-          if (Array.isArray(m.content)) {
-            for (const b of m.content) {
-              if (b.type === "tool_use") toolNames.add(b.name ?? "unknown");
-            }
-          }
+        if (m.role === "system") continue;
+        if (typeof m.content === "string") {
+          preservedMessages.push(m);
+        } else if (Array.isArray(m.content)) {
+          const textParts = m.content.filter(isTextBlock);
+          const toolParts = m.content.filter((b) => b.type === "tool_use" || b.type === "tool_result");
+          const next = {
+            role: m.role,
+            content: [
+              ...textParts,
+              ...toolParts.length > 0 ? [{ type: "text", text: `[${toolParts.length} tool call(s) omitted]` }] : []
+            ]
+          };
+          preservedMessages.push(next);
         }
-        const text = typeof m.content === "string" ? m.content : "";
-        const matches = text.matchAll(/(?:[\w.,\-/@]+\/)*[\w.,\-/@]+\.\w+/g);
-        for (const m_ of matches) filePaths.add(m_[0]);
       }
-      const parts = [`${toSummarize.length} turns (${userTurns} user, ${assistantTurns} assistant)`];
-      if (toolNames.size > 0) parts.push(`tools: ${[...toolNames].join(", ")}`);
-      if (filePaths.size > 0) parts.push(`files: ${[...filePaths].slice(0, 10).join(", ")}`);
-      summaryText = parts.join(" | ");
-      if (!summaryText) summaryText = `${toSummarize.length} earlier turns omitted`;
+      summaryText = preservedMessages.map((m) => `[${m.role}]: ${typeof m.content === "string" ? m.content : m.content.filter(isTextBlock).map((b) => b.text).join(" ")}`).join("\n");
+      if (!summaryText) summaryText = `${toSummarize.length} earlier turns (semantic content preserved)`;
     }
     const summaryMsg = {
       role: "system",
@@ -7282,7 +7727,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       const res = await this.provider.complete(req, { signal: ac.signal });
       const textBlocks = res.content.filter(isTextBlock);
       raw = textBlocks.map((b) => b.text).join("\n").trim();
-    } catch (err) {
+    } catch (_err) {
       return this.fallbackSelect(messages, effectiveBudget);
     }
     return this.parseSelectorOutput(raw, messages.length);
@@ -7374,15 +7819,24 @@ var SelectiveCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateTokens(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
-    const load = beforeTokens / this.maxContext;
+    const load = beforeFull / this.maxContext;
     const shouldCompact = load >= this.warnThreshold || opts.aggressive;
     if (!shouldCompact) {
       const saved = this.eliseOldToolResults(ctx);
       if (saved > 0) reductions.push({ phase: "elision", saved });
       const repair2 = this.repairProtocolAdjacency(ctx);
       const afterTokens2 = this.estimateTokens(ctx.messages);
-      return { before: beforeTokens, after: afterTokens2, reductions, repaired: repair2 };
+      const afterFull2 = this.estimateFullRequest(ctx);
+      return {
+        before: beforeTokens,
+        after: afterTokens2,
+        fullRequestTokensBefore: beforeFull,
+        fullRequestTokensAfter: afterFull2,
+        reductions,
+        repaired: repair2
+      };
     }
     const savedElision = this.eliseOldToolResults(ctx);
     if (savedElision > 0) reductions.push({ phase: "elision", saved: savedElision });
@@ -7394,7 +7848,23 @@ var SelectiveCompactor = class {
     }
     const repair = this.repairProtocolAdjacency(ctx);
     const afterTokens = this.estimateTokens(ctx.messages);
-    return { before: beforeTokens, after: afterTokens, reductions, repaired: repair };
+    const afterFull = this.estimateFullRequest(ctx);
+    return {
+      before: beforeTokens,
+      after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
+      reductions,
+      repaired: repair
+    };
+  }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
   }
   repairProtocolAdjacency(ctx) {
     const repaired = repairToolUseAdjacency(ctx.messages);
@@ -7584,7 +8054,8 @@ var LEVEL_RANK2 = { warn: 0, soft: 1, hard: 2 };
 var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
-  estimator;
+  /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
+  _estimator;
   warnThreshold;
   softThreshold;
   hardThreshold;
@@ -7594,19 +8065,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
@@ -7619,8 +8078,11 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   lastNoopAttempt = null;
   /**
    * @param compactor        Compactor to use for compaction.
-   * @param maxContext       Provider's max context window in tokens.
-   * @param estimator        Token estimation function.
+   * @param maxContext Provider's max context window in tokens.
+   * @param _estimator       Deprecated parameter kept for backward compatibility.
+   *                         The middleware now uses `estimateRequestTokens` internally
+   *                         for accurate full-request token counting (messages +
+   *                         systemPrompt + toolDefs).
    * @param thresholds       Threshold fractions (0-1) of maxContext.
    * @param opts             Optional behavior. By default, failures at the
    *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
@@ -7628,11 +8090,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;
@@ -7640,6 +8102,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. */
@@ -7648,8 +8111,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   }
   handler() {
     return async (ctx, next) => {
-      const rawTokens = this.estimator(ctx);
-      const tokens = Math.ceil(rawTokens * _AutoCompactionMiddleware.OVERHEAD_FACTOR);
+      const tokens = this._estimator ? this._estimator(ctx) : estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []).total;
       const load = tokens / this._maxContext;
       const policy = this.policyProvider?.(ctx);
       const thresholds = policy?.thresholds ?? {
@@ -7684,7 +8146,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;
@@ -7704,6 +8166,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));
@@ -8615,19 +9086,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.
@@ -8668,6 +9136,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() {
@@ -8689,38 +9175,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")) {
@@ -8737,20 +9273,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");
+                }
+              });
+            }
           });
         }
       });
@@ -8774,54 +9312,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 {
@@ -8928,6 +9471,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) {
@@ -8944,6 +9488,7 @@ function makeAgentSubagentRunner(opts) {
         currentToolName = e.name;
       }),
       events.on("provider.text_delta", (e) => {
+        ctx.budget.markActivity();
         streamingTextAcc = (streamingTextAcc + e.text).slice(-200);
       })
     );
@@ -11513,6 +12058,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 },
@@ -11524,7 +12070,7 @@ var FLEET_ROSTER_BUDGETS = {
   )
 };
 var GENERIC_SUBAGENT_BUDGET = {
-  timeoutMs: 3 * 60 * 60 * 1e3,
+  idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
   maxIterations: 5e3,
   maxToolCalls: 15e3
 };
@@ -11534,7 +12080,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,
@@ -11604,84 +12156,213 @@ var FLEET_ROSTER_WITHACP = {
   ...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,
-      maxConcurrent: this.config.maxConcurrent ?? 16
-    };
-    this.subagents.set(id, {
-      config: { ...subagent, id },
-      context,
-      status: "idle",
-      abortController: new AbortController()
-    });
-    this.emit("subagent.started", { subagent: { ...subagent, id } });
-    this.fleetBus?.emit({
+// 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, {
+      config: { ...subagent, id },
+      context,
+      status: "idle",
+      abortController: new AbortController()
+    });
+    this.emit("subagent.started", { subagent: { ...subagent, id } });
+    this.fleetBus?.emit({
       subagentId: id,
       ts: Date.now(),
       type: "subagent.assigned",
@@ -11967,13 +12648,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) {
@@ -12020,63 +12705,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]);
@@ -12253,12 +12954,12 @@ var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
   constructor(opts) {
     this.opts = opts;
-    this.goalPath = goalFilePath(opts.projectRoot);
+    this.goalPath = opts.goalPath ?? goalFilePath(opts.projectRoot);
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
     this.timeoutMs = opts.iterationTimeoutMs ?? 3e5;
     this.dispatchEnabled = opts.dispatch !== false;
     this.dispatchClassifier = opts.dispatchClassifier;
-    this.agentFactory = opts.subagentFactory ?? (async (config) => ({
+    this.agentFactory = opts.subagentFactory ?? (async (_config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
     }));
@@ -12352,7 +13053,6 @@ var ParallelEternalEngine = class {
     }
     const tasks = await this.decomposeGoal(goal);
     if (!tasks || tasks.length === 0) {
-      await sleep2(5e3);
       return false;
     }
     const fanOut = await this.fanOut(goal, tasks);
@@ -12373,6 +13073,7 @@ var ParallelEternalEngine = class {
     });
     if (fanOut.goalComplete) {
       this.stopRequested = true;
+      this.state = "stopped";
       return true;
     }
     await this.maybeCompact();
@@ -12553,7 +13254,11 @@ ${lastFew}` : "No prior iterations.",
       } finally {
         clearTimeout(timer);
       }
-    } catch {
+    } catch (err) {
+      this.opts.onError?.(
+        err instanceof Error ? err : new Error(String(err)),
+        this.consecutiveFailures
+      );
       return [];
     }
   }
@@ -12770,7 +13475,11 @@ Working rules:
      thrashing, terminate it rather than letting cost climb silently.
   6. Never claim a subagent's work as your own without verifying it. If a
      result looks wrong, ask_subagent for clarification before passing it
-     to the user.`;
+     to the user.
+  7. Wind down when satisfied. When the results are good enough, call
+     work_complete \u2014 no new subagents will spawn and queued tasks complete
+     as aborted. Running subagents finish naturally. Call terminate_subagent
+     only for ones you need to stop immediately.`;
 var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
 a specific slice of a larger plan \u2014 do that slice well and report back.
 
@@ -12915,14 +13624,12 @@ var FleetBus = class {
 };
 var FleetUsageAggregator = class {
   constructor(bus, priceLookup, metaLookup) {
-    this.bus = bus;
     this.priceLookup = priceLookup;
     this.metaLookup = metaLookup;
     bus.filter("provider.response", (e) => this.onProviderResponse(e));
     bus.filter("tool.executed", (e) => this.onToolExecuted(e));
     bus.filter("iteration.started", (e) => this.onIterationStarted(e));
   }
-  bus;
   priceLookup;
   metaLookup;
   perSubagent = /* @__PURE__ */ new Map();
@@ -12990,106 +13697,6 @@ var FleetUsageAggregator = class {
     snap.lastEventAt = e.ts;
   }
 };
-
-// src/coordination/subagent-nicknames.ts
-var NICKNAME_POOL = {
-  // Physics & fundamental sciences
-  "einstein": { name: "Einstein", domain: "physics" },
-  "newton": { name: "Newton", domain: "physics" },
-  "feynman": { name: "Feynman", domain: "physics" },
-  "dirac": { name: "Dirac", domain: "physics" },
-  "bohr": { name: "Bohr", domain: "physics" },
-  "planck": { name: "Planck", domain: "physics" },
-  "curie": { name: "Curie", domain: "physics" },
-  "fermi": { name: "Fermi", domain: "physics" },
-  "heisenberg": { name: "Heisenberg", domain: "physics" },
-  "schrodinger": { name: "Schr\xF6dinger", domain: "physics" },
-  // Mathematics
-  "euclid": { name: "Euclid", domain: "math" },
-  "gauss": { name: "Gauss", domain: "math" },
-  "turing": { name: "Turing", domain: "math" },
-  "poincare": { name: "Poincar\xE9", domain: "math" },
-  "riemann": { name: "Riemann", domain: "math" },
-  "hilbert": { name: "Hilbert", domain: "math" },
-  "pythagoras": { name: "Pythagoras", domain: "math" },
-  // Computing & information theory
-  "von-neumann": { name: "Von Neumann", domain: "computing" },
-  "shannon": { name: "Shannon", domain: "computing" },
-  "hopper": { name: "Hopper", domain: "computing" },
-  "backus": { name: "Backus", domain: "computing" },
-  "knuth": { name: "Knuth", domain: "computing" },
-  "torvalds": { name: "Torvalds", domain: "computing" },
-  "stallman": { name: "Stallman", domain: "computing" },
-  "berners-lee": { name: "Berners-Lee", domain: "computing" },
-  "babbage": { name: "Babbage", domain: "computing" },
-  "lovelace": { name: "Lovelace", domain: "computing" },
-  "klein": { name: "Klein", domain: "computing" },
-  // Electronics & electrical engineering
-  "edison": { name: "Edison", domain: "ee" },
-  "tesla": { name: "Tesla", domain: "ee" },
-  "faraday": { name: "Faraday", domain: "ee" },
-  "maxwell": { name: "Maxwell", domain: "ee" },
-  "ohm": { name: "Ohm", domain: "ee" },
-  "bell": { name: "Bell", domain: "ee" },
-  "marconi": { name: "Marconi", domain: "ee" },
-  "lamarr": { name: "Lamarr", domain: "ee" },
-  // General science / multi-disciplinary
-  "darwin": { name: "Darwin", domain: "biology" },
-  "mendel": { name: "Mendel", domain: "biology" },
-  "pasteur": { name: "Pasteur", domain: "biology" },
-  "hawking": { name: "Hawking", domain: "cosmology" },
-  "sagan": { name: "Sagan", domain: "cosmology" },
-  // Chemistry / materials
-  "lavoisier": { name: "Lavoisier", domain: "chemistry" },
-  "mendeleev": { name: "Mendeleev", domain: "chemistry" }
-};
-var ALL_NICKNAMES = Object.values(NICKNAME_POOL);
-var DOMAIN_PREFERENCES = {
-  "security": ["shannon", "turing", "lamarr", "stallman"],
-  "bug-hunter": ["darwin", "curie", "feynman", "fermi"],
-  "refactor": ["gauss", "hilbert", "euclid", "planck"],
-  "audit-log": ["sagan", "hawking", "poincare", "newton"],
-  "planner": ["hilbert", "gauss", "turing", "euclid"],
-  "researcher": ["sagan", "hawking", "darwin", "pasteur"],
-  "explorer": ["marconi", "bell", "columbus", "polo"],
-  "testing": ["pasteur", "curie", "fermi", "bohr"],
-  "frontend": ["lovelace", "hopper", "babbage", "backus"],
-  "backend": ["torvalds", "stallman", "von-neumann", "backus"],
-  "database": ["turing", "shannon", "backus", "knuth"],
-  "devops": ["tesla", "edison", "faraday", "bell"],
-  "security-scanner": ["shannon", "turing", "lamarr", "stallman"],
-  "refactor-planner": ["gauss", "hilbert", "planck", "newton"],
-  "architect": ["von-neumann", "turing", "gauss", "hilbert"],
-  "critic": ["einstein", "feynman", "dirac", "bohr"],
-  "e2e": ["hopper", "bell", "marconi", "tesla"],
-  "performance": ["knuth", "gauss", "planck", "feynman"],
-  "chaos": ["tesla", "edison", "curie", "fermi"],
-  "cost": ["oh", "bell", "marconi", "tesla"],
-  // default fallback
-  "default": ["einstein", "newton", "curie", "tesla", "edison", "turing", "shannon", "hopper", "knuth", "stallman"]
-};
-function assignNickname(role, used) {
-  const preferences = [
-    ...DOMAIN_PREFERENCES[role] ?? [],
-    ...DOMAIN_PREFERENCES["default"] ?? []
-  ];
-  for (const key of preferences) {
-    if (!used.has(key)) {
-      return `${NICKNAME_POOL[key].name} (${formatRole(role)})`;
-    }
-  }
-  for (const entry of ALL_NICKNAMES) {
-    const key = Object.entries(NICKNAME_POOL).find(([, v]) => v.name === entry.name)?.[0];
-    if (key && !used.has(key)) {
-      return `${entry.name} (${formatRole(role)})`;
-    }
-  }
-  const counter = used.size + 1;
-  return `Scientist #${counter} (${formatRole(role)})`;
-}
-function formatRole(role) {
-  return role.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
 function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
@@ -13260,7 +13867,7 @@ function makeRollUpTool(director) {
 function makeTerminateTool(director) {
   return {
     name: "terminate_subagent",
-    description: "Forcibly abort a subagent.",
+    description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
     permission: "auto",
     mutating: true,
     inputSchema: { type: "object", properties: { subagentId: { type: "string", description: "Subagent to abort." } }, required: ["subagentId"] },
@@ -13271,6 +13878,19 @@ function makeTerminateTool(director) {
     }
   };
 }
+function makeTerminateAllTool(director) {
+  return {
+    name: "terminate_all",
+    description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
+    permission: "auto",
+    mutating: true,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      await director.terminateAll();
+      return { ok: true, message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.` };
+    }
+  };
+}
 function makeFleetStatusTool(director) {
   return {
     name: "fleet_status",
@@ -13413,7 +14033,7 @@ function makeCollabDebugTool(director) {
 function makeFleetEmitTool(director) {
   return {
     name: "fleet_emit",
-    description: "Emit a structured event on the FleetBus. Use this when you find a bug (bug.found), complete a refactor plan (refactor.plan), or finish an evaluation (critic.evaluation). Events are routed to other agents in the collab session.",
+    description: "Emit a structured event on the FleetBus. Any subagent can emit any event type; the Director routes it to all listeners. Use it to stream findings, progress updates, or final results to other agents in real time.",
     permission: "auto",
     mutating: false,
     inputSchema: {
@@ -13421,14 +14041,14 @@ function makeFleetEmitTool(director) {
       properties: {
         type: {
           type: "string",
-          description: "Event type: bug.found | refactor.plan | critic.evaluation"
+          description: "Event type string (e.g. bug.found, refactor.plan, critic.evaluation, progress, result)."
         },
         payload: {
           type: "object",
-          description: "Event payload matching the event type."
+          description: "Event payload. Structure depends on event type. Use null if no payload."
         }
       },
-      required: ["type", "payload"]
+      required: ["type"]
     },
     async execute(input) {
       const i = input;
@@ -13436,12 +14056,25 @@ function makeFleetEmitTool(director) {
         subagentId: director.id,
         ts: Date.now(),
         type: i.type,
-        payload: i.payload
+        payload: i.payload ?? {}
       });
       return { ok: true, event: i.type };
     }
   };
 }
+function makeWorkCompleteTool(director) {
+  return {
+    name: "work_complete",
+    description: "Signal that the director is satisfied with the results and the fleet should wind down. After calling this, spawn_subagent will refuse with a budget error and assign_task will instantly complete any queued tasks as aborted. Running subagents finish naturally. Call terminate_subagent separately to stop specific subagents immediately.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      director.workComplete();
+      return { ok: true, message: "Fleet wind-down signaled. No new spawns or task dispatches." };
+    }
+  };
+}
 var CollabSession = class extends EventEmitter {
   sessionId;
   options;
@@ -13456,6 +14089,14 @@ var CollabSession = class extends EventEmitter {
   disposers = new Array();
   settled = false;
   timeoutMs;
+  cancelled = false;
+  alerts = [];
+  /** Tracks tool call counts per subagent for progress-based timeout decisions. */
+  progressBySubagent = /* @__PURE__ */ new Map();
+  /** Last tool call count when a timeout warning was handled. */
+  lastTimeoutProgress = /* @__PURE__ */ new Map();
+  /** Session-level timeout timer handle (cleared on cancel or natural completion). */
+  _timeoutTimer;
   constructor(director, fleetBus, options) {
     super();
     this.sessionId = randomUUID();
@@ -13473,11 +14114,23 @@ var CollabSession = class extends EventEmitter {
       };
     }
   }
+  get id() {
+    return this.sessionId;
+  }
+  getSessionAlerts() {
+    return [...this.alerts];
+  }
+  isCancelled() {
+    return this.cancelled;
+  }
   /**
-   * Read the target files from disk and populate the snapshot.
-   * Call this after construction if you did not provide a prebuiltSnapshot
-   * and want the session to operate on real file contents.
+   * Snapshot of role → subagentId map. The Director calls coordinator.stop()
+   * for each agent when cancelling the session, using this map to enumerate
+   * all three collab agents.
    */
+  getSubagentIds() {
+    return new Map(this.subagentIds);
+  }
   async buildSnapshot() {
     if (this.snapshot.files.length > 0) return this.snapshot;
     for (const filePath of this.options.targetPaths) {
@@ -13493,9 +14146,30 @@ var CollabSession = class extends EventEmitter {
     return this.snapshot;
   }
   /**
-   * Start the collaborative session: snapshot files, spawn all three agents,
-   * wire up event routing, and wait for completion.
+   * Cancel the session. Emits director.cancel_collab on the FleetBus so all
+   * collab agents finish early. The session-level timeout timer is also cleared.
+   * Safe to call multiple times (idempotent after first call).
    */
+  cancel(reason = "Director cancelled collab session") {
+    if (this.settled) return;
+    this.cancelled = true;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = void 0;
+    }
+    this.fleetBus.emit({
+      subagentId: this.director.id,
+      ts: Date.now(),
+      type: "director.cancel_collab",
+      payload: { sessionId: this.sessionId, reason, cancelledAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    this.fleetBus.emit({
+      subagentId: this.director.id,
+      ts: Date.now(),
+      type: "collab.cancelled",
+      payload: { sessionId: this.sessionId, reason }
+    });
+  }
   async start() {
     if (this.settled) throw new Error("session already settled");
     this.settled = true;
@@ -13510,10 +14184,10 @@ var CollabSession = class extends EventEmitter {
     this.subagentIds.set("refactor-planner", refactorPlannerId);
     this.subagentIds.set("critic", criticId);
     const timeout = new Promise((_, reject) => {
-      setTimeout(
-        () => reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`)),
-        this.timeoutMs
-      );
+      this._timeoutTimer = setTimeout(() => {
+        this.cancel("Session-level timeout reached");
+        reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
     });
     let results;
     try {
@@ -13526,6 +14200,10 @@ var CollabSession = class extends EventEmitter {
         timeout
       ]);
     } catch (err) {
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = void 0;
+      }
       this.cleanup();
       const error = err instanceof Error ? err : new Error(String(err));
       this.emit("session.error", error);
@@ -13539,17 +14217,6 @@ var CollabSession = class extends EventEmitter {
     this.emit("session.done", report);
     return report;
   }
-  /**
-   * Parse a completed agent's final text output and route the structured
-   * findings onto the FleetBus. Agents are instructed to emit one JSON object
-   * per finding / plan / evaluation; we scan the output for balanced JSON
-   * objects (tolerating prose, markdown, and ```json fences around them) and
-   * dispatch each by its discriminating key. The wired FleetBus listeners then
-   * collect them into the bugs / plans / evaluations maps.
-   *
-   * Failed or empty results are ignored, and a single malformed object never
-   * aborts the collation pass — see {@link extractJsonObjects}.
-   */
   async parseAndEmit(result) {
     if (result.status !== "success" || result.result == null) return;
     const text = typeof result.result === "string" ? result.result : JSON.stringify(result.result);
@@ -13565,12 +14232,6 @@ var CollabSession = class extends EventEmitter {
       });
     }
   }
-  /**
-   * Extract every top-level JSON object embedded in free-form agent text.
-   * Scans for balanced braces while respecting string literals and escape
-   * sequences, so prose, markdown headers, and code fences around the JSON
-   * are skipped. Malformed spans are dropped silently rather than thrown.
-   */
   extractJsonObjects(text) {
     const objects = [];
     let depth = 0;
@@ -13607,25 +14268,33 @@ var CollabSession = class extends EventEmitter {
     }
     return objects;
   }
+  budgetForRole(role) {
+    if (this.options.budgetOverrides?.[role]) {
+      return this.options.budgetOverrides[role];
+    }
+    const defaults = {
+      "bug-hunter": { maxIterations: 2e3, maxToolCalls: 5e3, timeoutMs: 10 * 60 * 1e3 },
+      "refactor-planner": { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 },
+      "critic": { maxIterations: 1e3, maxToolCalls: 3e3, timeoutMs: 6 * 60 * 1e3 }
+    };
+    return defaults[role] ?? { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 };
+  }
   async spawnAgent(role, taskBrief) {
+    const budget = this.budgetForRole(role);
     const cfg = {
       id: `${role}-${this.sessionId}`,
       name: role,
-      role
-      // No fleet_emit tool — agents output structured JSON, the Director parses
-      // results and emits FleetBus events. This keeps the agent simple and the
-      // routing deterministic.
+      role,
+      tools: ["fleet_emit", "fleet_status", "read", "grep", "glob", "bash", "write"],
+      maxIterations: budget.maxIterations,
+      maxToolCalls: budget.maxToolCalls,
+      timeoutMs: budget.timeoutMs
     };
     const subagentId = await this.director.spawn(cfg);
-    await this.director.assign({
-      id: randomUUID(),
-      subagentId,
-      description: taskBrief
-    });
+    await this.director.assign({ id: randomUUID(), subagentId, description: taskBrief });
     return subagentId;
   }
   buildBugHunterTask() {
-    this.options.targetPaths.join(", ");
     const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
     const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
 ${f.content}`).join("\n\n");
@@ -13634,13 +14303,17 @@ ${f.content}`).join("\n\n");
 Target files:
 ${fileContents}
 
-For each bug found, write ONE valid JSON line to the scratchpad with this exact structure:
-{ "finding": { "id": "<uuid>", "type": "<pattern>", "severity": "<critical|high|medium|low>", "location": { "file": "<path>", "line": <n> }, "description": "<explain>", "suggestedFix": "<optional>" } }.
-After scanning all files, write your full markdown bug report to the shared scratchpad at:
-${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
+For each bug found, emit it using the fleet_emit tool immediately:
+{ "type": "bug.found", "payload": { "finding": { "id": "<uuid>", "type": "<pattern>", "severity": "<critical|high|medium|low>", "location": { "file": "<path>", "line": <n> }, "description": "<explain>", "suggestedFix": "<optional>" } } }
+
+After scanning all files, write your full markdown bug report to:
+${scratchpad}/bug-hunter-report-${this.sessionId}.md
+
+Important: emit each finding as soon as you find it. Do not batch or wait until the end.`;
   }
   buildRefactorPlannerTask() {
     const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
     const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
 ${f.content}`).join("\n\n");
     return `You are RefactorPlanner. Plan refactorings for the following files.
@@ -13648,26 +14321,146 @@ ${f.content}`).join("\n\n");
 Target files:
 ${fileContents}
 
-Listen for bug.found events from BugHunter on the fleet bus. For each bug, create a refactor plan and write one JSON line per plan:
-{ "plan": { "id": "<uuid>", "basedOnBugIds": ["<bug-id>"], "phases": [...], "riskScore": "<low|medium|high>", "estimatedChangeCount": <n>, "rollbackStrategy": "<text>" } }.
-After planning, write your full markdown plan to:
-${scratchpad}/refactor-plan-${this.sessionId}.md`;
+Read the BugHunter report at: ${bugHunterReportPath}
+
+For each bug you can address, emit a refactor plan using fleet_emit:
+{ "type": "refactor.plan", "payload": { "plan": { "id": "<uuid>", "basedOnBugIds": ["<bug-id>"], "phases": [{ "number": 1, "title": "<phase>", "tasks": ["<task>"], "risk": "<low|medium|high>" }], "riskScore": "<low|medium|high>", "estimatedChangeCount": <n>, "rollbackStrategy": "<text>" } } }
+
+Also write your full markdown plan to:
+${scratchpad}/refactor-plan-${this.sessionId}.md
+
+Emit each plan immediately. Do not wait until planning is complete.`;
   }
   buildCriticTask() {
     const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
+    const refactorPlanPath = `${scratchpad}/refactor-plan-${this.sessionId}.md`;
     const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
 ${f.content}`).join("\n\n");
-    return `You are Critic. Evaluate bug findings and refactor plans as they arrive via fleet bus events.
+    return `You are Critic. Evaluate bug findings and refactor plans.
 
 Target files:
 ${fileContents}
 
-Subscribe to bug.found events (from BugHunter) and refactor.plan events (from RefactorPlanner). For each subject, write one JSON line per evaluation:
-{ "evaluation": { "id": "<uuid>", "subjectType": "<bug_finding|refactor_plan>", "subjectId": "<id>", "score": <0-10>, "verdict": "<approve|needs_revision|reject>", "strengths": [...], "weaknesses": [...], "concerns": [...] } }.
-After all evaluations, write your markdown critic report to:
-${scratchpad}/critic-report-${this.sessionId}.md`;
+Read the BugHunter report at: ${bugHunterReportPath}
+Read the RefactorPlanner report at: ${refactorPlanPath}
+
+For each bug and refactor plan, emit your evaluation using fleet_emit:
+{ "type": "critic.evaluation", "payload": { "evaluation": { "id": "<uuid>", "subjectType": "<bug_finding|refactor_plan>", "subjectId": "<id>", "score": <0-10>, "verdict": "<approve|needs_revision|reject>", "strengths": ["<strength>"], "weaknesses": ["<weakness>"], "concerns": [{ "description": "<concern>", "severity": "<blocking|advisory>" }] } } }
+
+After all evaluations, write your markdown report to:
+${scratchpad}/critic-report-${this.sessionId}.md
+
+Emit each evaluation immediately. Do not wait until you have read all reports.`;
   }
   wireFleetBus() {
+    const dTool = this.fleetBus.filter("tool.executed", (e) => {
+      this.progressBySubagent.set(e.subagentId, (this.progressBySubagent.get(e.subagentId) ?? 0) + 1);
+    });
+    this.disposers.push(dTool);
+    const dBudget = this.fleetBus.filter("budget.threshold_reached", (e) => {
+      const payload = e.payload;
+      const role = this.roleFromSubagentId(e.subagentId);
+      if (!role) return;
+      const btwNotes = this.director.getLeaderBtwNotes();
+      const alert = {
+        sessionId: this.sessionId,
+        subagentId: e.subagentId,
+        role,
+        level: "warning" /* WARNING */,
+        message: `${role} hit ${payload.kind} soft limit (${payload.used}/${payload.limit})`,
+        budgetKind: payload.kind,
+        elapsedMs: payload.timeoutMs,
+        limit: payload.limit,
+        btwNotes
+      };
+      this.alerts.push(alert);
+      this.fleetBus.emit({
+        subagentId: e.subagentId,
+        ts: Date.now(),
+        type: "collab.warning",
+        payload: alert
+      });
+      const decision = this.options.onBudgetWarning?.(alert) ?? "ignore";
+      if (decision === "cancel") {
+        this.cancel(`Director cancelled: ${role} ${payload.kind} threshold`);
+        return;
+      }
+      if (payload.kind === "timeout") {
+        const progress = this.progressBySubagent.get(e.subagentId) ?? 0;
+        const lastProgress = this.lastTimeoutProgress.get(e.subagentId) ?? -1;
+        if (progress <= lastProgress) {
+          payload.deny();
+          return;
+        }
+        this.lastTimeoutProgress.set(e.subagentId, progress);
+        const newLimit = Math.min(Math.ceil((payload.timeoutMs ?? payload.limit) * 2), 24 * 60 * 6e4);
+        setImmediate(() => {
+          payload.extend({ timeoutMs: newLimit });
+        });
+        return;
+      }
+      if (decision === "extend") {
+        setImmediate(() => {
+          const base = Math.max(payload.limit, payload.used);
+          const extra = {};
+          switch (payload.kind) {
+            case "iterations":
+              extra.maxIterations = Math.min(Math.ceil(base * 1.5), 5e4);
+              break;
+            case "tool_calls":
+              extra.maxToolCalls = Math.min(Math.ceil(base * 1.5), 1e5);
+              break;
+            case "tokens":
+              extra.maxTokens = Math.min(Math.ceil(base * 1.5), 5e6);
+              break;
+            case "cost":
+              extra.maxCostUsd = Math.min(base * 1.5, 100);
+              break;
+          }
+          payload.extend(extra);
+        });
+        return;
+      }
+      if (payload.kind !== "timeout") {
+        setImmediate(() => {
+          const base = Math.max(payload.limit, payload.used);
+          const extra = {};
+          switch (payload.kind) {
+            case "iterations":
+              extra.maxIterations = Math.min(Math.ceil(base * 1.25), 5e4);
+              break;
+            case "tool_calls":
+              extra.maxToolCalls = Math.min(Math.ceil(base * 1.25), 1e5);
+              break;
+            case "tokens":
+              extra.maxTokens = Math.min(Math.ceil(base * 1.25), 5e6);
+              break;
+            case "cost":
+              extra.maxCostUsd = Math.min(base * 1.25, 100);
+              break;
+          }
+          payload.extend(extra);
+        });
+      }
+    });
+    this.disposers.push(dBudget);
+    const dCancel = this.fleetBus.filter("director.cancel_collab", (e) => {
+      const payload = e.payload;
+      if (payload.sessionId !== this.sessionId) return;
+      this.cancelled = true;
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = void 0;
+      }
+      this.fleetBus.emit({
+        subagentId: this.director.id,
+        ts: Date.now(),
+        type: "collab.cancelled",
+        payload: { sessionId: this.sessionId, reason: payload.reason }
+      });
+    });
+    this.disposers.push(dCancel);
     const d1 = this.fleetBus.filter("bug.found", (e) => {
       const payload = e.payload;
       if (payload?.finding) {
@@ -13693,10 +14486,19 @@ ${scratchpad}/critic-report-${this.sessionId}.md`;
     });
     this.disposers.push(d3);
   }
+  roleFromSubagentId(subagentId) {
+    for (const [role, id] of this.subagentIds) {
+      if (id === subagentId) return role;
+    }
+    const match = subagentId.match(/^(bug-hunter|refactor-planner|critic)/);
+    return match?.[1] ?? null;
+  }
   assembleReport() {
     const bugList = Array.from(this.bugs.values());
     const planList = Array.from(this.plans.values());
     const evalList = Array.from(this.evaluations.values());
+    let disposition = "completed";
+    if (this.cancelled) disposition = "cancelled";
     const verdictOrder = {
       approve: 0,
       needs_revision: 1,
@@ -13710,33 +14512,41 @@ ${scratchpad}/critic-report-${this.sessionId}.md`;
       },
       "approve"
     );
-    const summary = this.buildMarkdownSummary(bugList, planList, evalList, overallVerdict);
+    const summary = this.buildMarkdownSummary(bugList, planList, evalList, overallVerdict, disposition);
     return {
       sessionId: this.sessionId,
       startedAt: this.snapshot.createdAt,
       completedAt: (/* @__PURE__ */ new Date()).toISOString(),
       targetPaths: this.options.targetPaths,
+      disposition,
       bugs: bugList,
       refactorPlans: planList,
       evaluations: evalList,
+      alerts: [...this.alerts],
       overallVerdict,
       summary
     };
   }
-  buildMarkdownSummary(bugs, plans, evals, overallVerdict) {
+  buildMarkdownSummary(bugs, plans, evals, overallVerdict, disposition) {
     const lines = [
       `## Collaborative Debugging Report \u2014 ${this.sessionId}`,
       "",
       `**Target:** ${this.options.targetPaths.join(", ")}`,
+      `**Disposition:** ${disposition.toUpperCase()}`,
       `**Overall Verdict:** **${overallVerdict.toUpperCase()}**`,
       ""
     ];
+    if (this.alerts.length > 0) {
+      lines.push("### Alerts", "");
+      for (const alert of this.alerts) {
+        lines.push(`- **[${alert.level.toUpperCase()}]** ${alert.role}: ${alert.message}`);
+      }
+      lines.push("");
+    }
     if (bugs.length > 0) {
       lines.push("### Bugs Found", "");
       for (const b of bugs) {
-        lines.push(
-          `- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`
-        );
+        lines.push(`- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`);
       }
       lines.push("");
     }
@@ -13755,9 +14565,7 @@ ${scratchpad}/critic-report-${this.sessionId}.md`;
       for (const e of evals) {
         lines.push(`- [${e.subjectType}] score=${e.score}/10 \u2014 **${e.verdict.toUpperCase()}**`);
         for (const c of e.concerns) {
-          if (c.severity === "blocking") {
-            lines.push(`  - ${c.description}`);
-          }
+          if (c.severity === "blocking") lines.push(`  - ${c.description}`);
         }
       }
       lines.push("");
@@ -13775,10 +14583,9 @@ var FleetSpawnBudgetError = class extends Error {
   kind;
   limit;
   observed;
-  constructor(kind, limit, observed) {
-    super(
-      kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`
-    );
+  constructor(kind, limit, observed, message) {
+    const defaultMsg = kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`;
+    super(message ?? defaultMsg);
     this.name = "FleetSpawnBudgetError";
     this.kind = kind;
     this.limit = limit;
@@ -13799,6 +14606,20 @@ var FleetCostCapError = class extends Error {
     this.observed = observed;
   }
 };
+var FleetContextOverflowError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Leader context overflow: leader has ${observed} tokens in flight (limit: ${limit}). Compact the leader context before spawning more subagents.`
+    );
+    this.name = "FleetContextOverflowError";
+    this.kind = "max_context_load";
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
 var Director = class {
   /** Alias for the ICoordinator contract. `id` is retained for backward compatibility. */
   get coordinatorId() {
@@ -13815,6 +14636,25 @@ var Director = class {
    * injected; otherwise own FleetUsageAggregator.
    */
   usage;
+  /**
+   * Update the leader agent's current context pressure (full request tokens:
+   * messages + systemPrompt + toolDefs). The director checks this before every
+   * spawn — if the pressure exceeds `maxLeaderContextLoad * maxContext`,
+   * spawning is refused with a `FleetContextOverflowError`.
+   *
+   * Call this after each leader agent iteration to keep the pressure current.
+   * The compactor's `CompactReport.fullRequestTokensAfter` is a natural source.
+   */
+  setLeaderContextPressure(tokens) {
+    this.leaderContextPressure = tokens;
+    this.fleetManager?.setLeaderContextPressure(tokens);
+  }
+  /**
+   * Read the leader agent's current context pressure.
+   */
+  getLeaderContextPressure() {
+    return this.leaderContextPressure;
+  }
   /**
    * Optional fleet-level policy container. When provided the Director
    * delegates spawn budgeting, manifest entries, and checkpointing to it
@@ -13900,6 +14740,23 @@ var Director = class {
   taskCompletedListener = null;
   /** Optional LLM classifier for smart dispatch. Passed from options. */
   dispatchClassifier;
+  /** Leader agent's current context pressure (full request tokens). */
+  leaderContextPressure = 0;
+  /** Maximum context load fraction before spawn is refused. */
+  maxLeaderContextLoad;
+  /** Provider's max context window in tokens. */
+  maxContext;
+  /**
+   * When set by `workComplete()`, the director stops dispatching new tasks
+   * and terminates all running subagents. Used when the director's LLM decides
+   * the goal is satisfied and no further spawns are needed — prevents the
+   * coordinator from keeping workers alive for tasks that will never arrive.
+   */
+  workCompleteFlag = false;
+  /** Pending /btw notes stashed by the leader agent (see setLeaderBtwNote). */
+  _leaderBtwNotes = [];
+  /** Active collab sessions tracked by sessionId (see spawnCollab). */
+  _activeCollabSessions = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID();
     this.manifestPath = opts.manifestPath;
@@ -13915,6 +14772,8 @@ var Director = class {
     this.dispatchClassifier = opts.dispatchClassifier;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
     this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
+    this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
+    this.maxContext = opts.maxContext ?? 128e3;
     this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? this.id;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
@@ -13942,7 +14801,7 @@ var Director = class {
       this.fleet = new FleetBus();
       this.usage = new FleetUsageAggregator(
         this.fleet,
-        (id, provider, model) => {
+        (_id, provider, model) => {
           if (provider && model) return this.priceLookups.get(`${provider}/${model}`);
           return void 0;
         },
@@ -14004,6 +14863,9 @@ var Director = class {
     });
     this.fleet.filter("budget.threshold_reached", (e) => {
       const payload = e.payload;
+      if (e.subagentId.startsWith("bug-hunter-") || e.subagentId.startsWith("refactor-planner-") || e.subagentId.startsWith("critic-")) {
+        return;
+      }
       if (payload.kind === "timeout") {
         const progress = progressBySubagent.get(e.subagentId) ?? 0;
         const lastProgress = lastTimeoutProgress.get(e.subagentId) ?? -1;
@@ -14082,6 +14944,107 @@ var Director = class {
   extensionsFor(subagentId) {
     return this.extendTotals.get(subagentId) ?? 0;
   }
+  /**
+   * Signal that the director's work is done. Once called:
+   * - `spawn()` throws `FleetSpawnBudgetError('max_spawns', …)` — no new
+   *   subagents can be created
+   * - Running subagents are NOT forcibly stopped — they finish naturally,
+   *   but no new tasks are dispatched to them
+   *
+   * This lets the director LLM say "I'm satisfied with the results, stop
+   * spawning and wind down" — without killing in-flight work mid-execution.
+   * Call `terminateAll()` separately if you need immediate teardown.
+   *
+   * Idempotent — calling twice is a no-op.
+   */
+  workComplete() {
+    this.workCompleteFlag = true;
+    this.fleet.emit({ subagentId: this.id, ts: Date.now(), type: "director.work_complete", payload: {} });
+  }
+  /** Returns true if `workComplete()` has been called on this director. */
+  isWorkComplete() {
+    return this.workCompleteFlag;
+  }
+  /**
+   * Stashes a /btw note on the leader agent's context. The leader's agent loop
+   * calls `consumeBtwNotes()` at each iteration boundary and folds pending notes
+   * into the conversation as a visible block — no abort, no restart, just a
+   * "by the way" nudge the model picks up on its next turn.
+   *
+   * This is the entry point for the host (CLI, TUI) to inject /btw notes
+   * programmatically without going through the slash-command path.
+   */
+  setLeaderBtwNote(note) {
+    const trimmed = note.trim();
+    if (!trimmed) return this._leaderBtwNotes.length;
+    this._leaderBtwNotes = [...this._leaderBtwNotes, trimmed].slice(-20);
+    return this._leaderBtwNotes.length;
+  }
+  /**
+   * Read and clear all pending /btw notes the leader has stashed.
+   * Returns them in FIFO order (empty array when none).
+   *
+   * Called by CollabSession when a budget threshold event fires so the
+   * Director can inspect accumulated /btw notes before deciding whether
+   * to cancel the collab session or let it continue.
+   */
+  getLeaderBtwNotes() {
+    const notes = this._leaderBtwNotes;
+    this._leaderBtwNotes = [];
+    return notes;
+  }
+  /**
+   * Peek at pending /btw notes without consuming them.
+   * Useful for UI to show "N pending notes" without clearing them.
+   */
+  peekLeaderBtwNotes() {
+    return [...this._leaderBtwNotes];
+  }
+  /**
+   * Drain (read + clear) all /btw notes in one call.
+   * Alias for getLeaderBtwNotes() — kept for symmetry with consumeBtwNotes()
+   * in the agent's btw.ts. The Director calls this at the point where it
+   * makes a cancellation decision, not on every budget event.
+   */
+  drainLeaderBtwNotes() {
+    return this.getLeaderBtwNotes();
+  }
+  /**
+   * Cancel an active collab session by its id.
+   * Emits `director.cancel_collab` on the FleetBus so the session's agents
+   * finish early with a 'cancelled' disposition.
+   *
+   * Returns silently if the session id is not tracked or already settled.
+   * The CollabDebugReport will reflect 'cancelled' disposition when awaited.
+   */
+  cancelCollabSession(sessionId, reason = "Director cancelled") {
+    const session = this._activeCollabSessions.get(sessionId);
+    if (!session || session.isCancelled()) return;
+    session.cancel(reason);
+    for (const [_role, subagentId] of session.getSubagentIds()) {
+      this.coordinator.stop(subagentId).catch(() => {
+      });
+    }
+  }
+  /**
+   * Subscribe a callback to be notified whenever a collab session raises
+   * an alert (warning level). The callback receives the full DirectorAlert
+   * payload so the host (CLI, TUI) can display it to the user.
+   * Returns an unsubscribe function.
+   */
+  onCollabAlert(handler) {
+    return this.fleet.filter("collab.warning", (e) => {
+      handler(e.payload);
+    });
+  }
+  /**
+   * Returns all active (not yet settled) collab session ids.
+   * Useful for the TUI to render a "N active sessions" badge and for
+   * the host to know what can be cancelled.
+   */
+  activeCollabSessions() {
+    return Array.from(this._activeCollabSessions.keys());
+  }
   /** Best-effort session-writer append. Swallows failures — the director
    *  must not break a fleet run because the session JSONL handle closed. */
   async appendSessionEvent(event) {
@@ -14120,12 +15083,21 @@ var Director = class {
    * it the `cost` column in `usage.snapshot()` stays at 0.
    */
   async spawn(config, priceLookup) {
+    if (this.workCompleteFlag) {
+      throw new FleetSpawnBudgetError(
+        "max_spawns",
+        this.maxSpawns,
+        this.spawnCount + 1,
+        "workComplete() has been called \u2014 director closed further spawning"
+      );
+    }
     if (this.fleetManager) {
       const rejection = this.fleetManager.canSpawn(config);
       if (rejection) {
         if (rejection.kind === "max_spawn_depth") throw new FleetSpawnBudgetError("max_spawn_depth", rejection.limit, rejection.observed);
         if (rejection.kind === "max_spawns") throw new FleetSpawnBudgetError("max_spawns", rejection.limit, rejection.observed);
         if (rejection.kind === "max_cost_usd") throw new FleetCostCapError(rejection.limit, rejection.observed);
+        if (rejection.kind === "max_context_load") throw new FleetContextOverflowError(rejection.limit, rejection.observed);
       }
     } else {
       if (this.spawnDepth >= this.maxSpawnDepth) {
@@ -14140,9 +15112,15 @@ var Director = class {
           throw new FleetCostCapError(this.maxFleetCostUsd, totalCost);
         }
       }
+      if (this.maxLeaderContextLoad < 1) {
+        const threshold = this.maxContext * this.maxLeaderContextLoad;
+        if (this.leaderContextPressure >= threshold) {
+          throw new FleetContextOverflowError(threshold, this.leaderContextPressure);
+        }
+      }
     }
     let result;
-    const needsNickname = config.name === config.role || !config.name || config.name === "subagent";
+    const needsNickname = config.name === config.role || !config.name || config.name === "subagent" || config.name === "adhoc";
     if (needsNickname) {
       const role = config.role ?? "subagent";
       if (this.fleetManager) {
@@ -14367,6 +15345,24 @@ var Director = class {
    */
   async assign(task) {
     const taskWithId = task.id ? task : { ...task, id: randomUUID() };
+    if (this.workCompleteFlag) {
+      const synthetic = {
+        subagentId: taskWithId.subagentId ?? "unassigned",
+        taskId: taskWithId.id,
+        status: "stopped",
+        error: { kind: "aborted_by_parent", message: "Director called workComplete() \u2014 no further tasks will run", retryable: false },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      };
+      this.completed.set(taskWithId.id, synthetic);
+      const waiter = this.taskWaiters.get(taskWithId.id);
+      if (waiter) {
+        waiter.resolve(synthetic);
+        this.taskWaiters.delete(taskWithId.id);
+      }
+      return taskWithId.id;
+    }
     if (task.subagentId) {
       if (this.fleetManager) {
         this.fleetManager.addTaskToSubagent(task.subagentId, taskWithId.id);
@@ -14589,12 +15585,14 @@ var Director = class {
       makeAskTool(this),
       makeRollUpTool(this),
       makeTerminateTool(this),
+      makeTerminateAllTool(this),
       makeFleetStatusTool(this),
       makeFleetUsageTool(this),
       makeFleetSessionTool(this),
       makeFleetHealthTool(this),
       makeCollabDebugTool(this),
-      makeFleetEmitTool(this)
+      makeFleetEmitTool(this),
+      makeWorkCompleteTool(this)
     ];
     return t2;
   }
@@ -14614,7 +15612,15 @@ var Director = class {
    * three agents complete or the session times out.
    */
   async spawnCollab(options) {
-    const session = new CollabSession(this, this.fleet, options);
+    const session = new CollabSession(this, this.fleet, {
+      ...options,
+      onBudgetWarning: (alert) => {
+        return options.onBudgetWarning?.(alert) ?? "ignore";
+      }
+    });
+    this._activeCollabSessions.set(session.sessionId, session);
+    session.on("session.done", () => this._activeCollabSessions.delete(session.sessionId));
+    session.on("session.error", () => this._activeCollabSessions.delete(session.sessionId));
     return session.start();
   }
   /**
@@ -15104,8 +16110,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path6.join(modesDir, entry);
-      const stat9 = await fsp2.stat(filePath);
-      if (!stat9.isFile()) continue;
+      const stat8 = await fsp2.stat(filePath);
+      if (!stat8.isFile()) continue;
       const content = await fsp2.readFile(filePath, "utf8");
       const id = path6.basename(entry, path6.extname(entry));
       modes.push({
@@ -16379,9 +17385,9 @@ var AISpecBuilder = class {
     if (!this.sessionPath) return;
     try {
       const fsp19 = await import('fs/promises');
-      const path31 = await import('path');
+      const path35 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp19.mkdir(path31.dirname(this.sessionPath), { recursive: true });
+      await fsp19.mkdir(path35.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -17033,7 +18039,7 @@ function analyzeCriticalPath(graph) {
     blockedTasks
   };
 }
-function getTransitiveBlocked(graph, taskId, blocksMap) {
+function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
@@ -17049,7 +18055,7 @@ function getTransitiveBlocked(graph, taskId, blocksMap) {
   }
   return visited;
 }
-function computeCriticalPath(graph, topoOrder, blockedByMap) {
+function computeCriticalPath(graph, _topoOrder, blockedByMap) {
   const allIds = Array.from(graph.nodes.keys());
   if (allIds.length === 0) return [];
   const dist = /* @__PURE__ */ new Map();
@@ -17091,15 +18097,15 @@ function computeCriticalPath(graph, topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path31 = [];
+  const path35 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path31.unshift(current);
+    path35.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path31;
+  return path35;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -17467,13 +18473,11 @@ function createAutoExecutor(opts) {
 
 // src/sdd/sdd-task-decomposer.ts
 var SddTaskDecomposer = class {
-  constructor(tracker, graph, opts = {}) {
+  constructor(tracker, _graph, opts = {}) {
     this.tracker = tracker;
-    this.graph = graph;
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
   }
   tracker;
-  graph;
   slots;
   wave = 0;
   // -------------------------------------------------------------------
@@ -17626,7 +18630,7 @@ var SddParallelRun = class {
     this.coordinator.setRunner?.(runner);
   }
   defaultFactory() {
-    return async (config) => ({
+    return async (_config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
     });
@@ -18079,7 +19083,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path31 = opts.path ?? "/metrics";
+  const path35 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -18089,7 +19093,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path31) {
+    if (url === path35) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -18153,7 +19157,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path31}`,
+    url: `${protocol}://${host}:${boundPort}${path35}`,
     close: () => new Promise((resolve9, reject) => {
       server.close((err) => err ? reject(err) : resolve9());
     })
@@ -18440,6 +19444,12 @@ function roughEstimate(messages) {
   return total;
 }
 function createContextManagerTool(opts = {}) {
+  const minCompactThreshold = opts.minCompactThreshold ?? 0;
+  const noopRetryDeltaTokens = opts.noopRetryDeltaTokens ?? 2e3;
+  const maxContext = opts.maxContext ?? 128e3;
+  const compactThresholdFraction = opts.compactThresholdFraction ?? 0.5;
+  const effectiveThreshold = minCompactThreshold > 0 ? minCompactThreshold : Math.floor(maxContext * compactThresholdFraction);
+  let lastNoopTokens = 0;
   return {
     name: CONTEXT_MANAGER_TOOL_NAME,
     description: 'Inspect or reorganize the conversation context window. Use "check" to see token budget. Use "summary" to collapse a message range into a concise note (provide "text" for custom summary). Use "prune" to remove specific messages by index. Use "add_note" to inject a summary note. Use "compact" to run aggressive compaction. Use "repair" to remove orphan tool_use/tool_result blocks after manual context surgery.',
@@ -18530,11 +19540,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,
@@ -18775,16 +19815,16 @@ var allServers = () => ({
 function parseSkillRef(input) {
   const trimmed = input.trim().replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
   const atIdx = trimmed.indexOf("@");
-  let refPath;
+  let refPath2;
   let ref;
   if (atIdx > 0) {
-    refPath = trimmed.slice(0, atIdx);
+    refPath2 = trimmed.slice(0, atIdx);
     ref = trimmed.slice(atIdx + 1);
   } else {
-    refPath = trimmed;
+    refPath2 = trimmed;
     ref = "main";
   }
-  const parts = refPath.split("/").filter(Boolean);
+  const parts = refPath2.split("/").filter(Boolean);
   if (parts.length < 2) {
     throw new Error(`Invalid skill reference "${input}". Expected format: user/repo or user/repo@ref`);
   }
@@ -19000,10 +20040,10 @@ var SkillInstaller = class {
           if (!resolved.startsWith(path6.resolve(destDir))) {
             throw new Error(`Path traversal detected in skill file: ${file}`);
           }
-          const stat9 = await fsp2.stat(srcPath);
-          if (stat9.size > MAX_SKILL_FILE_SIZE) {
+          const stat8 = await fsp2.stat(srcPath);
+          if (stat8.size > MAX_SKILL_FILE_SIZE) {
             throw new Error(
-              `Skill file "${file}" is too large (${(stat9.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
+              `Skill file "${file}" is too large (${(stat8.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
             );
           }
           await fsp2.mkdir(path6.dirname(destPath), { recursive: true });
@@ -19042,7 +20082,7 @@ var SkillInstaller = class {
    * - Name: update that specific skill
    * - Name + newRef: update to a different ref
    */
-  async update(nameOrRef, opts) {
+  async update(nameOrRef, _opts) {
     const result = { updated: [], unchanged: [], errors: [] };
     const allEntries = await this.manifest.listAll();
     let targets;
@@ -19121,131 +20161,747 @@ var SkillInstaller = class {
     if (!entry) {
       throw new Error(`Skill "${name}" is not installed${scope === "user" ? " (global)" : ""}.`);
     }
-    await this.removeSkillFiles(name, scope);
-    await this.manifest.removeEntry(name, scope);
-    this.invalidateLoaderCache();
+    await this.removeSkillFiles(name, scope);
+    await this.manifest.removeEntry(name, scope);
+    this.invalidateLoaderCache();
+  }
+  /**
+   * List all installed skills from the manifest.
+   */
+  async listInstalled() {
+    return this.manifest.listAll();
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  /**
+   * Detect skills in an extracted repository.
+   * Returns an array of detected skills with their files.
+   */
+  async detectSkills(baseDir) {
+    const results = [];
+    const rootSkillMd = path6.join(baseDir, "SKILL.md");
+    try {
+      await fsp2.access(rootSkillMd);
+      const content = await fsp2.readFile(rootSkillMd, "utf8");
+      const meta = parseFrontmatter2(content);
+      if (meta.name && meta.description) {
+        results.push({
+          name: meta.name,
+          baseDir,
+          files: ["SKILL.md"]
+        });
+        return results;
+      }
+    } catch {
+    }
+    const skillsDir = path6.join(baseDir, "skills");
+    try {
+      const entries = await fsp2.readdir(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillFile = path6.join(skillsDir, entry.name, "SKILL.md");
+        try {
+          const content = await fsp2.readFile(skillFile, "utf8");
+          const meta = parseFrontmatter2(content);
+          if (meta.name && meta.description) {
+            const skillDir = path6.join(skillsDir, entry.name);
+            const files = await collectFiles(skillDir, skillDir);
+            results.push({
+              name: meta.name,
+              baseDir: skillDir,
+              files
+            });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return results;
+  }
+  /**
+   * Remove all files for an installed skill.
+   */
+  async removeSkillFiles(name, scope) {
+    const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
+    const skillDir = path6.join(targetDir, name);
+    await fsp2.rm(skillDir, { recursive: true, force: true });
+  }
+  /**
+   * Invalidate the skill loader's cache so newly installed skills appear.
+   */
+  invalidateLoaderCache() {
+    const loader = this.opts.skillLoader;
+    if (loader && typeof loader.invalidateCache === "function") {
+      loader.invalidateCache();
+    }
+  }
+};
+function parseFrontmatter2(raw) {
+  if (!raw.startsWith("---")) return {};
+  const end = raw.indexOf("\n---", 4);
+  if (end === -1) return {};
+  const block = raw.slice(4, end);
+  const out = {};
+  let key = null;
+  let value = [];
+  const flush = () => {
+    if (key) {
+      out[key] = value.join("\n").trim();
+    }
+    key = null;
+    value = [];
+  };
+  for (const line of block.split("\n")) {
+    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
+    if (m) {
+      flush();
+      key = m[1] ?? "";
+      const pipe = m[2];
+      const rest = m[3] ?? "";
+      if (pipe === "|") {
+        value = [];
+      } else if (rest) {
+        value = [rest];
+      } else {
+        value = [];
+      }
+    } else if (key) {
+      value.push(line.replace(/^\s+/, ""));
+    }
+  }
+  flush();
+  return out;
+}
+async function collectFiles(dir, baseDir) {
+  const results = [];
+  const entries = await fsp2.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path6.join(dir, entry.name);
+    const relPath = path6.relative(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      results.push(...await collectFiles(fullPath, baseDir));
+    } else {
+      results.push(relPath);
+    }
+  }
+  return results;
+}
+
+// src/storage/annotations-store.ts
+init_atomic_write();
+var FILE_VERSION = 1;
+var MAX_TEXT_LENGTH = 2e3;
+var MAX_ANNOTATIONS = 1e3;
+var AnnotationsStore = class {
+  dir;
+  /** Per-session write queue. Created lazily on first add. */
+  writeChains = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.dir = opts.dir;
+  }
+  // ── Reads ──────────────────────────────────────────────────────────────
+  /**
+   * Return all annotations for `sessionId` in insertion order
+   * (oldest first). Returns an empty array when no file exists
+   * yet (the normal case for a fresh session).
+   */
+  async list(sessionId) {
+    const file = await this.readFile(sessionId);
+    return file ? file.annotations : [];
+  }
+  /**
+   * Convenience: only unresolved annotations, newest first — the
+   * common UI rendering for "what still needs attention?".
+   */
+  async listOpen(sessionId) {
+    const all = await this.list(sessionId);
+    return all.filter((a) => !a.resolved).reverse();
+  }
+  // ── Writes ─────────────────────────────────────────────────────────────
+  /**
+   * Add a new annotation. Returns the persisted record (with id
+   * and timestamps filled in). Throws when `text` is empty or
+   * exceeds `MAX_TEXT_LENGTH`.
+   */
+  async add(input) {
+    const text = input.text.trim();
+    if (text.length === 0) {
+      throw new Error("Annotation text must be non-empty");
+    }
+    if (text.length > MAX_TEXT_LENGTH) {
+      throw new Error(
+        `Annotation text exceeds ${MAX_TEXT_LENGTH} chars (got ${text.length})`
+      );
+    }
+    if (!Number.isInteger(input.atEventIndex) || input.atEventIndex < 0) {
+      throw new Error("atEventIndex must be a non-negative integer");
+    }
+    const annotation = {
+      id: randomUUID(),
+      sessionId: input.sessionId,
+      atEventIndex: input.atEventIndex,
+      authorId: input.authorId,
+      authorRole: "annotator",
+      text,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      resolved: false
+    };
+    await this.enqueue(input.sessionId, async () => {
+      const all = await this.list(input.sessionId);
+      all.push(annotation);
+      if (all.length > MAX_ANNOTATIONS) {
+        const sorted = all.map((a, i) => ({ a, i })).sort((x, y) => {
+          if (x.a.resolved !== y.a.resolved) return x.a.resolved ? 1 : -1;
+          return x.a.createdAt.localeCompare(y.a.createdAt);
+        });
+        const evictCount = all.length - MAX_ANNOTATIONS;
+        const toEvict = new Set(sorted.slice(0, evictCount).map((s) => s.a.id));
+        const kept = all.filter((a) => !toEvict.has(a.id));
+        await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: kept });
+      } else {
+        await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
+      }
+    });
+    return annotation;
+  }
+  /**
+   * Mark an annotation as resolved. Returns the updated record, or
+   * `null` if no annotation with that id exists in this session.
+   * Idempotent: resolving an already-resolved annotation refreshes
+   * `resolvedAt` / `resolvedBy` to the latest call.
+   */
+  async resolve(input) {
+    let updated = null;
+    await this.enqueue(input.sessionId, async () => {
+      const all = await this.list(input.sessionId);
+      const idx = all.findIndex((a) => a.id === input.annotationId);
+      if (idx === -1) {
+        updated = null;
+        return;
+      }
+      const next = {
+        ...all[idx],
+        resolved: true,
+        resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        resolvedBy: input.resolvedBy
+      };
+      all[idx] = next;
+      await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
+      updated = next;
+    });
+    return updated;
+  }
+  // ── Internals ──────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.annotations.json`);
+  }
+  async readFile(sessionId) {
+    const fp = this.filePath(sessionId);
+    try {
+      const raw = await fsp2.readFile(fp, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version !== FILE_VERSION) {
+        return { version: FILE_VERSION, annotations: [] };
+      }
+      return parsed;
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return { version: FILE_VERSION, annotations: [] };
+    }
+  }
+  async writeFile(sessionId, file) {
+    const fp = this.filePath(sessionId);
+    await atomicWrite(fp, JSON.stringify(file, null, 2));
+  }
+  /**
+   * Serialize writes per-sessionId. We chain promises instead of
+   * using a Mutex class so the contract is obvious from the
+   * call-site: `enqueue(sid, fn)` runs `fn` after every prior
+   * enqueue for `sid` has settled.
+   */
+  enqueue(sessionId, fn) {
+    const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.writeChains.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
+  }
+};
+
+// src/storage/replay-log-store.ts
+init_atomic_write();
+function stableStringify(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = sortKeys(obj[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function hashRequest(request) {
+  const payload = {
+    model: request.model,
+    system: request.system,
+    messages: request.messages,
+    tools: request.tools,
+    maxTokens: request.maxTokens,
+    temperature: request.temperature,
+    topP: request.topP,
+    stopSequences: request.stopSequences,
+    toolChoice: request.toolChoice
+  };
+  const json = stableStringify(payload);
+  const digest = createHash("sha256").update(json, "utf8").digest("hex");
+  return `sha256:${digest}`;
+}
+var DEFAULT_MAX_ENTRIES = 1e3;
+var ReplayLogStore = class {
+  dir;
+  writeChains = /* @__PURE__ */ new Map();
+  /** Per-session hash → entry index, kept in memory after the first load. */
+  cache = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+  // ── Writes ──────────────────────────────────────────────────────────────
+  /**
+   * Record a request/response pair. Idempotent on hash: a second
+   * `record` for the same hash is a no-op (the existing entry wins).
+   * Returns the hash.
+   */
+  async record(input) {
+    const hash = hashRequest(input.request);
+    await this.enqueue(input.sessionId, async () => {
+      const cache = await this.ensureCache(input.sessionId);
+      if (cache.has(hash)) return;
+      const entry = {
+        hash,
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        request: input.request,
+        response: input.response
+      };
+      let all = [...cache.values(), entry];
+      if (all.length > this.maxEntries) {
+        const evictCount = all.length - this.maxEntries;
+        all = all.slice(evictCount);
+      }
+      await this.writeAll(input.sessionId, all);
+      cache.clear();
+      for (const e of all) cache.set(e.hash, e);
+    });
+    return hash;
+  }
+  // ── Reads ───────────────────────────────────────────────────────────────
+  /**
+   * Look up an entry by hash. Returns `null` when the request has
+   * not been recorded for this session. O(1) after the first call
+   * per session (in-memory cache).
+   */
+  async lookup(sessionId, hash) {
+    const cache = await this.ensureCache(sessionId);
+    return cache.get(hash) ?? null;
+  }
+  /** All recorded entries for a session, in insertion order. */
+  async load(sessionId) {
+    const cache = await this.ensureCache(sessionId);
+    return [...cache.values()];
+  }
+  /**
+   * List every session id that has a replay log in the store dir.
+   * Returns an array of `{ sessionId, entryCount, path }` sorted
+   * by sessionId for stable output. Used by `wstack replay --list`.
+   */
+  async list() {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
+    }
+    const out = [];
+    for (const name of entries) {
+      if (!name.endsWith(".replay.jsonl")) continue;
+      const sessionId = name.slice(0, -".replay.jsonl".length);
+      const all = await this.load(sessionId);
+      out.push({
+        sessionId,
+        entryCount: all.length,
+        path: path6.join(this.dir, name)
+      });
+    }
+    return out.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+  }
+  // ── Internals ───────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.replay.jsonl`);
+  }
+  async readAll(sessionId) {
+    const fp = this.filePath(sessionId);
+    try {
+      const raw = await fsp2.readFile(fp, "utf8");
+      const out = [];
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if ("entry" in parsed && parsed.entry) {
+            out.push(parsed.entry);
+          } else {
+            out.push(parsed);
+          }
+        } catch {
+        }
+      }
+      return out;
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
+    }
+  }
+  async writeAll(sessionId, entries) {
+    const fp = this.filePath(sessionId);
+    const body = entries.map((e) => JSON.stringify(e)).join("\n") + (entries.length ? "\n" : "");
+    await atomicWrite(fp, body);
+  }
+  async ensureCache(sessionId) {
+    let cache = this.cache.get(sessionId);
+    if (cache) return cache;
+    const all = await this.readAll(sessionId);
+    cache = /* @__PURE__ */ new Map();
+    for (const e of all) cache.set(e.hash, e);
+    this.cache.set(sessionId, cache);
+    return cache;
+  }
+  enqueue(sessionId, fn) {
+    const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.writeChains.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
+  }
+};
+var SessionRecovery = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  /**
+   * Scan a session log and return a `StaleSession` if and only
+   * if the last event is an `in_flight_start` without a matching
+   * `in_flight_end`. Returns `null` when:
+   *   - the log does not exist;
+   *   - the log is empty;
+   *   - the last event is `in_flight_end` (clean shutdown);
+   *   - the last event is something else (e.g. an unannotated
+   *     legacy log without in-flight markers).
+   */
+  async detectStale(sessionId) {
+    const fp = this.filePath(sessionId);
+    let raw;
+    try {
+      raw = await fsp2.readFile(fp, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return null;
+    }
+    return this.parseForStale(sessionId, fp, raw);
+  }
+  /**
+   * Generate a recovery plan for a session. The plan describes
+   * "what would be re-executed" if the user chose to resume —
+   * everything after the last `checkpoint` event, plus the
+   * dangling in-flight marker if present.
+   *
+   * Returns a non-null plan for ANY session that has at least
+   * one event after a checkpoint (or, for legacy sessions, at
+   * least one event). Pure read; no mutation.
+   */
+  async recover(sessionId) {
+    const fp = this.filePath(sessionId);
+    let raw;
+    try {
+      raw = await fsp2.readFile(fp, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return null;
+    }
+    const events = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    if (events.length === 0) return null;
+    let lastCheckpoint = null;
+    let lastCheckpointIdx = -1;
+    for (let i = 0; i < events.length; i++) {
+      if (events[i].type === "checkpoint") {
+        lastCheckpoint = events[i];
+        lastCheckpointIdx = i;
+      }
+    }
+    const pendingEvents = lastCheckpointIdx >= 0 ? events.slice(lastCheckpointIdx + 1) : events;
+    const lastEv = events[events.length - 1];
+    const inFlightStart = lastEv.type === "in_flight_start" ? lastEv : null;
+    const context = inFlightStart && inFlightStart.type === "in_flight_start" ? inFlightStart.context : null;
+    return {
+      sessionId,
+      stale: inFlightStart !== null,
+      lastCheckpoint,
+      pendingEvents,
+      inFlightStart,
+      context
+    };
+  }
+  /**
+   * List every stale session in a directory. Returns an array
+   * (possibly empty) sorted by `lastEventTs` descending — most
+   * recent crash first.
+   */
+  async listResumable() {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
+    }
+    const out = [];
+    for (const name of entries) {
+      if (!name.endsWith(".jsonl")) continue;
+      const sessionId = name.slice(0, -".jsonl".length);
+      if (sessionId.includes(".replay") || sessionId.includes(".annotations")) continue;
+      const stale = await this.detectStale(sessionId);
+      if (stale) out.push(stale);
+    }
+    return out.sort((a, b) => b.lastEventTs.localeCompare(a.lastEventTs));
+  }
+  // ── Internals ──────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.jsonl`);
+  }
+  /**
+   * Stream-parse the last few lines of a JSONL log. We do NOT load
+   * the whole file into memory — for long-running sessions the log
+   * can be megabytes. Instead we read tail-ward and find the last
+   * `in_flight_start` / `in_flight_end` pair.
+   */
+  async parseForStale(sessionId, fp, raw) {
+    const lines = raw.split("\n");
+    let lastEvent = null;
+    let eventCount = 0;
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const ev = JSON.parse(line);
+        lastEvent = ev;
+        eventCount++;
+      } catch {
+      }
+    }
+    if (!lastEvent) return null;
+    if (lastEvent.type === "in_flight_start") {
+      return {
+        sessionId,
+        path: fp,
+        lastEventTs: lastEvent.ts,
+        context: lastEvent.context,
+        eventCount
+      };
+    }
+    return null;
+  }
+};
+
+// src/storage/tool-audit-log.ts
+init_atomic_write();
+var GENESIS_PREV = "0".repeat(64);
+var ToolAuditLog = class {
+  dir;
+  /** In-memory cache of the last entry's hash (per session), to compute chains efficiently. */
+  tailHash = /* @__PURE__ */ new Map();
+  writeChains = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.dir = opts.dir;
   }
   /**
-   * List all installed skills from the manifest.
+   * Append a tool call/result pair to the chain. Returns the
+   * resulting entry. Idempotency is not guaranteed — if you
+   * record the same tool_use twice you get two entries. That's
+   * intentional: the audit log is a record, not a cache.
    */
-  async listInstalled() {
-    return this.manifest.listAll();
+  async record(input) {
+    let entry = null;
+    await this.enqueue(input.sessionId, async () => {
+      const prevHash = this.tailHash.get(input.sessionId) ?? GENESIS_PREV;
+      const id = randomUUID();
+      const ts = (/* @__PURE__ */ new Date()).toISOString();
+      const content = {
+        id,
+        ts,
+        prevHash,
+        toolName: input.toolName,
+        toolUseId: input.toolUseId,
+        input: input.input,
+        output: input.output,
+        isError: input.isError
+      };
+      const hash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
+      entry = {
+        index: this.tailHash.has(input.sessionId) ? -1 : 0,
+        // placeholder; recomputed below
+        id,
+        ts,
+        prevHash,
+        hash,
+        toolName: input.toolName,
+        toolUseId: input.toolUseId,
+        input: input.input,
+        output: input.output,
+        isError: input.isError
+      };
+      const existing = await this.readAll(input.sessionId);
+      const index = existing.length;
+      const finalContent = { ...content, index };
+      const finalHash = createHash("sha256").update(stableStringify2(finalContent), "utf8").digest("hex");
+      entry = { ...entry, index, hash: finalHash };
+      await this.appendLine(input.sessionId, entry);
+      this.tailHash.set(input.sessionId, finalHash);
+    });
+    return entry;
   }
-  // ── Private helpers ──────────────────────────────────────────────
   /**
-   * Detect skills in an extracted repository.
-   * Returns an array of detected skills with their files.
+   * Walk the chain and verify every entry's hash and prevHash.
+   * Returns a structured verdict — never throws.
    */
-  async detectSkills(baseDir) {
-    const results = [];
-    const rootSkillMd = path6.join(baseDir, "SKILL.md");
-    try {
-      await fsp2.access(rootSkillMd);
-      const content = await fsp2.readFile(rootSkillMd, "utf8");
-      const meta = parseFrontmatter2(content);
-      if (meta.name && meta.description) {
-        results.push({
-          name: meta.name,
-          baseDir,
-          files: ["SKILL.md"]
-        });
-        return results;
+  async verify(sessionId) {
+    const entries = await this.readAll(sessionId);
+    if (entries.length === 0) return { ok: true, entries: 0 };
+    if (entries[0].prevHash !== GENESIS_PREV) {
+      return {
+        ok: false,
+        brokenAt: 0,
+        reason: "first entry is not the genesis (prevHash != 0\u20260)"
+      };
+    }
+    let prevHash = GENESIS_PREV;
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      if (e.prevHash !== prevHash) {
+        return {
+          ok: false,
+          brokenAt: i,
+          reason: `prevHash mismatch at entry ${i} (expected ${prevHash.slice(0, 8)}\u2026, got ${e.prevHash.slice(0, 8)}\u2026)`
+        };
       }
-    } catch {
+      const content = {
+        id: e.id,
+        ts: e.ts,
+        prevHash: e.prevHash,
+        toolName: e.toolName,
+        toolUseId: e.toolUseId,
+        input: e.input,
+        output: e.output,
+        isError: e.isError,
+        index: e.index
+      };
+      const expectedHash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
+      if (expectedHash !== e.hash) {
+        return {
+          ok: false,
+          brokenAt: i,
+          reason: `hash mismatch at entry ${i} (entry content was modified)`
+        };
+      }
+      prevHash = e.hash;
     }
-    const skillsDir = path6.join(baseDir, "skills");
+    return { ok: true, entries: entries.length };
+  }
+  /** All entries for a session, in insertion order. */
+  async load(sessionId) {
+    return this.readAll(sessionId);
+  }
+  // ── Internals ────────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.audit.jsonl`);
+  }
+  async readAll(sessionId) {
+    const fp = this.filePath(sessionId);
     try {
-      const entries = await fsp2.readdir(skillsDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const skillFile = path6.join(skillsDir, entry.name, "SKILL.md");
+      const raw = await fsp2.readFile(fp, "utf8");
+      const out = [];
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
         try {
-          const content = await fsp2.readFile(skillFile, "utf8");
-          const meta = parseFrontmatter2(content);
-          if (meta.name && meta.description) {
-            const skillDir = path6.join(skillsDir, entry.name);
-            const files = await collectFiles(skillDir, skillDir);
-            results.push({
-              name: meta.name,
-              baseDir: skillDir,
-              files
-            });
-          }
+          out.push(JSON.parse(line));
         } catch {
         }
       }
-    } catch {
+      return out;
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
     }
-    return results;
   }
-  /**
-   * Remove all files for an installed skill.
-   */
-  async removeSkillFiles(name, scope) {
-    const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
-    const skillDir = path6.join(targetDir, name);
-    await fsp2.rm(skillDir, { recursive: true, force: true });
+  async appendLine(sessionId, entry) {
+    const fp = this.filePath(sessionId);
+    const existing = await this.readAll(sessionId);
+    const all = [...existing, entry];
+    await atomicWrite(fp, all.map((e) => JSON.stringify(e)).join("\n") + (all.length ? "\n" : ""));
   }
-  /**
-   * Invalidate the skill loader's cache so newly installed skills appear.
-   */
-  invalidateLoaderCache() {
-    const loader = this.opts.skillLoader;
-    if (loader && typeof loader.invalidateCache === "function") {
-      loader.invalidateCache();
-    }
+  enqueue(sessionId, fn) {
+    const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.writeChains.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
   }
 };
-function parseFrontmatter2(raw) {
-  if (!raw.startsWith("---")) return {};
-  const end = raw.indexOf("\n---", 4);
-  if (end === -1) return {};
-  const block = raw.slice(4, end);
-  const out = {};
-  let key = null;
-  let value = [];
-  const flush = () => {
-    if (key) {
-      out[key] = value.join("\n").trim();
-    }
-    key = null;
-    value = [];
-  };
-  for (const line of block.split("\n")) {
-    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
-    if (m) {
-      flush();
-      key = m[1] ?? "";
-      const pipe = m[2];
-      const rest = m[3] ?? "";
-      if (pipe === "|") {
-        value = [];
-      } else if (rest) {
-        value = [rest];
-      } else {
-        value = [];
-      }
-    } else if (key) {
-      value.push(line.replace(/^\s+/, ""));
-    }
-  }
-  flush();
-  return out;
+function stableStringify2(value) {
+  return JSON.stringify(sortKeys2(value));
 }
-async function collectFiles(dir, baseDir) {
-  const results = [];
-  const entries = await fsp2.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path6.join(dir, entry.name);
-    const relPath = path6.relative(baseDir, fullPath);
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      results.push(...await collectFiles(fullPath, baseDir));
-    } else {
-      results.push(relPath);
+function sortKeys2(value) {
+  if (Array.isArray(value)) return value.map(sortKeys2);
+  if (value && typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = sortKeys2(obj[key]);
     }
+    return sorted;
   }
-  return results;
+  return value;
 }
 
 // src/storage/session-rewinder.ts
@@ -19421,7 +21077,7 @@ var DefaultPromptStore = class {
   }
   async list() {
     await ensureDir(this.dir);
-    let entries = [];
+    const entries = [];
     try {
       const files = await fsp2.readdir(this.dir);
       for (const file of files) {
@@ -19697,8 +21353,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat9 = await fsp2.stat(localPath);
-        if (stat9.isDirectory()) {
+        const stat8 = await fsp2.stat(localPath);
+        if (stat8.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file, "utf8");
@@ -19723,8 +21379,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat9 = await fsp2.stat(localPath);
-        if (stat9.isDirectory()) {
+        const stat8 = await fsp2.stat(localPath);
+        if (stat8.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file);
@@ -20325,7 +21981,7 @@ var SkillGenerator = class {
     };
     return [commonInjection, ...stackSpecific[stack] ?? []];
   }
-  getConfigPatterns(stack) {
+  getConfigPatterns(_stack) {
     const commonConfig = [
       {
         id: "insecure-tls",
@@ -20907,7 +22563,6 @@ var SecurityScannerOrchestrator = class {
   retryPolicy;
   errorHandler;
   detector = defaultTechStackDetector;
-  reportGenerator = defaultReportGenerator;
   gitignoreUpdater = defaultGitignoreUpdater;
   /**
    * Wraps provider.complete with retry logic using the injected RetryPolicy.
@@ -21091,7 +22746,7 @@ Return ONLY the JSON object, no markdown, no explanation.`;
   /**
    * Scan a batch of files using LLM.
    */
-  async scanFileBatchLLM(provider, model, files, skill, techStack) {
+  async scanFileBatchLLM(provider, model, files, skill, _techStack) {
     const fileContents = [];
     for (const file of files) {
       try {
@@ -21288,7 +22943,7 @@ Be specific about the vulnerabilities found and how to fix them.`;
   /**
    * Gather project info for skill generation.
    */
-  async gatherProjectInfo(projectRoot, techStack) {
+  async gatherProjectInfo(projectRoot, _techStack) {
     const info = [];
     const keyFiles = [
       "package.json",
@@ -21320,7 +22975,7 @@ ${dirs.join(", ")}`);
   /**
    * Gather files to scan based on patterns.
    */
-  async gatherFiles(root, patterns, depth) {
+  async gatherFiles(root, _patterns, depth) {
     const files = [];
     const maxDepth = depth === "quick" ? 2 : depth === "deep" ? 20 : 5;
     const extensions = [".ts", ".js", ".jsx", ".tsx", ".py", ".go", ".java", ".cs", ".rs"];
@@ -21579,22 +23234,22 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = Number.parseInt(reportId, 10) - 1;
     if (!Number.isNaN(index) && reports[index]) {
-      const { readFile: readFile35 } = await import('fs/promises');
-      const content = await readFile35(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile37 } = await import('fs/promises');
+      const content = await readFile37(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile35 } = await import('fs/promises');
-      const content = await readFile35(join(reportsDir, match), "utf-8");
+      const { readFile: readFile37 } = await import('fs/promises');
+      const content = await readFile37(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     return { message: `\u274C Report "${reportId}" not found. Use \`/security report\` to see available reports.` };
-  } catch (error) {
+  } catch (_error) {
     return { message: "\u{1F4ED} No security reports found. Run `/security scan` first." };
   }
 }
@@ -21647,7 +23302,6 @@ var FleetManager = class {
   /** Usage rollup across all subagents. */
   usage;
   manifestPath;
-  sessionsRoot;
   directorRunId;
   /** Spawn cap (lifetime total). Infinity means unlimited. */
   maxSpawns;
@@ -21675,9 +23329,14 @@ var FleetManager = class {
   _usedNicknames = /* @__PURE__ */ new Set();
   /** The coordinator (wired via setCoordinator by Director after construction). */
   coordinator = null;
+  /** Leader agent's current context pressure (full request tokens). */
+  leaderContextPressure = 0;
+  /** Maximum context load fraction before spawn is refused. */
+  maxLeaderContextLoad;
+  /** Provider's max context window in tokens. */
+  maxContext;
   constructor(opts = {}) {
     this.manifestPath = opts.manifestPath;
-    this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? randomUUID();
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
@@ -21685,6 +23344,8 @@ var FleetManager = class {
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
+    this.maxContext = opts.maxContext ?? 128e3;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(
       opts.stateCheckpointPath,
       {
@@ -21699,7 +23360,7 @@ var FleetManager = class {
     this.fleet = new FleetBus();
     this.usage = new FleetUsageAggregator(
       this.fleet,
-      (id, provider, model) => {
+      (_id, provider, model) => {
         if (provider && model) return this.priceLookups.get(`${provider}/${model}`);
         return void 0;
       },
@@ -21738,7 +23399,7 @@ var FleetManager = class {
    * which cap was exceeded. Does NOT throw — the caller decides
    * how to surface the rejection.
    */
-  canSpawn(config) {
+  canSpawn(_config) {
     if (this.spawnDepth >= this.maxSpawnDepth) {
       return { kind: "max_spawn_depth", limit: this.maxSpawnDepth, observed: this.spawnDepth };
     }
@@ -21751,8 +23412,21 @@ var FleetManager = class {
         return { kind: "max_cost_usd", limit: this.maxFleetCostUsd, observed: totalCost };
       }
     }
+    if (this.maxLeaderContextLoad < 1) {
+      const threshold = this.maxContext * this.maxLeaderContextLoad;
+      if (this.leaderContextPressure >= threshold) {
+        return {
+          kind: "max_context_load",
+          limit: threshold,
+          observed: this.leaderContextPressure
+        };
+      }
+    }
     return null;
   }
+  setLeaderContextPressure(tokens) {
+    this.leaderContextPressure = tokens;
+  }
   /**
    * Assign a memorable nickname (e.g. "Einstein (Bug Hunter)") to the config,
    * record it so the same name is never reused, then record the spawn.
@@ -21977,7 +23651,7 @@ function createMcpControlTool(opts) {
     mutating: true,
     riskTier: "standard",
     inputSchema,
-    async execute(raw, ctx) {
+    async execute(raw) {
       const input = raw;
       return mcpControlDispatch(input, { getConfig, configPath, registry });
     }
@@ -22525,7 +24199,6 @@ var Agent = class {
   pipelines;
   ctx;
   maxIterations;
-  iterationTimeoutMs;
   executionStrategy;
   perIterationOutputCapBytes;
   plugins = [];
@@ -22543,7 +24216,6 @@ var Agent = class {
     this.pipelines = init.pipelines;
     this.ctx = init.context;
     this.maxIterations = init.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-    this.iterationTimeoutMs = init.iterationTimeoutMs ?? 3e5;
     this.executionStrategy = init.executionStrategy ?? "smart";
     this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
     this.autoExtendLimit = init.autoExtendLimit ?? true;
@@ -22565,9 +24237,6 @@ var Agent = class {
   get permission() {
     return this.container.resolve(TOKENS.PermissionPolicy);
   }
-  get scrubber() {
-    return this.container.resolve(TOKENS.SecretScrubber);
-  }
   get renderer() {
     return this.container.has(TOKENS.Renderer) ? this.container.resolve(TOKENS.Renderer) : void 0;
   }
@@ -22697,6 +24366,11 @@ var Agent = class {
         if (controller.signal.aborted) {
           return { status: "aborted", iterations };
         }
+        await this.ctx.session.writeInFlightMarker(`iteration ${i} / max ${this.maxIterations}`).catch((err) => {
+          this.logger.debug?.(
+            `in-flight marker write failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
         if (autonomousContinue) {
           consumeAutonomousContinue(this.ctx);
         }
@@ -22715,6 +24389,15 @@ var Agent = class {
         this.events.emit("iteration.started", { ctx: this.ctx, index: i });
         this.injectPendingBtwNotes();
         const req = await this.buildAndRunRequestPipeline(opts);
+        await this.ctx.session.append({
+          type: "llm_request",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          model: req.model,
+          messageCount: req.messages.length,
+          estimatedInputTokens: estimateRequestTokens(req.messages, req.system, req.tools ?? []).total,
+          toolCount: (req.tools ?? []).length
+        }).catch(() => {
+        });
         let res;
         try {
           res = await customRunner(this.ctx, req);
@@ -22778,6 +24461,7 @@ var Agent = class {
         finalText = responseResult.finalText;
         const toolUses = res.content.filter(isToolUseBlock);
         if (toolUses.length === 0) {
+          this.emitContextPct();
           this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
           if (autonomousContinue && responseResult.directive === "continue") {
             await this.compactContextIfNeeded();
@@ -22791,11 +24475,13 @@ var Agent = class {
         }
         await this.executeTools(toolUses);
         if (autonomousContinue && consumeAutonomousContinue(this.ctx)) {
+          this.emitContextPct();
           this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
           await this.compactContextIfNeeded();
           await this.extensions.runAfterIteration(this.ctx, i);
           continue;
         }
+        this.emitContextPct();
         this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
         await this.compactContextIfNeeded();
         await this.extensions.runAfterIteration(this.ctx, i);
@@ -22808,6 +24494,12 @@ var Agent = class {
       }
     } finally {
       offSubagentDone();
+      const reason = controller.signal.aborted ? "aborted" : "clean";
+      await this.ctx.session.clearInFlightMarker(reason).catch((err) => {
+        this.logger.debug?.(
+          `in-flight marker clear failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
     }
   }
   /**
@@ -22915,6 +24607,7 @@ var Agent = class {
       this.executionStrategy
     );
     const useById = new Map(selectedToolUses.map((u) => [u.id, u]));
+    const resultsForMessage = [];
     for (const { result, tool, durationMs } of outputs) {
       if (result.type === "tool_confirm_pending") {
         const decision = await this.waitForConfirm({
@@ -22999,8 +24692,10 @@ var Agent = class {
             });
           }
         }
+        resultsForMessage.push(reRunResult.result);
         continue;
       }
+      resultsForMessage.push(result);
       const use = useById.get(result.tool_use_id);
       if (!use) continue;
       await this.pipelines.toolCall.run({
@@ -23033,7 +24728,7 @@ var Agent = class {
     }
     this.ctx.state.appendMessage({
       role: "user",
-      content: outputs.map((o) => o.result)
+      content: resultsForMessage
     });
     await this.extensions.runAfterToolExecution(this.ctx, outputs);
   }
@@ -23100,6 +24795,19 @@ var Agent = class {
   async compactContextIfNeeded() {
     await this.pipelines.contextWindow.run(this.ctx);
   }
+  /**
+   * Emit the current context window load as a `ctx.pct` event so subscribers
+   * (FleetBus → TUI) can render a live fill bar per agent.
+   */
+  emitContextPct() {
+    const maxContext = this.ctx.provider.capabilities.maxContext ?? 2e5;
+    const { total } = estimateRequestTokens(
+      this.ctx.messages,
+      this.ctx.systemPrompt,
+      this.ctx.tools ?? []
+    );
+    this.events.emit("ctx.pct", { load: total / maxContext, tokens: total, maxContext });
+  }
 };
 function toError(err) {
   return err instanceof Error ? err : new Error(String(err));
@@ -23385,6 +25093,50 @@ var InputBuilder = class {
     this.refs.push(ref);
     return placeholder;
   }
+  /**
+   * Register-only variant of `appendPaste`. Always stores the paste and
+   * returns the inline `[pasted #N, L lines]` token WITHOUT mutating
+   * `display` — the caller (TUI) owns its own editable buffer as the single
+   * source of truth, inserts the token there, and expands the buffer at
+   * submit. The collapse decision is the caller's (it gates this call); use
+   * `wouldCollapse()` for that.
+   */
+  async registerPaste(text) {
+    const ref = await this.store.add({
+      kind: "text",
+      data: text,
+      meta: { label: paragraphLabel(text) }
+    });
+    this.refs.push(ref);
+    const lines = text.split("\n").length;
+    return `[pasted #${ref.seq}, ${lines} lines]`;
+  }
+  /**
+   * Register-only variant of `appendImage` — see `registerPaste`. Returns a
+   * seq-keyed `[image #N, LABEL]` token; does not touch `display`.
+   */
+  async registerImage(dataBase64, mediaType) {
+    const label = `${mediaType.split("/")[1]?.toUpperCase() ?? "IMG"}`;
+    const ref = await this.store.add({
+      kind: "image",
+      data: dataBase64,
+      meta: { mediaType, label }
+    });
+    this.refs.push(ref);
+    return `[image #${ref.seq}, ${label}]`;
+  }
+  /**
+   * Register-only variant of `appendFile` — see `registerPaste`. Returns a
+   * path-keyed `[file:<path>]` token (resolved by path at expand time); does
+   * not touch `display`. The path is read from `meta.filename` (falling back
+   * to `meta.label`).
+   */
+  async registerFile(input) {
+    const ref = await this.store.add({ ...input, kind: "file" });
+    this.refs.push(ref);
+    const path35 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
+    return `[file:${path35}]`;
+  }
   /**
    * Whether `appendPaste(text)` would collapse the text to a placeholder
    * (rather than inlining it). Lets a frontend decide where to route a paste
@@ -23776,8 +25528,8 @@ ${mem}`);
   }
   async dirExists(p) {
     try {
-      const stat9 = await fsp2.stat(p);
-      return stat9.isDirectory();
+      const stat8 = await fsp2.stat(p);
+      return stat8.isDirectory();
     } catch {
       return false;
     }
@@ -23867,6 +25619,14 @@ var ToolRegistry = class _ToolRegistry {
         context: { tool: tool.name }
       });
     }
+    if (!tool.inputSchema || typeof tool.inputSchema !== "object") {
+      throw new WrongStackError({
+        message: `Tool "${tool.name}" has an invalid or missing inputSchema`,
+        code: ERROR_CODES.REGISTRY_INVALID,
+        subsystem: "container",
+        context: { tool: tool.name }
+      });
+    }
     this.tools.set(tool.name, { tool, owner });
   }
   /**
@@ -23876,6 +25636,9 @@ var ToolRegistry = class _ToolRegistry {
    */
   tryRegister(tool, owner = "core") {
     if (this.tools.has(tool.name)) return false;
+    if (!tool.inputSchema || typeof tool.inputSchema !== "object") {
+      return false;
+    }
     this.tools.set(tool.name, { tool, owner });
     return true;
   }
@@ -26113,6 +27876,203 @@ function assertSafePath(dir, projectRoot) {
   }
 }
 
+// src/coordination/collab-bus.ts
+var CollaborationBus = class {
+  pausePromise = null;
+  pauseResolve = null;
+  pausedAtMs = null;
+  pausedBy = null;
+  // ── State queries ──────────────────────────────────────────────────────
+  isPaused() {
+    return this.pausePromise !== null;
+  }
+  getState() {
+    return {
+      paused: this.isPaused(),
+      pausedAt: this.pausedAtMs ? new Date(this.pausedAtMs).toISOString() : null,
+      pausedBy: this.pausedBy
+    };
+  }
+  // ── Pause / resume control ─────────────────────────────────────────────
+  /**
+   * Pause the agent loop. Idempotent: a second `requestPause` while
+   * already paused is a no-op (the original pause wins; we do not
+   * overwrite `pausedBy`). Returns true when the state actually
+   * transitioned, false when it was already paused.
+   */
+  requestPause(byParticipant) {
+    if (this.isPaused()) return false;
+    this.pausedAtMs = Date.now();
+    this.pausedBy = byParticipant;
+    this.pausePromise = new Promise((resolve9) => {
+      this.pauseResolve = resolve9;
+    });
+    return true;
+  }
+  /**
+   * Resume the agent loop. Returns true when the state actually
+   * transitioned from paused → running, false when it was already
+   * running (no-op).
+   */
+  resume() {
+    if (!this.isPaused()) return false;
+    if (this.pauseResolve) this.pauseResolve();
+    this.pausePromise = null;
+    this.pauseResolve = null;
+    this.pausedAtMs = null;
+    this.pausedBy = null;
+    return true;
+  }
+  // ── Wait semantics (consumed by the middleware) ────────────────────────
+  /**
+   * Block until the bus is resumed or the timeout fires. Returns:
+   *   - `true`  → bus was resumed in time
+   *   - `false` → timeout fired; bus was auto-resumed as a side effect
+   *
+   * When `timeoutMs` is `0` the wait is unbounded (the middleware must
+   * be paired with an external AbortSignal in that case — we don't
+   * expose one here to keep the API simple).
+   */
+  async waitForResume(timeoutMs) {
+    if (!this.isPaused()) return true;
+    if (!this.pausePromise) return true;
+    if (timeoutMs === 0) {
+      await this.pausePromise;
+      return true;
+    }
+    let timer;
+    const timeoutPromise = new Promise((resolve9) => {
+      timer = setTimeout(() => resolve9("timeout"), timeoutMs);
+    });
+    const resumedPromise = this.pausePromise.then(() => "resumed");
+    const winner = await Promise.race([resumedPromise, timeoutPromise]);
+    if (timer) clearTimeout(timer);
+    if (winner === "timeout") {
+      this.resume();
+      return false;
+    }
+    return true;
+  }
+  // ── Manual tool-call injection (Phase 4) ─────────────────────────────────
+  //
+  // A controller can ask the agent loop to use a specific tool_result
+  // for a given tool_use_id — bypassing the real tool execution. This
+  // is "I want the agent to think the read returned THIS content" or
+  // "skip the bash call, just give it the answer I typed". The
+  // injection is matched by tool_use_id, consumed once, and discarded.
+  injectionQueue = /* @__PURE__ */ new Map();
+  /**
+   * Queue a manual tool result. The next time the agent's toolCall
+   * pipeline sees a matching `toolUse.id`, the
+   * `collabInjectMiddleware` consumes this entry and replaces the
+   * real tool execution. Returns `false` if an injection for the
+   * same id is already queued (idempotent — first write wins).
+   */
+  injectToolResult(input) {
+    if (this.injectionQueue.has(input.toolUseId)) return false;
+    this.injectionQueue.set(input.toolUseId, input);
+    return true;
+  }
+  /**
+   * Pop an injection from the queue. Returns the payload (and
+   * removes it) if one is pending, or `null` when nothing matches.
+   * Called by the middleware on every tool call.
+   */
+  takeInjection(toolUseId) {
+    const v = this.injectionQueue.get(toolUseId);
+    if (!v) return null;
+    this.injectionQueue.delete(toolUseId);
+    return v;
+  }
+  /** Inspect the queue size (for observability / tests). */
+  pendingInjectionCount() {
+    return this.injectionQueue.size;
+  }
+};
+
+// src/middleware/collab-pause.ts
+function collabPauseMiddleware(bus, opts = {}) {
+  const timeoutMs = opts.defaultTimeoutMs ?? 6e4;
+  const logger = opts.logger;
+  return async function collabPause(payload, next) {
+    if (!bus.isPaused()) {
+      return next();
+    }
+    const state = bus.getState();
+    logger?.debug?.(
+      `collab-pause: tool '${payload.toolUse.name}' blocked \u2014 bus paused by ${state.pausedBy ?? "?"} at ${state.pausedAt ?? "?"}, waiting up to ${timeoutMs}ms for resume`
+    );
+    const resumed = await bus.waitForResume(timeoutMs);
+    if (!resumed) {
+      logger?.warn?.(
+        `collab-pause: timeout after ${timeoutMs}ms \u2014 auto-resuming the bus to unblock the agent loop`
+      );
+    } else {
+      logger?.debug?.(`collab-pause: resumed \u2014 proceeding with tool '${payload.toolUse.name}'`);
+    }
+    return next();
+  };
+}
+function collabInjectMiddleware(bus, opts = {}) {
+  const logger = opts.logger;
+  return async function collabInject(payload, next) {
+    const injected = bus.takeInjection(payload.toolUse.id);
+    if (!injected) {
+      return next();
+    }
+    logger?.debug?.(
+      `collab-inject: tool '${payload.toolUse.name}' (id ${payload.toolUse.id}) \u2014 using controller-injected result (reason: ${injected.reason})`
+    );
+    payload.result = {
+      type: "tool_result",
+      tool_use_id: payload.toolUse.id,
+      content: typeof injected.content === "string" ? injected.content : JSON.stringify(injected.content),
+      is_error: injected.isError
+    };
+  };
+}
+
+// src/replay/replay-provider-runner.ts
+var ReplayProviderRunner = class {
+  constructor(inner, opts) {
+    this.inner = inner;
+    this.opts = opts;
+  }
+  inner;
+  opts;
+  async run(runOpts) {
+    const hash = hashRequest(runOpts.request);
+    const cached = await this.opts.log.lookup(this.opts.sessionId, hash);
+    if (this.opts.mode === "replay") {
+      if (!cached) {
+        this.opts.logger?.warn?.(
+          `replay: no recorded response for hash ${hash} (model ${runOpts.request.model})`
+        );
+        throw new Error(
+          `ReplayProviderRunner: no recorded response for hash ${hash} in session ${this.opts.sessionId}. Either the request changed since recording, or this session has no replay log.`
+        );
+      }
+      this.opts.logger?.debug?.(
+        `replay: served cached response for hash ${hash} (recorded ${cached.ts})`
+      );
+      return cached.response;
+    }
+    if (this.opts.mode === "auto" && cached) {
+      this.opts.logger?.debug?.(
+        `replay: auto-hit hash ${hash}, served cached response`
+      );
+      return cached.response;
+    }
+    const response = await this.inner.run(runOpts);
+    await this.opts.log.record({
+      sessionId: this.opts.sessionId,
+      request: runOpts.request,
+      response
+    });
+    return response;
+  }
+};
+
 // src/plugins/prompts-plugin.ts
 function createPromptsPlugin(opts) {
   let store = null;
@@ -27170,6 +29130,6 @@ ${formatPlan(updated)}`
   };
 }
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CheckpointManager, CloudSync, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSkillsPlugin, createSyncPlugin, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, CheckpointManager, CloudSync, CollaborationBus, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionRecovery, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createSyncPlugin, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, hashRequest, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveAuditLevel, resolveContextWindowPolicy, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map