@wrongstack/core 0.1.4 → 0.1.8

package/dist/index.js

@@ -467,7 +467,8 @@ var TOKENS = {
   SkillLoader: t("SkillLoader"),
   SystemPromptBuilder: t("SystemPromptBuilder"),
   SecretScrubber: t("SecretScrubber"),
-  ModelsRegistry: t("ModelsRegistry")
+  ModelsRegistry: t("ModelsRegistry"),
+  ModeStore: t("ModeStore")
 };
 
 // src/kernel/run-controller.ts
@@ -800,16 +801,33 @@ var DEFAULT_SPEC_TEMPLATE = {
 
 // src/types/task-graph.ts
 function computeTaskProgress(graph) {
-  const nodes = Array.from(graph.nodes.values());
-  const total = nodes.length;
-  const completed = nodes.filter((n) => n.status === "completed").length;
-  const pending = nodes.filter((n) => n.status === "pending").length;
-  const inProgress = nodes.filter((n) => n.status === "in_progress").length;
-  const blocked = nodes.filter((n) => n.status === "blocked").length;
-  const failed = nodes.filter((n) => n.status === "failed").length;
-  const review = nodes.filter((n) => n.status === "review").length;
-  const estimatedHours = nodes.reduce((sum, n) => sum + (n.estimateHours ?? 0), 0);
-  const actualHours = nodes.reduce((sum, n) => sum + (n.actualHours ?? 0), 0);
+  let completed = 0, pending = 0, inProgress = 0, blocked = 0, failed = 0, review = 0;
+  let estimatedHours = 0, actualHours = 0;
+  for (const n of graph.nodes.values()) {
+    switch (n.status) {
+      case "completed":
+        completed++;
+        break;
+      case "pending":
+        pending++;
+        break;
+      case "in_progress":
+        inProgress++;
+        break;
+      case "blocked":
+        blocked++;
+        break;
+      case "failed":
+        failed++;
+        break;
+      case "review":
+        review++;
+        break;
+    }
+    estimatedHours += n.estimateHours ?? 0;
+    actualHours += n.actualHours ?? 0;
+  }
+  const total = graph.nodes.size;
   return {
     total,
     pending,
@@ -836,16 +854,18 @@ function findCriticalPath(graph) {
 }
 function topologicalSort(graph) {
   const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
   const result = [];
   function visit(id) {
+    if (inStack.has(id)) return;
     if (visited.has(id)) return;
+    if (!graph.nodes.has(id)) return;
     visited.add(id);
-    const node = graph.nodes.get(id);
-    if (!node) return;
-    const outgoing = graph.edges.filter((e) => e.from === id);
-    for (const edge of outgoing) {
-      visit(edge.to);
+    inStack.add(id);
+    for (const edge of graph.edges) {
+      if (edge.from === id) visit(edge.to);
     }
+    inStack.delete(id);
     result.push(id);
   }
   for (const rootId of graph.rootNodes) {
@@ -937,7 +957,7 @@ function sanitizeJsonString(s) {
     JSON.parse(out);
     return out;
   } catch {
-    return out;
+    return null;
   }
 }
 function stripSingleLineComments(s) {
@@ -1027,7 +1047,22 @@ function stripAnsi(s) {
 
 // src/utils/glob-match.ts
 function escapeRegex(s) {
-  return s.replace(/[.+^${}()|\\/]/g, "\\$&");
+  return s.replace(/[.+^${}()|\\]/g, "\\$&");
+}
+var COMPILED_GLOB_CACHE = /* @__PURE__ */ new Map();
+var CACHE_MAX_SIZE = 2e3;
+function getCachedGlob(pattern) {
+  const cached = COMPILED_GLOB_CACHE.get(pattern);
+  if (cached) return cached;
+  if (COMPILED_GLOB_CACHE.size >= CACHE_MAX_SIZE) {
+    const keys = [...COMPILED_GLOB_CACHE.keys()];
+    for (let i = 0; i < Math.floor(CACHE_MAX_SIZE / 4); i++) {
+      COMPILED_GLOB_CACHE.delete(keys[i]);
+    }
+  }
+  const re = compileGlob(pattern);
+  COMPILED_GLOB_CACHE.set(pattern, re);
+  return re;
 }
 function compileGlob(pattern) {
   let i = 0;
@@ -1076,7 +1111,7 @@ function compileGlob(pattern) {
   return new RegExp(re);
 }
 function matchGlob(pattern, input) {
-  return compileGlob(pattern).test(input);
+  return getCachedGlob(pattern).test(input);
 }
 function matchAny(patterns, input) {
   return patterns.some((p) => matchGlob(p, input));
@@ -1243,6 +1278,7 @@ function resolveWstackPaths(opts) {
   const projectDir = path2.join(globalRoot, "projects", hash);
   return {
     globalRoot,
+    configDir: globalRoot,
     globalConfig: path2.join(globalRoot, "config.json"),
     secretsKey: path2.join(globalRoot, ".key"),
     globalMemory: path2.join(globalRoot, "memory.md"),
@@ -1301,7 +1337,6 @@ function createToolOutputSerializer(opts = {}) {
     }
     const half = Math.floor(available / 2);
     const first = text.slice(0, half);
-    Buffer.byteLength(first, "utf8");
     const second = text.slice(text.length - half);
     return { text: `${first}${marker}${second}`, newBudget: 0 };
   }
@@ -1310,21 +1345,33 @@ function createToolOutputSerializer(opts = {}) {
 
 // src/utils/token-estimate.ts
 var RoughTokenEstimate = (text) => Math.max(1, Math.ceil(text.length / 4));
+var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
+var ESTIMATE_CACHE_MAX_SIZE = 1e4;
+function getCachedEstimate(key, compute) {
+  const existing = ESTIMATE_CACHE.get(key);
+  if (existing !== void 0) return existing;
+  if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
+    const keys = [...ESTIMATE_CACHE.keys()];
+    for (let i = 0; i < Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4); i++) {
+      ESTIMATE_CACHE.delete(keys[i]);
+    }
+  }
+  const estimate = compute();
+  ESTIMATE_CACHE.set(key, estimate);
+  return estimate;
+}
 function estimateToolInputTokens(input) {
   if (typeof input === "string") return RoughTokenEstimate(input);
-  if (input !== null && typeof input === "object" && "__tokenEstimate" in input) {
-    return input.__tokenEstimate;
+  if (input === null || typeof input !== "object") {
+    return RoughTokenEstimate(String(input));
   }
-  const str = typeof input === "object" ? JSON.stringify(input) : String(input);
-  const estimate = RoughTokenEstimate(str);
-  if (input !== null && typeof input === "object" && !Array.isArray(input)) {
-    input.__tokenEstimate = estimate;
-  }
-  return estimate;
+  const key = JSON.stringify(input);
+  return getCachedEstimate(key, () => RoughTokenEstimate(key));
 }
 function estimateToolResultTokens(content) {
   if (typeof content === "string") return RoughTokenEstimate(content);
-  return RoughTokenEstimate(JSON.stringify(content));
+  const key = JSON.stringify(content);
+  return getCachedEstimate(key, () => RoughTokenEstimate(key));
 }
 function estimateTextTokens(text) {
   return RoughTokenEstimate(text);
@@ -1336,11 +1383,11 @@ function validateAgainstSchema(value, schema) {
   walk(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk(value, schema, path15, errors) {
+function walk(value, schema, path17, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path15 || "<root>",
+        path: path17 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -1349,7 +1396,7 @@ function walk(value, schema, path15, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path15 || "<root>",
+        path: path17 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -1359,19 +1406,19 @@ function walk(value, schema, path15, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path15, req), message: "required property missing" });
+        errors.push({ path: joinPath(path17, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path15, key), errors);
+          walk(obj[key], subSchema, joinPath(path17, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk(item, schema.items, `${path15}[${i}]`, errors));
+    value.forEach((item, i) => walk(item, schema.items, `${path17}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -1567,9 +1614,11 @@ var DefaultPathResolver = class {
   ensureInsideRoot(absPath) {
     const resolved = this.resolve(absPath);
     if (!this.isInsideRoot(resolved)) {
-      throw new Error(
-        `Path "${absPath}" resolves outside the project root (${this.projectRoot})`
-      );
+      const display = path2.isAbsolute(absPath) ? path2.basename(absPath) : absPath;
+      const err = new Error(`Path "${display}" resolves outside the project root`);
+      err.fullPath = absPath;
+      err.projectRoot = this.projectRoot;
+      throw err;
     }
     return resolved;
   }
@@ -1697,7 +1746,9 @@ var DefaultSessionStore = class {
     try {
       handle = await fsp.open(file, "a", 384);
     } catch (err) {
-      throw new Error(`Failed to open session file: ${err instanceof Error ? err.message : String(err)}`);
+      throw new Error(`Failed to open session file: ${err instanceof Error ? err.message : String(err)}`, {
+        cause: err
+      });
     }
     try {
       return new FileSessionWriter(id, handle, startedAt, meta, { dir: this.dir, filePath: file });
@@ -1715,7 +1766,8 @@ var DefaultSessionStore = class {
       handle = await fsp.open(file, "a", 384);
     } catch (err) {
       throw new Error(
-        `Failed to open session "${id}" for append: ${err instanceof Error ? err.message : String(err)}`
+        `Failed to open session "${id}" for append: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
       );
     }
     const writer = new FileSessionWriter(
@@ -1738,7 +1790,10 @@ var DefaultSessionStore = class {
     const events = [];
     for (const line of lines) {
       try {
-        events.push(JSON.parse(line));
+        const parsed = JSON.parse(line);
+        if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+          events.push(parsed);
+        }
       } catch {
       }
     }
@@ -1755,7 +1810,11 @@ var DefaultSessionStore = class {
         ids.map((id) => this.summaryFor(id).catch(() => null))
       );
       const out = sessions.filter((s) => s !== null);
-      out.sort((a, b) => a.startedAt < b.startedAt ? 1 : -1);
+      out.sort((a, b) => {
+        if (a.startedAt < b.startedAt) return 1;
+        if (a.startedAt > b.startedAt) return -1;
+        return a.id.localeCompare(b.id);
+      });
       return out.slice(0, limit);
     } catch {
       return [];
@@ -1901,6 +1960,8 @@ var FileSessionWriter = class {
   filePath;
   initDone = false;
   resumed;
+  appendFailCount = 0;
+  lastAppendWarnAt = 0;
   async writeSessionStart() {
     if (this.initDone || this.closed) return;
     this.initDone = true;
@@ -1929,7 +1990,19 @@ var FileSessionWriter = class {
       await this.handle.appendFile(`${JSON.stringify(event)}
 `, "utf8");
     } catch (err) {
-      console.warn("[session] append failed:", err instanceof Error ? err.message : String(err));
+      this.appendFailCount++;
+      const now = Date.now();
+      if (now - this.lastAppendWarnAt > 5e3) {
+        const suppressed = this.appendFailCount - 1;
+        const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
+        console.warn(
+          "[session] append failed:",
+          err instanceof Error ? err.message : String(err),
+          tail
+        );
+        this.lastAppendWarnAt = now;
+        this.appendFailCount = 0;
+      }
     }
   }
   /**
@@ -2135,6 +2208,15 @@ function mergeAdjacentText(blocks) {
 var MAX_BYTES_TOTAL = 32e3;
 var DefaultMemoryStore = class {
   files;
+  /**
+   * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
+   * `clear` are read-modify-write against a single file; without a lock,
+   * two concurrent calls on the same scope can read the same baseline and
+   * the later write silently drops the earlier entry. We chain each
+   * mutation onto the prior promise for the same scope so they run in
+   * issue order. Different scopes still proceed in parallel.
+   */
+  writeChain = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.files = {
       "project-agents": opts.paths.inProjectAgentsFile,
@@ -2142,6 +2224,18 @@ var DefaultMemoryStore = class {
       "user-memory": opts.paths.globalMemory
     };
   }
+  async runSerialized(scope, work) {
+    const prior = this.writeChain.get(scope) ?? Promise.resolve();
+    const next = prior.catch(() => void 0).then(work);
+    this.writeChain.set(scope, next);
+    try {
+      return await next;
+    } finally {
+      if (this.writeChain.get(scope) === next) {
+        this.writeChain.delete(scope);
+      }
+    }
+  }
   async readAll() {
     const parts = [];
     for (const scope of ["project-agents", "project-memory", "user-memory"]) {
@@ -2160,27 +2254,32 @@ ${body.trim()}`);
     }
   }
   async remember(text, scope = "project-memory") {
-    const file = this.files[scope];
-    await ensureDir(path2.dirname(file));
-    let existing = "";
-    try {
-      existing = await fsp.readFile(file, "utf8");
-    } catch {
-    }
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    const id = `mem_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-    const entry = `
+    return this.runSerialized(scope, async () => {
+      const file = this.files[scope];
+      await ensureDir(path2.dirname(file));
+      let existing = "";
+      try {
+        existing = await fsp.readFile(file, "utf8");
+      } catch {
+      }
+      const ts = (/* @__PURE__ */ new Date()).toISOString();
+      const id = `mem_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+      const entry = `
 - [${ts}] ${id} ${text.replace(/\n/g, " ")}
 `;
-    const next = existing.trim() ? existing.replace(/\n+$/, "") + entry : `# WrongStack Memory
+      const next = existing.trim() ? existing.replace(/\n+$/, "") + entry : `# WrongStack Memory
 ${entry}`;
-    await atomicWrite(file, next);
-    const buf = Buffer.byteLength(next, "utf8");
-    if (buf > MAX_BYTES_TOTAL) {
-      await this.consolidate(scope);
-    }
+      await atomicWrite(file, next);
+      const buf = Buffer.byteLength(next, "utf8");
+      if (buf > MAX_BYTES_TOTAL) {
+        await this.consolidateUnsafe(scope);
+      }
+    });
   }
   async forget(query, scope = "project-memory") {
+    return this.runSerialized(scope, async () => this.forgetUnsafe(query, scope));
+  }
+  async forgetUnsafe(query, scope) {
     const file = this.files[scope];
     let existing;
     try {
@@ -2217,6 +2316,9 @@ ${entry}`;
     return removed;
   }
   async consolidate(scope) {
+    return this.runSerialized(scope, async () => this.consolidateUnsafe(scope));
+  }
+  async consolidateUnsafe(scope) {
     const file = this.files[scope];
     let existing;
     try {
@@ -2247,12 +2349,14 @@ ${entry}`;
   }
   async clear(scope) {
     if (scope) {
-      await atomicWrite(this.files[scope], "");
-    } else {
-      for (const s of ["project-agents", "project-memory", "user-memory"]) {
-        await atomicWrite(this.files[s], "");
-      }
+      await this.runSerialized(scope, async () => atomicWrite(this.files[scope], ""));
+      return;
     }
+    await Promise.all(
+      ["project-agents", "project-memory", "user-memory"].map(
+        (s) => this.runSerialized(s, async () => atomicWrite(this.files[s], ""))
+      )
+    );
   }
 };
 function labelOf(scope) {
@@ -2300,9 +2404,27 @@ var PATTERNS = [
     regex: /\b([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,})['"]?(?!\s*[A-Za-z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))/g
   }
 ];
+var SCRUB_CHUNK_BYTES = 64 * 1024;
 var DefaultSecretScrubber = class {
   scrub(text) {
     if (!text) return text;
+    if (text.length <= SCRUB_CHUNK_BYTES) {
+      return this.scrubOne(text);
+    }
+    const out = [];
+    let i = 0;
+    while (i < text.length) {
+      let end = Math.min(i + SCRUB_CHUNK_BYTES, text.length);
+      if (end < text.length) {
+        const nl = text.lastIndexOf("\n", end);
+        if (nl > i + SCRUB_CHUNK_BYTES / 2) end = nl + 1;
+      }
+      out.push(this.scrubOne(text.slice(i, end)));
+      i = end;
+    }
+    return out.join("");
+  }
+  scrubOne(text) {
     let out = text;
     for (const p of PATTERNS) {
       out = out.replace(p.regex, (_match, group1, group2) => {
@@ -2402,7 +2524,17 @@ var DefaultSecretVault = class {
   }
 };
 function decryptConfigSecrets(cfg, vault) {
-  return walk2(cfg, vault, (v) => vault.decrypt(v));
+  return walk2(cfg, vault, (v, key) => {
+    try {
+      return vault.decrypt(v);
+    } catch (err) {
+      console.warn(
+        `[secret-vault] Failed to decrypt "${key}":`,
+        err instanceof Error ? err.message : err
+      );
+      return "";
+    }
+  });
 }
 function encryptConfigSecrets(cfg, vault) {
   return walk2(cfg, vault, (v) => vault.encrypt(v));
@@ -2416,7 +2548,7 @@ function walk2(node, vault, transform) {
   const out = {};
   for (const [k, v] of Object.entries(node)) {
     if (typeof v === "string" && isSecretField(k)) {
-      out[k] = transform(v);
+      out[k] = transform(v, k);
     } else if (typeof v === "object" && v !== null) {
       out[k] = walk2(v, vault, transform);
     } else {
@@ -2490,9 +2622,11 @@ function walkCount(node, vault, counter) {
   }
   return out;
 }
+var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function deepMerge(a, b) {
   const out = { ...a };
   for (const [k, v] of Object.entries(b)) {
+    if (FORBIDDEN_PROTO_KEYS.has(k)) continue;
     const existing = out[k];
     if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
       out[k] = deepMerge(existing, v);
@@ -2527,7 +2661,7 @@ var DefaultPermissionPolicy = class {
     if (!this.loaded) await this.reload();
     const namespaceEntry = this.findNamespaceEntry(tool.name);
     const entry = this.policy[tool.name] ?? namespaceEntry;
-    const subject = this.subjectFor(tool.name, input);
+    const subject = this.subjectFor(tool.name, input, tool.subjectKey);
     if (entry?.deny && subject && matchAny(entry.deny, subject)) {
       return { permission: "deny", source: "deny", reason: "matched deny pattern" };
     }
@@ -2575,16 +2709,23 @@ var DefaultPermissionPolicy = class {
       throw err;
     }
   }
-  subjectFor(toolName, input) {
+  subjectFor(toolName, input, subjectKey) {
     if (!input || typeof input !== "object") return void 0;
     const obj = input;
     const globChars = /[*?\[\]]/g;
     const escapeGlob = (s) => s.replace(globChars, (c) => `\\${c}`);
+    const normalizePath = (s) => escapeGlob(s.replace(/\\/g, "/"));
+    if (subjectKey) {
+      const v = obj[subjectKey];
+      if (typeof v === "string") {
+        return subjectKey === "path" || subjectKey === "file" || subjectKey === "files" ? normalizePath(v) : escapeGlob(v);
+      }
+    }
     if (toolName === "bash" && typeof obj.command === "string") {
       return escapeGlob(obj.command);
     }
     if (typeof obj.path === "string") {
-      return escapeGlob(obj.path.replace(/\\/g, "/"));
+      return normalizePath(obj.path);
     }
     if (typeof obj.url === "string") {
       return escapeGlob(obj.url);
@@ -2605,14 +2746,15 @@ var DefaultPermissionPolicy = class {
 };
 
 // src/defaults/retry-policy.ts
-var DefaultRetryPolicy = class {
+var DefaultRetryPolicy = class _DefaultRetryPolicy {
+  static NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
   shouldRetry(err, attempt) {
     if (err instanceof ProviderError) {
       if (!err.retryable) return false;
       return attempt < this.maxAttempts(err);
     }
     const msg = err.message ?? "";
-    const isNetwork = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i.test(msg);
+    const isNetwork = _DefaultRetryPolicy.NETWORK_ERR_RE.test(msg);
     if (isNetwork) return attempt < 2;
     return false;
   }
@@ -2634,55 +2776,43 @@ var DefaultRetryPolicy = class {
 };
 
 // src/defaults/error-handler.ts
+var CONTEXT_OVERFLOW_RE = /context|too long|tokens/i;
+var NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
 function buildRecoveryStrategies(opts) {
   return [
     {
       label: "context_overflow_reduce",
       compactor: opts?.compactor,
       async attempt(err, ctx) {
-        if (err instanceof ProviderError && (err.status === 413 || /context|too long|tokens/i.test(err.message))) {
-          if (this.compactor) {
-            try {
-              const report = await this.compactor.compact(ctx, { aggressive: true });
-              if (report.after < report.before) {
-                return {
-                  content: [{ type: "text", text: "[context compacted automatically \u2014 please retry]" }],
-                  stopReason: "end_turn",
-                  usage: { input: 0, output: 0 },
-                  model: ctx.model
-                };
-              }
-            } catch {
+        if (!(err instanceof ProviderError)) return null;
+        if (err.status !== 413 && !CONTEXT_OVERFLOW_RE.test(err.message)) return null;
+        if (this.compactor) {
+          try {
+            const report = await this.compactor.compact(ctx, { aggressive: true });
+            if (report.after < report.before) {
+              return { action: "retry", reason: "context_compacted" };
             }
+          } catch {
           }
-          return null;
         }
         return null;
       }
     },
     {
       label: "rate_limit_backoff",
-      async attempt(err, ctx) {
-        if (err instanceof ProviderError && err.status === 429) {
-          const delayMs = err.body?.retryAfterMs ?? 5e3;
-          const delay = Math.max(1e3, Math.min(delayMs, 6e4));
-          await new Promise((r) => setTimeout(r, delay));
-          return {
-            content: [{ type: "text", text: "[rate limit backoff applied \u2014 please retry]" }],
-            stopReason: "end_turn",
-            usage: { input: 0, output: 0 },
-            model: ctx.model
-          };
-        }
-        return null;
+      async attempt(err) {
+        if (!(err instanceof ProviderError) || err.status !== 429) return null;
+        const delayMs = err.body?.retryAfterMs ?? 5e3;
+        const delay = Math.max(1e3, Math.min(delayMs, 6e4));
+        await new Promise((r) => setTimeout(r, delay));
+        return { action: "retry", reason: "rate_limit_backoff" };
       }
     },
     {
       label: "downgrade_model",
       async attempt(err, ctx) {
-        if (err instanceof ProviderError && (err.status === 429 || err.status === 529 || err.status >= 500)) {
-          return null;
-        }
+        if (!(err instanceof ProviderError)) return null;
+        if (err.status !== 429 && err.status !== 529 && err.status < 500) return null;
         return null;
       }
     }
@@ -2705,12 +2835,12 @@ var DefaultErrorHandler = class {
       if (err.status === 429) return { kind: "rate_limit", retryable: true };
       if (err.status === 529) return { kind: "overloaded", retryable: true };
       if (err.status >= 500) return { kind: "server", retryable: true };
-      if (err.status === 413 || /context|too long|tokens/i.test(err.message)) {
+      if (err.status === 413 || CONTEXT_OVERFLOW_RE.test(err.message)) {
         return { kind: "context_overflow", retryable: false };
       }
       if (err.status >= 400) return { kind: "client", retryable: false };
     }
-    if (err instanceof Error && /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i.test(err.message)) {
+    if (err instanceof Error && NETWORK_ERR_RE.test(err.message)) {
       return { kind: "network", retryable: true };
     }
     return { kind: "unknown", retryable: false };
@@ -2774,13 +2904,28 @@ var DefaultSkillLoader = class {
   async manifestText() {
     const skills = await this.list();
     if (skills.length === 0) return "";
+    const entries = await this.listEntries();
     const lines = ["## Available skills"];
-    for (const s of skills) {
-      lines.push(`- **${s.name}** \u2014 ${s.description.replace(/\n/g, " ").trim()}`);
-      lines.push(`  Path: ${s.path}`);
+    for (const e of entries) {
+      const scopeTag = e.scope.length > 0 ? ` \u2014 ${e.scope.slice(0, 3).join(", ")}` : "";
+      lines.push(`- **${e.name}**${scopeTag}`);
+      lines.push(`  Use when: ${e.trigger}`);
     }
     return lines.join("\n");
   }
+  async listEntries() {
+    const skills = await this.list();
+    const entries = [];
+    for (const s of skills) {
+      try {
+        const raw = await fsp.readFile(s.path, "utf8");
+        const { trigger, scope } = parseDescription(raw);
+        entries.push({ name: s.name, trigger, scope, source: s.source, path: s.path });
+      } catch {
+      }
+    }
+    return entries;
+  }
   async readBody(name) {
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
@@ -2823,6 +2968,19 @@ function parseFrontmatter(raw) {
   flush();
   return out;
 }
+function parseDescription(raw) {
+  const fm = parseFrontmatter(raw);
+  const desc = fm.description ?? "";
+  const firstSentenceEnd = desc.indexOf(". ");
+  const trigger = firstSentenceEnd !== -1 ? desc.slice(0, firstSentenceEnd + 1).trim() : desc.trim().split("\n")[0] ?? "";
+  const scope = [];
+  const coversMatch = /(?:covers|for|including)\s+([^.]+)/i.exec(desc);
+  if (coversMatch) {
+    const items = coversMatch[1].replace(/[·•]/g, ",").split(",").map((s) => s.trim()).filter(Boolean);
+    scope.push(...items);
+  }
+  return { trigger, scope };
+}
 var BEHAVIOR_DEFAULTS = {
   version: 1,
   context: {
@@ -2871,11 +3029,13 @@ var ENV_MAP = {
 function isPrimitiveArray(a) {
   return a.every((v) => v === null || typeof v !== "object");
 }
+var FORBIDDEN_PROTO_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function deepMerge2(base, patch) {
   if (typeof base !== "object" || base === null) return patch ?? base;
   if (typeof patch !== "object" || patch === null) return base;
   const out = { ...base };
   for (const [k, v] of Object.entries(patch)) {
+    if (FORBIDDEN_PROTO_KEYS2.has(k)) continue;
     const existing = out[k];
     if (Array.isArray(v)) {
       if (Array.isArray(existing) && isPrimitiveArray(v) && isPrimitiveArray(existing)) {
@@ -2943,8 +3103,12 @@ var DefaultConfigLoader = class {
     if (cfg.providers) {
       for (const pcfg of Object.values(cfg.providers)) {
         if (!pcfg || typeof pcfg !== "object") continue;
-        const keys = pcfg.apiKeys;
-        if (!Array.isArray(keys) || keys.length === 0) continue;
+        const rawKeys = pcfg.apiKeys;
+        if (!Array.isArray(rawKeys) || rawKeys.length === 0) continue;
+        const keys = rawKeys.filter(
+          (k) => !!k && typeof k === "object" && typeof k.label === "string" && typeof k.apiKey === "string"
+        );
+        if (keys.length === 0) continue;
         const existing = pcfg.apiKey;
         if (existing && existing.length > 0) continue;
         const activeLabel = pcfg.activeKey;
@@ -2955,23 +3119,42 @@ var DefaultConfigLoader = class {
       }
     }
     this.validateBehavior(cfg);
-    if (this.strict) this.validateIdentity(cfg);
+    if (this.strict) {
+      this.validateIdentity(cfg);
+    }
     return Object.freeze(cfg);
   }
   async readJson(file) {
+    let raw;
     try {
-      const raw = await fsp.readFile(file, "utf8");
-      const parsed = safeParse(raw);
-      if (parsed.ok && parsed.value) return parsed.value;
-    } catch {
+      raw = await fsp.readFile(file, "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        console.warn(`[config] Failed to read "${file}":`, err);
+      }
+      return {};
+    }
+    const parsed = safeParse(raw);
+    if (!parsed.ok || !parsed.value) {
+      console.warn(
+        `[config] Failed to parse "${file}": invalid JSON. Falling back to defaults for this layer.`
+      );
+      return {};
     }
-    return {};
+    return parsed.value;
   }
   validateBehavior(cfg) {
     if (cfg.version === void 0) throw new Error("Config: missing version field");
     if (cfg.version !== 1) throw new Error(`Config: unsupported version ${cfg.version}`);
     const c = cfg.context;
     if (!c) throw new Error("Config: missing context section");
+    const fields = ["warnThreshold", "softThreshold", "hardThreshold"];
+    for (const f of fields) {
+      const v = c[f];
+      if (typeof v !== "number" || !Number.isFinite(v)) {
+        throw new Error(`Config: context.${String(f)} must be a finite number (got ${typeof v})`);
+      }
+    }
     if (c.warnThreshold >= c.softThreshold || c.softThreshold >= c.hardThreshold) {
       throw new Error("Config: context thresholds must satisfy warn < soft < hard");
     }
@@ -3019,7 +3202,8 @@ var DefaultConfigStore = class {
     for (const w of this.watchers) {
       try {
         w(next, prev);
-      } catch {
+      } catch (err) {
+        console.error("[config-store] watcher threw:", err);
       }
     }
     return next;
@@ -3129,9 +3313,18 @@ var HybridCompactor = class {
       }
     }
     let saved = 0;
-    for (let i = 0; i < preserveStart; i++) {
+    let changed = false;
+    const nextMessages = new Array(messages.length);
+    for (let i = 0; i < messages.length; i++) {
       const msg = messages[i];
-      if (!msg || !Array.isArray(msg.content)) continue;
+      if (i >= preserveStart) {
+        nextMessages[i] = msg;
+        continue;
+      }
+      if (!msg || !Array.isArray(msg.content)) {
+        nextMessages[i] = msg;
+        continue;
+      }
       const newContent = msg.content.map((b) => {
         if (b.type !== "tool_result") return b;
         const tokens = estimateToolResultTokens(b.content);
@@ -3145,8 +3338,14 @@ var HybridCompactor = class {
         };
         return elided;
       });
-      messages[i] = { ...msg, content: newContent };
+      if (newContent.length === msg.content.length && newContent.every((b, idx) => b === msg.content[idx])) {
+        nextMessages[i] = msg;
+      } else {
+        nextMessages[i] = { ...msg, content: newContent };
+        changed = true;
+      }
     }
+    if (changed) ctx.state.replaceMessages(nextMessages);
     return saved;
   }
   collapseAncientTurns(ctx) {
@@ -3180,10 +3379,10 @@ var HybridCompactor = class {
     let total = 0;
     for (const m of messages) {
       if (typeof m.content === "string") {
-        total += estimateTextTokens(m.content);
+        total += this.estimator(m.content);
       } else {
         for (const b of m.content) {
-          if (b.type === "text") total += estimateTextTokens(b.text);
+          if (b.type === "text") total += this.estimator(b.text);
           else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
           else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
         }
@@ -3223,7 +3422,7 @@ var IntelligentCompactor = class {
     const beforeTokens = this.estimateTokens(ctx.messages);
     const reductions = [];
     const load = beforeTokens / this.maxContext;
-    const aggressive = opts.aggressive ?? load >= this.softThreshold;
+    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 });
     if (aggressive) {
@@ -3332,9 +3531,18 @@ var IntelligentCompactor = class {
       }
     }
     let saved = 0;
-    for (let i = 0; i < preserveStart; i++) {
+    let changed = false;
+    const nextMessages = new Array(messages.length);
+    for (let i = 0; i < messages.length; i++) {
       const msg = messages[i];
-      if (!msg || !Array.isArray(msg.content)) continue;
+      if (i >= preserveStart) {
+        nextMessages[i] = msg;
+        continue;
+      }
+      if (!msg || !Array.isArray(msg.content)) {
+        nextMessages[i] = msg;
+        continue;
+      }
       const newContent = msg.content.map((b) => {
         if (b.type !== "tool_result") return b;
         const tokens = estimateToolResultTokens(b.content);
@@ -3347,8 +3555,14 @@ var IntelligentCompactor = class {
           is_error: b.is_error
         };
       });
-      messages[i] = { ...msg, content: newContent };
+      if (newContent.length === msg.content.length && newContent.every((b, idx) => b === msg.content[idx])) {
+        nextMessages[i] = msg;
+      } else {
+        nextMessages[i] = { ...msg, content: newContent };
+        changed = true;
+      }
     }
+    if (changed) ctx.state.replaceMessages(nextMessages);
     return saved;
   }
   hasTextContent(m) {
@@ -3501,7 +3715,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
     const jsonEnd = raw.lastIndexOf("}");
     if (jsonStart === -1 || jsonEnd === -1) {
       return this.fallbackSelect(
-        Array.from({ length: messageCount }, (_, i) => ({ role: "user", content: "" })),
+        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
         this.maxContextTokens
       );
     }
@@ -3510,7 +3724,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       parsed = JSON.parse(raw.slice(jsonStart, jsonEnd + 1));
     } catch {
       return this.fallbackSelect(
-        Array.from({ length: messageCount }, (_, i) => ({ role: "user", content: "" })),
+        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
         this.maxContextTokens
       );
     }
@@ -3563,7 +3777,7 @@ var SelectiveCompactor = class {
     const savedElision = this.eliseOldToolResults(ctx);
     if (savedElision > 0) reductions.push({ phase: "elision", saved: savedElision });
     const afterPhase1 = this.estimateTokens(ctx.messages);
-    const targetBudget = this.computeTargetBudget(load, opts.aggressive ?? false);
+    const targetBudget = this.computeTargetBudget(load);
     if (afterPhase1 > targetBudget) {
       const savedSelective = await this.runSelector(ctx, targetBudget);
       if (savedSelective > 0) reductions.push({ phase: "selective", saved: savedSelective });
@@ -3581,7 +3795,7 @@ var SelectiveCompactor = class {
     try {
       result = await this.selector.select(ctx.messages, targetBudget);
     } catch {
-      return this.aggressiveRecencyTrim(ctx, targetBudget);
+      return this.aggressiveRecencyTrim(ctx);
     }
     await this.executePlan(ctx, result);
     const after = this.estimateTokens(ctx.messages);
@@ -3636,9 +3850,8 @@ Summarize the following message range:`;
    * Fallback when selector fails: aggressively trim from the oldest end
    * until we hit targetBudget.
    */
-  aggressiveRecencyTrim(ctx, targetBudget) {
+  aggressiveRecencyTrim(ctx) {
     const messages = ctx.messages;
-    this.estimateTokens(messages);
     const preserveIdx = Math.max(0, messages.length - this.preserveK * 2);
     if (preserveIdx <= 0) return 0;
     let boundary = preserveIdx;
@@ -3659,7 +3872,7 @@ Summarize the following message range:`;
     ctx.state.replaceMessages([summaryMsg, ...tail]);
     return Math.max(0, removedTokens - this.estimateTokens([summaryMsg]));
   }
-  computeTargetBudget(load, aggressive) {
+  computeTargetBudget(load) {
     if (load >= this.hardThreshold) {
       return Math.floor(this.maxContext * 0.5);
     }
@@ -3681,9 +3894,18 @@ Summarize the following message range:`;
       }
     }
     let saved = 0;
-    for (let i = 0; i < preserveStart; i++) {
+    let changed = false;
+    const nextMessages = new Array(messages.length);
+    for (let i = 0; i < messages.length; i++) {
       const msg = messages[i];
-      if (!msg || !Array.isArray(msg.content)) continue;
+      if (i >= preserveStart) {
+        nextMessages[i] = msg;
+        continue;
+      }
+      if (!msg || !Array.isArray(msg.content)) {
+        nextMessages[i] = msg;
+        continue;
+      }
       const newContent = msg.content.map((b) => {
         if (b.type !== "tool_result") return b;
         const text = typeof b.content === "string" ? b.content : JSON.stringify(b.content);
@@ -3697,8 +3919,14 @@ Summarize the following message range:`;
           is_error: b.is_error
         };
       });
-      messages[i] = { ...msg, content: newContent };
+      if (newContent.every((b, idx) => b === msg.content[idx])) {
+        nextMessages[i] = msg;
+      } else {
+        nextMessages[i] = { ...msg, content: newContent };
+        changed = true;
+      }
     }
+    if (changed) ctx.state.replaceMessages(nextMessages);
     return saved;
   }
   hasTextContent(m) {
@@ -3734,46 +3962,78 @@ var AutoCompactionMiddleware = class {
   name = "AutoCompaction";
   compactor;
   warnThreshold;
-  // fraction of maxContext (0-1)
   softThreshold;
   hardThreshold;
   maxContext;
   estimator;
   aggressiveOn;
+  events;
+  failureMode;
   /**
-   * @param compactor        Compactor to use for compaction
-   * @param maxContext       Provider's max context window in tokens
-   * @param estimator        Token estimation function (ctx → token count)
-   * @param thresholds      Threshold fractions (0-1) of maxContext
-   * @param aggressiveOn    Which threshold triggers aggressive (full LLM summarization)
+   * @param compactor        Compactor to use for compaction.
+   * @param maxContext       Provider's max context window in tokens.
+   * @param estimator        Token estimation function.
+   * @param thresholds       Threshold fractions (0-1) of maxContext.
+   * @param opts             Optional behavior. By default, failures at the
+   *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
+   *                         the agent does not continue into a likely
+   *                         provider context overflow. Warn/soft failures
+   *                         still emit compaction.failed and continue.
    */
-  constructor(compactor, maxContext, estimator, thresholds, aggressiveOn = "soft") {
+  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.warnThreshold = thresholds.warn;
     this.softThreshold = thresholds.soft;
     this.hardThreshold = thresholds.hard;
-    this.aggressiveOn = aggressiveOn;
+    this.aggressiveOn = opts.aggressiveOn ?? "soft";
+    this.events = opts.events;
+    this.failureMode = opts.failureMode ?? "throw_on_hard";
   }
   handler() {
     return async (ctx, next) => {
       const tokens = this.estimator(ctx);
       const load = tokens / this.maxContext;
       if (load >= this.hardThreshold) {
-        await this.compact(ctx, true);
+        await this.compact(ctx, true, { level: "hard", tokens, load });
       } else if (load >= this.softThreshold) {
-        await this.compact(ctx, this.aggressiveOn !== "hard");
+        await this.compact(ctx, this.aggressiveOn !== "hard", { level: "soft", tokens, load });
       } else if (load >= this.warnThreshold) {
-        await this.compact(ctx, false);
+        await this.compact(ctx, false, { level: "warn", tokens, load });
       }
       return next(ctx);
     };
   }
-  async compact(ctx, aggressive) {
+  async compact(ctx, aggressive, pressure) {
     try {
       await this.compactor.compact(ctx, { aggressive });
-    } catch {
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const fatal = this.failureMode === "throw" || this.failureMode === "throw_on_hard" && pressure.level === "hard";
+      this.events?.emit("compaction.failed", {
+        err: error,
+        aggressive,
+        level: pressure.level,
+        tokens: pressure.tokens,
+        maxContext: this.maxContext,
+        load: pressure.load,
+        fatal
+      });
+      if (fatal) {
+        throw new AgentError({
+          message: `Auto-compaction failed at ${pressure.level} threshold`,
+          code: "AGENT_CONTEXT_OVERFLOW",
+          recoverable: true,
+          context: {
+            level: pressure.level,
+            tokens: pressure.tokens,
+            maxContext: this.maxContext
+          },
+          cause: err
+        });
+      }
     }
   }
 };
@@ -4150,8 +4410,9 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     const context = {
       subagentId: id,
       tasks: [],
-      // parentBridge: wired by the caller via setSubagentBridge() once the
-      // bidirectional bridge is created. Reads gated by hasParentBridge().
+      // 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 ?? 4
@@ -4196,9 +4457,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
   }
   async stopAll() {
-    for (const id of this.subagents.keys()) {
-      await this.stop(id);
-    }
+    await Promise.allSettled([...this.subagents.keys()].map((id) => this.stop(id)));
   }
   getStatus() {
     return {
@@ -4234,7 +4493,17 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       if (!subagentId) return;
       const task = this.pendingTasks.shift();
       if (!task) return;
-      void this.runDispatched(subagentId, task);
+      this.runDispatched(subagentId, task).catch((err) => {
+        this.recordCompletion({
+          subagentId,
+          taskId: task.id,
+          status: "failed",
+          error: err instanceof Error ? err.message : String(err),
+          iterations: 0,
+          toolCalls: 0,
+          durationMs: 0
+        });
+      });
     }
   }
   canDispatch() {
@@ -4254,7 +4523,6 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     subagent.currentTask = task.id;
     task.subagentId = subagentId;
     subagent.context.tasks.push(task);
-    this.inFlight++;
     this.emit("task.assigned", { task, subagentId });
     const budget = new SubagentBudget({
       maxIterations: subagent.config.maxIterations ?? this.config.defaultBudget?.maxIterations,
@@ -4264,6 +4532,10 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       timeoutMs: task.timeoutMs ?? subagent.config.timeoutMs ?? this.config.defaultBudget?.timeoutMs
     });
     subagent.activeBudget = budget;
+    if (!this.runner) {
+      return;
+    }
+    this.inFlight++;
     const startTime = Date.now();
     const runCtx = {
       subagentId,
@@ -4273,9 +4545,6 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       bridge: subagent.context.parentBridge || null
     };
     let result;
-    if (!this.runner) {
-      return;
-    }
     budget.start();
     try {
       const outcome = await this.executeWithTimeout(this.runner, task, runCtx, budget);
@@ -4290,13 +4559,14 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       };
     } catch (err) {
       const status = err instanceof BudgetExceededError && err.kind === "timeout" ? "timeout" : subagent.abortController.signal.aborted ? "stopped" : "failed";
+      const usage = budget.usage();
       result = {
         subagentId,
         taskId: task.id,
         status,
         error: err instanceof Error ? err.message : String(err),
-        iterations: budget.usage().iterations,
-        toolCalls: budget.usage().toolCalls,
+        iterations: usage.iterations,
+        toolCalls: usage.toolCalls,
         durationMs: Date.now() - startTime
       };
     }
@@ -4321,11 +4591,24 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   recordCompletion(result) {
     this.completedResults.push(result);
     this.totalIterations += result.iterations;
-    this.inFlight = Math.max(0, this.inFlight - 1);
+    if (this.inFlight > 0) {
+      this.inFlight--;
+    } else if (this.runner) {
+      this.emit("warning", {
+        type: "inFlight_underflow",
+        taskId: result.taskId,
+        subagentId: result.subagentId
+      });
+      return;
+    }
     const subagent = this.subagents.get(result.subagentId);
     if (subagent && subagent.status !== "stopped") {
-      subagent.status = result.status === "failed" || result.status === "timeout" ? "error" : "idle";
+      const failed = result.status === "failed" || result.status === "timeout";
+      subagent.status = failed ? "error" : "idle";
       subagent.currentTask = void 0;
+      if (subagent.abortController.signal.aborted) {
+        subagent.abortController = new AbortController();
+      }
       if (subagent.status === "error") {
         queueMicrotask(() => {
           if (subagent.status === "error") subagent.status = "idle";
@@ -4427,6 +4710,182 @@ function defaultFormatTaskInput(task) {
   return task.description ?? "";
 }
 
+// src/defaults/fleet-bus.ts
+var FleetBus = class {
+  byId = /* @__PURE__ */ new Map();
+  byType = /* @__PURE__ */ new Map();
+  any = /* @__PURE__ */ new Set();
+  /**
+   * Hook a subagent's EventBus into the fleet. EventBus is strongly
+   * typed and doesn't expose an `onAny` hook, so we subscribe to the
+   * canonical set of event types a subagent emits during a run. New
+   * event types added to the kernel must be added here too — but the
+   * cost is a tiny single line per type, and the explicit list keeps
+   * the wire format clear.
+   *
+   * Returns a disposer that detaches every subscription; call on
+   * subagent teardown so the listeners don't outlive the run.
+   */
+  attach(subagentId, bus, taskId) {
+    const FORWARDED_TYPES = [
+      "tool.started",
+      "tool.executed",
+      "tool.progress",
+      "tool.confirm_needed",
+      "iteration.started",
+      "iteration.completed",
+      "provider.text_delta",
+      "provider.response",
+      "provider.retry",
+      "provider.error",
+      "session.started",
+      "session.ended",
+      "token.threshold"
+    ];
+    const offs = [];
+    for (const t2 of FORWARDED_TYPES) {
+      offs.push(
+        bus.on(t2, (payload) => {
+          this.emit({ subagentId, taskId, ts: Date.now(), type: t2, payload });
+        })
+      );
+    }
+    return () => {
+      for (const off of offs) off();
+    };
+  }
+  /** Subscribe to every event from one subagent. */
+  subscribe(subagentId, handler) {
+    let set = this.byId.get(subagentId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byId.set(subagentId, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  /** Subscribe to one event type across all subagents. */
+  filter(type, handler) {
+    let set = this.byType.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byType.set(type, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  /** Subscribe to literally everything. The fleet roll-up uses this. */
+  onAny(handler) {
+    this.any.add(handler);
+    return () => {
+      this.any.delete(handler);
+    };
+  }
+  emit(event) {
+    const byId = this.byId.get(event.subagentId);
+    if (byId) for (const h of byId) {
+      try {
+        h(event);
+      } catch {
+      }
+    }
+    const byType = this.byType.get(event.type);
+    if (byType) for (const h of byType) {
+      try {
+        h(event);
+      } catch {
+      }
+    }
+    for (const h of this.any) {
+      try {
+        h(event);
+      } catch {
+      }
+    }
+  }
+};
+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();
+  total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  /** Live snapshot — safe to call from a tool's execute() body. */
+  snapshot() {
+    return {
+      total: { ...this.total },
+      perSubagent: Object.fromEntries(
+        Array.from(this.perSubagent.entries()).map(([k, v]) => [k, { ...v }])
+      )
+    };
+  }
+  ensure(subagentId) {
+    let snap = this.perSubagent.get(subagentId);
+    if (!snap) {
+      const meta = this.metaLookup?.(subagentId);
+      snap = {
+        subagentId,
+        provider: meta?.provider,
+        model: meta?.model,
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: 0,
+        toolCalls: 0,
+        iterations: 0,
+        startedAt: Date.now(),
+        lastEventAt: Date.now()
+      };
+      this.perSubagent.set(subagentId, snap);
+    }
+    return snap;
+  }
+  onProviderResponse(e) {
+    const snap = this.ensure(e.subagentId);
+    const p = e.payload;
+    const usage = p?.usage;
+    if (!usage) return;
+    snap.input += usage.input ?? 0;
+    snap.output += usage.output ?? 0;
+    snap.cacheRead += usage.cacheRead ?? 0;
+    snap.cacheWrite += usage.cacheWrite ?? 0;
+    this.total.input += usage.input ?? 0;
+    this.total.output += usage.output ?? 0;
+    this.total.cacheRead += usage.cacheRead ?? 0;
+    this.total.cacheWrite += usage.cacheWrite ?? 0;
+    const price = this.priceLookup?.(e.subagentId);
+    if (price) {
+      const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
+      snap.cost += delta;
+      this.total.cost += delta;
+    }
+    snap.lastEventAt = e.ts;
+  }
+  onToolExecuted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.toolCalls += 1;
+    snap.lastEventAt = e.ts;
+  }
+  onIterationStarted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.iterations += 1;
+    snap.lastEventAt = e.ts;
+  }
+};
+
 // src/defaults/transport/in-memory-transport.ts
 var InMemoryBridgeTransport = class {
   subs = /* @__PURE__ */ new Map();
@@ -4513,6 +4972,11 @@ var InMemoryAgentBridge = class {
     if (this.stopped) throw new Error("Bridge is stopped");
     const timeout = timeoutMs ?? this.timeoutMs;
     const correlationId = msg.id;
+    if (this.pendingRequests.has(correlationId)) {
+      throw new Error(
+        `Bridge request id "${correlationId}" collides with an in-flight request \u2014 caller is reusing message ids`
+      );
+    }
     return new Promise((resolve4, reject) => {
       const timer = setTimeout(() => {
         this.pendingRequests.delete(correlationId);
@@ -4549,12 +5013,686 @@ function createMessage(type, from, payload, to) {
   };
 }
 
+// src/defaults/director-prompts.ts
+var DEFAULT_DIRECTOR_PREAMBLE = `You are the Director of a multi-agent fleet. You orchestrate worker
+subagents by spawning them, assigning tasks, awaiting completions, and
+rolling up their outputs into your next decision.
+
+Core fleet tools available to you:
+  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role
+  - assign_task          \u2014 hand a piece of work to a specific subagent
+  - await_tasks          \u2014 block until named task ids complete (parallel-safe)
+  - ask_subagent         \u2014 synchronously query a running subagent via the bridge
+  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary
+  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)
+  - fleet_status         \u2014 snapshot of all subagents and pending tasks
+  - fleet_usage          \u2014 token + cost breakdown per subagent and total
+
+Working rules:
+  1. Decompose first. Before spawning, decide which sub-tasks are
+     independent and can run in parallel. Sequential work doesn't need a
+     subagent \u2014 do it yourself.
+  2. Match worker to job. Cheap/fast model for triage, capable model for
+     synthesis. Different providers per sibling is allowed and encouraged.
+  3. Always pair an assign with an await. Don't fire-and-forget; you owe
+     the user a single coherent answer at the end.
+  4. Roll up before deciding. After await_tasks resolves, call roll_up so
+     the results are folded back into your context in a compact form.
+  5. Budget is real. Check fleet_usage periodically. If a subagent is
+     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.`;
+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.
+
+Bridge contract:
+  - You have a parent (the Director). You may call \`request\` on the
+    parent bridge to ask a clarifying question. Use this sparingly; the
+    parent is also working.
+  - You MAY NOT request the parent's system prompt, tool list, or other
+    subagents' context. Those are not yours to read.
+  - Your final task output is what the Director sees. Be concise,
+    structured, and self-contained \u2014 assume the Director will paste your
+    output into its own context.`;
+function composeDirectorPrompt(parts = {}) {
+  const sections = [];
+  const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
+  if (preamble && preamble.trim().length > 0) sections.push(preamble.trim());
+  if (parts.rosterSummary && parts.rosterSummary.trim().length > 0) {
+    sections.push(`Available roles you can spawn:
+${parts.rosterSummary.trim()}`);
+  }
+  if (parts.basePrompt && parts.basePrompt.trim().length > 0) {
+    sections.push(parts.basePrompt.trim());
+  }
+  return sections.join("\n\n");
+}
+function composeSubagentPrompt(parts = {}) {
+  const sections = [];
+  const baseline = parts.baseline ?? DEFAULT_SUBAGENT_BASELINE;
+  if (baseline && baseline.trim().length > 0) sections.push(baseline.trim());
+  if (parts.role && parts.role.trim().length > 0) {
+    sections.push(`Role:
+${parts.role.trim()}`);
+  }
+  if (parts.task && parts.task.trim().length > 0) {
+    sections.push(`Task:
+${parts.task.trim()}`);
+  }
+  if (parts.override && parts.override.trim().length > 0) {
+    sections.push(parts.override.trim());
+  }
+  return sections.join("\n\n");
+}
+function rosterSummaryFromConfigs(roster) {
+  const lines = [];
+  for (const [roleId, cfg] of Object.entries(roster)) {
+    const tag = cfg.provider && cfg.model ? ` (${cfg.provider}/${cfg.model})` : "";
+    const headline = cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").trim().slice(0, 80) : "";
+    const tail = headline ? ` \u2014 ${headline}` : "";
+    lines.push(`- ${roleId}: ${cfg.name}${tag}${tail}`);
+  }
+  return lines.join("\n");
+}
+
+// src/defaults/director.ts
+var Director = class {
+  id;
+  fleet;
+  usage;
+  /**
+   * Director-side bridge endpoint. Subagents are wired to the same
+   * in-memory transport so the director can `ask()` them synchronously
+   * and they can `send()` progress back. Exposed so external code (e.g.
+   * the TUI) can subscribe to inbound messages.
+   */
+  bridge;
+  transport;
+  coordinator;
+  /** Resolves with the matching `TaskResult` the first time the
+   *  coordinator emits `task.completed` for a given task id. Each entry
+   *  is created lazily on first poll/await and cleared once consumed. */
+  taskWaiters = /* @__PURE__ */ new Map();
+  /** Cache of completed results in case the consumer asks AFTER the
+   *  coordinator already fired the event — `awaitTasks(['t-1'])` after
+   *  t-1 finished should resolve immediately, not hang. */
+  completed = /* @__PURE__ */ new Map();
+  /** Per-subagent provider/model metadata, captured at spawn time so the
+   *  FleetUsageAggregator's metaLookup can surface readable rows. */
+  subagentMeta = /* @__PURE__ */ new Map();
+  priceLookups = /* @__PURE__ */ new Map();
+  /** Bridge endpoints we created per subagent (so we can `stop()` them
+   *  on shutdown and free transport subscriptions). */
+  subagentBridges = /* @__PURE__ */ new Map();
+  /** Tracks per-spawn config + assigned task ids for manifest writing. */
+  manifestEntries = /* @__PURE__ */ new Map();
+  manifestPath;
+  roster;
+  directorPreamble;
+  subagentBaseline;
+  constructor(opts) {
+    this.id = opts.config.coordinatorId || randomUUID();
+    this.manifestPath = opts.manifestPath;
+    this.roster = opts.roster;
+    this.directorPreamble = opts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
+    this.subagentBaseline = opts.subagentBaseline ?? DEFAULT_SUBAGENT_BASELINE;
+    this.transport = new InMemoryBridgeTransport();
+    this.bridge = new InMemoryAgentBridge(
+      { agentId: this.id, coordinatorId: this.id },
+      this.transport
+    );
+    this.fleet = new FleetBus();
+    this.usage = new FleetUsageAggregator(
+      this.fleet,
+      (id) => this.priceLookups.get(id),
+      (id) => this.subagentMeta.get(id)
+    );
+    this.coordinator = new DefaultMultiAgentCoordinator(
+      { ...opts.config, coordinatorId: this.id },
+      { runner: opts.runner }
+    );
+    this.coordinator.on("task.completed", (payload) => {
+      const r = payload.result;
+      this.completed.set(r.taskId, r);
+      const waiter = this.taskWaiters.get(r.taskId);
+      if (waiter) {
+        waiter.resolve(r);
+        this.taskWaiters.delete(r.taskId);
+      }
+    });
+  }
+  /**
+   * Spawn a subagent. Identical to the coordinator's `spawn()` but
+   * captures provider/model metadata for the usage aggregator and
+   * lets the FleetBus attach to the runner's EventBus when the task
+   * actually runs (see `attachSubagentBus`).
+   *
+   * Caller-supplied `priceLookup` is optional but recommended — without
+   * it the `cost` column in `usage.snapshot()` stays at 0.
+   */
+  async spawn(config, priceLookup) {
+    const result = await this.coordinator.spawn(config);
+    this.subagentMeta.set(result.subagentId, {
+      provider: config.provider,
+      model: config.model
+    });
+    if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+    const subagentBridge = new InMemoryAgentBridge(
+      { agentId: result.subagentId, coordinatorId: this.id },
+      this.transport
+    );
+    this.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
+    this.subagentBridges.set(result.subagentId, subagentBridge);
+    this.manifestEntries.set(result.subagentId, {
+      subagentId: result.subagentId,
+      name: config.name,
+      role: config.role,
+      provider: config.provider,
+      model: config.model,
+      taskIds: []
+    });
+    return result.subagentId;
+  }
+  /**
+   * Synchronously ask a subagent something via the bridge. Sends a
+   * `task` message addressed to the subagent and awaits a matching
+   * reply (matched by message id). Subagent runners that handle these
+   * requests subscribe to `ctx.bridge` and reply with a message whose
+   * `id` equals the incoming request's id (see `InMemoryAgentBridge`'s
+   * `request<T>` implementation).
+   *
+   * Returns the response payload directly (the bridge wrapper is
+   * unwrapped for ergonomics). Times out after `timeoutMs` (default
+   * matches the bridge's own default of 30s) — surface those rejections
+   * to the caller as actionable errors instead of letting tools hang.
+   */
+  async ask(subagentId, payload, timeoutMs) {
+    if (!this.subagentBridges.has(subagentId)) {
+      throw new Error(
+        `ask: unknown subagent "${subagentId}" (spawn() it first; current fleet: ${Array.from(this.subagentBridges.keys()).join(", ") || "(empty)"})`
+      );
+    }
+    const msg = {
+      id: randomUUID(),
+      type: "task",
+      from: this.id,
+      to: subagentId,
+      payload,
+      timestamp: Date.now(),
+      priority: "normal"
+    };
+    const reply = await this.bridge.request(msg, timeoutMs);
+    return reply.payload;
+  }
+  /**
+   * Read completed task results and format them as a structured text
+   * block the director's LLM can paste into its own context. The
+   * Director keeps every completed `TaskResult` in `completed` so this
+   * is a pure read — no bridge round-trip, cheap to call.
+   *
+   * The returned string is intentionally markdown-flavored: headers per
+   * subagent, a one-line meta row (iter / tools / ms), and the task's
+   * result text. Pass `style: 'json'` for a programmatic shape instead
+   * (useful when the director model is doing structured-output work).
+   */
+  rollUp(taskIds, style = "markdown") {
+    const rows = taskIds.map((id) => this.completed.get(id)).filter(
+      (r) => !!r
+    );
+    if (style === "json") {
+      return JSON.stringify(
+        rows.map((r) => ({
+          taskId: r.taskId,
+          subagentId: r.subagentId,
+          status: r.status,
+          iterations: r.iterations,
+          toolCalls: r.toolCalls,
+          durationMs: r.durationMs,
+          result: r.result,
+          error: r.error
+        })),
+        null,
+        2
+      );
+    }
+    if (rows.length === 0) {
+      return "_No completed tasks for the requested ids \u2014 try waiting first._";
+    }
+    const lines = [];
+    for (const r of rows) {
+      const meta = this.subagentMeta.get(r.subagentId);
+      const tag = meta?.provider && meta?.model ? ` \xB7 ${meta.provider}/${meta.model}` : "";
+      lines.push(`### ${r.subagentId}${tag}`);
+      lines.push(
+        `_${r.status} \u2014 ${r.iterations} iter \xB7 ${r.toolCalls} tools \xB7 ${r.durationMs}ms_`
+      );
+      lines.push("");
+      if (r.error) lines.push(`**Error:** ${r.error}`);
+      else if (typeof r.result === "string") lines.push(r.result);
+      else if (r.result !== void 0) lines.push("```json\n" + JSON.stringify(r.result, null, 2) + "\n```");
+      else lines.push("_(no output)_");
+      lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+  }
+  /**
+   * Write the fleet manifest to `manifestPath`. Returns the path written
+   * or null when no path was configured. Captures every spawn + its
+   * assigned tasks — paired with per-subagent JSONLs, this is enough to
+   * replay an entire director run.
+   */
+  async writeManifest() {
+    if (!this.manifestPath) return null;
+    const manifest = {
+      directorRunId: this.id,
+      writtenAt: (/* @__PURE__ */ new Date()).toISOString(),
+      children: Array.from(this.manifestEntries.values()).map((e) => ({
+        ...e,
+        // Surface final status from `completed` when available — manifest
+        // becomes much more useful for replay when it carries the
+        // success/failure state.
+        results: e.taskIds.map((tid) => {
+          const r = this.completed.get(tid);
+          return r ? {
+            taskId: tid,
+            status: r.status,
+            iterations: r.iterations,
+            toolCalls: r.toolCalls,
+            durationMs: r.durationMs
+          } : { taskId: tid, status: "pending" };
+        })
+      })),
+      usage: this.usage.snapshot()
+    };
+    await fsp.mkdir(path2.dirname(this.manifestPath), { recursive: true });
+    await fsp.writeFile(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
+    return this.manifestPath;
+  }
+  /**
+   * Tear down the director: stop every subagent, close every bridge
+   * endpoint, and (when configured) write the final manifest. Idempotent
+   * — calling shutdown twice is a no-op on the second invocation.
+   */
+  async shutdown() {
+    await this.coordinator.stopAll();
+    for (const b of this.subagentBridges.values()) {
+      await b.stop().catch(() => void 0);
+    }
+    this.subagentBridges.clear();
+    await this.bridge.stop().catch(() => void 0);
+    if (this.manifestPath) await this.writeManifest().catch(() => void 0);
+  }
+  /**
+   * Hand a task to the coordinator. Returns the assigned task id so
+   * callers can wait on it via `awaitTasks([id])`. The coordinator's
+   * concurrency limit applies — the task may queue before running.
+   */
+  async assign(task) {
+    const taskWithId = task.id ? task : { ...task, id: randomUUID() };
+    if (task.subagentId) {
+      const entry = this.manifestEntries.get(task.subagentId);
+      if (entry) entry.taskIds.push(taskWithId.id);
+    }
+    await this.coordinator.assign(taskWithId);
+    return taskWithId.id;
+  }
+  /**
+   * Block until every task id resolves. Returns results in the same
+   * order as the input. If any task hasn't completed by the time this
+   * is called, the promise hangs until it does — pair with a timeout
+   * at the caller if that's a concern. Resolves immediately for ids
+   * whose results were already cached.
+   */
+  awaitTasks(taskIds) {
+    return Promise.all(taskIds.map((id) => {
+      const cached = this.completed.get(id);
+      if (cached) return cached;
+      const existing = this.taskWaiters.get(id);
+      if (existing) return existing.promise;
+      let resolve4;
+      const promise = new Promise((res) => {
+        resolve4 = res;
+      });
+      this.taskWaiters.set(id, { promise, resolve: resolve4 });
+      return promise;
+    }));
+  }
+  async terminate(subagentId) {
+    await this.coordinator.stop(subagentId);
+  }
+  async terminateAll() {
+    await this.coordinator.stopAll();
+  }
+  status() {
+    return this.coordinator.getStatus();
+  }
+  /**
+   * Subscribe to coordinator events. Currently only `task.completed` is
+   * exposed (the others are internal lifecycle). Returns an unsubscribe
+   * function. External callers (e.g. the CLI's `MultiAgentHost`) use this
+   * to drive their own pending/results tracking without poking the
+   * coordinator directly.
+   */
+  on(event, handler) {
+    this.coordinator.on(event, handler);
+    return () => {
+      this.coordinator.off(event, handler);
+    };
+  }
+  /**
+   * Snapshot of every task that has resolved (success, failed, timeout,
+   * stopped) since the director started. Returned in completion order
+   * via the internal map's iteration order. Used by `/fleet status` to
+   * paint the completed table without reaching into private state.
+   */
+  completedResults() {
+    return Array.from(this.completed.values());
+  }
+  snapshot() {
+    return this.usage.snapshot();
+  }
+  /**
+   * Compose the leader/director-agent system prompt: fleet preamble +
+   * (optional) roster summary + user base prompt. Pass the result to your
+   * leader Agent's `ctx.systemPrompt` when constructing it.
+   *
+   * `basePrompt` defaults to `config.leaderSystemPrompt` so callers can
+   * use the no-arg form when the multi-agent config already carries it.
+   */
+  leaderSystemPrompt(basePrompt) {
+    return composeDirectorPrompt({
+      basePrompt: basePrompt ?? this.coordinator.config.leaderSystemPrompt,
+      directorPreamble: this.directorPreamble,
+      rosterSummary: this.roster ? rosterSummaryFromConfigs(this.roster) : void 0
+    });
+  }
+  /**
+   * Compose a subagent's system prompt for a given `SubagentConfig`:
+   * baseline + role + task + per-spawn override. Returned by value — does
+   * not mutate the config. Factories (the user-supplied `AgentFactory`)
+   * should call this when building each subagent's Agent so the bridge
+   * contract, role context, and override are all surfaced.
+   *
+   * When `taskBrief` is omitted the Task section is dropped. Pass the
+   * actual task description here to reinforce it in the system prompt
+   * (the runner already passes it as user input — duplicating in the
+   * system prompt is optional but improves anchoring on small models).
+   */
+  subagentSystemPrompt(config, taskBrief) {
+    return composeSubagentPrompt({
+      baseline: this.subagentBaseline,
+      role: config.prompt,
+      task: taskBrief,
+      override: config.systemPromptOverride
+    });
+  }
+  /**
+   * Build the tool set the LLM-driven director uses to orchestrate.
+   * Returns an array of `Tool` definitions; register these on the
+   * director's `Agent` to expose `spawn_subagent`, `assign_task`, etc.
+   * Each tool's `execute()` delegates straight to the matching method
+   * above.
+   *
+   * Tools all carry `permission: 'auto'` — the *user* has already
+   * approved running the director when they kicked off the run, so
+   * gating individual orchestration calls behind a confirm prompt
+   * would just be noise. The actual subagent tools they spawn are
+   * still permission-checked normally.
+   */
+  tools(roster) {
+    const t2 = [
+      makeSpawnTool(this, roster),
+      makeAssignTool(this),
+      makeAwaitTasksTool(this),
+      makeAskTool(this),
+      makeRollUpTool(this),
+      makeTerminateTool(this),
+      makeFleetStatusTool(this),
+      makeFleetUsageTool(this)
+    ];
+    return t2;
+  }
+};
+function makeSpawnTool(director, roster) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      role: { type: "string", description: "Roster role id (preferred). When set, the spawn uses the matching config from the roster and ignores other fields." },
+      name: { type: "string", description: "Display name for the subagent. Required when not using roster." },
+      provider: { type: "string", description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.' },
+      model: { type: "string", description: "Model id within the provider. Defaults to the leader model when omitted." },
+      systemPromptOverride: { type: "string", description: "Extra prompt text appended after the role-base prompt." },
+      maxIterations: { type: "number" },
+      maxToolCalls: { type: "number" },
+      maxCostUsd: { type: "number" }
+    },
+    required: []
+  };
+  return {
+    name: "spawn_subagent",
+    description: "Create a new subagent under this director. Returns the subagent id. Use this when you need a worker with a specific provider, model, or role to handle a piece of the plan.",
+    usageHint: "Either pass `role` (matches the roster) OR pass `name` + optional `provider`/`model`. Returns `{ subagentId }`.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input ?? {};
+      const role = typeof i.role === "string" ? i.role : void 0;
+      const base = role && roster ? roster[role] : void 0;
+      if (role && !base) {
+        return { error: `unknown role "${role}". roster has: ${roster ? Object.keys(roster).join(", ") : "(empty)"}` };
+      }
+      const cfg = {
+        ...base ?? { name: i.name ?? "subagent" }
+      };
+      if (typeof i.name === "string") cfg.name = i.name;
+      if (typeof i.provider === "string") cfg.provider = i.provider;
+      if (typeof i.model === "string") cfg.model = i.model;
+      if (typeof i.systemPromptOverride === "string") cfg.systemPromptOverride = i.systemPromptOverride;
+      if (typeof i.maxIterations === "number") cfg.maxIterations = i.maxIterations;
+      if (typeof i.maxToolCalls === "number") cfg.maxToolCalls = i.maxToolCalls;
+      if (typeof i.maxCostUsd === "number") cfg.maxCostUsd = i.maxCostUsd;
+      const subagentId = await director.spawn(cfg);
+      return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name };
+    }
+  };
+}
+function makeAssignTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: { type: "string", description: "Target subagent id. Required." },
+      description: { type: "string", description: "The task in natural language \u2014 what you want this subagent to do." },
+      maxToolCalls: { type: "number", description: "Optional per-task tool-call budget override." },
+      timeoutMs: { type: "number", description: "Optional per-task timeout in ms." }
+    },
+    required: ["subagentId", "description"]
+  };
+  return {
+    name: "assign_task",
+    description: "Hand a task to a previously spawned subagent. Returns the task id \u2014 pass it to `await_tasks` to block on completion.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const task = {
+        id: randomUUID(),
+        description: i.description,
+        subagentId: i.subagentId,
+        maxToolCalls: i.maxToolCalls,
+        timeoutMs: i.timeoutMs
+      };
+      const taskId = await director.assign(task);
+      return { taskId, subagentId: i.subagentId };
+    }
+  };
+}
+function makeAwaitTasksTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      taskIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "One or more task ids returned by `assign_task`. The call blocks until every id resolves."
+      }
+    },
+    required: ["taskIds"]
+  };
+  return {
+    name: "await_tasks",
+    description: "Block until every named task completes. Returns the array of TaskResult \u2014 use this to gather subagent output before deciding the next step.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const results = await director.awaitTasks(i.taskIds);
+      return { results };
+    }
+  };
+}
+function makeAskTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: { type: "string", description: "Subagent to ask. Must be a previously spawned id." },
+      question: { type: "string", description: "The question or instruction. Sent as the bridge message payload." },
+      timeoutMs: { type: "number", description: "Optional timeout in ms (default 30s)." }
+    },
+    required: ["subagentId", "question"]
+  };
+  return {
+    name: "ask_subagent",
+    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge (or the timeout fires). Use this when you need a one-shot answer without spawning a fresh task.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      try {
+        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
+        return { ok: true, answer };
+      } catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+  };
+}
+function makeRollUpTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      taskIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Completed task ids to aggregate. Pass the ids returned by previous `assign_task` calls."
+      },
+      style: {
+        type: "string",
+        enum: ["markdown", "json"],
+        description: "Output flavor \u2014 markdown (default) for in-prompt summarization, json for structured downstream processing."
+      }
+    },
+    required: ["taskIds"]
+  };
+  return {
+    name: "roll_up",
+    description: "Aggregate completed task results into a single formatted summary. Use this after `await_tasks` to fold subagent outputs back into the director's context before deciding the next step.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
+      return { summary, count: i.taskIds.length };
+    }
+  };
+}
+function makeTerminateTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: { type: "string", description: "Subagent to abort." }
+    },
+    required: ["subagentId"]
+  };
+  return {
+    name: "terminate_subagent",
+    description: 'Forcibly abort a subagent. Use sparingly \u2014 prefer waiting on the natural budget to expire. The current task (if any) ends with status "stopped".',
+    permission: "auto",
+    mutating: true,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      await director.terminate(i.subagentId);
+      return { ok: true };
+    }
+  };
+}
+function makeFleetStatusTool(director) {
+  return {
+    name: "fleet_status",
+    description: "Snapshot of the fleet \u2014 every subagent's current status, pending vs. completed task counts, and the running total iteration count. Cheap; call freely.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      return director.status();
+    }
+  };
+}
+function makeFleetUsageTool(director) {
+  return {
+    name: "fleet_usage",
+    description: "Token + cost breakdown across the fleet, per-subagent and totals. Use this to reason about which workers to assign costly tasks to or when to wrap up to stay within budget.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      return director.snapshot();
+    }
+  };
+}
+function makeDirectorSessionFactory(opts) {
+  const runId = opts.directorRunId ?? `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-director`;
+  let store;
+  let dir;
+  if (opts.store) {
+    store = opts.store;
+    dir = opts.sessionsRoot ? path2.join(opts.sessionsRoot, runId) : "(caller-managed)";
+  } else if (opts.sessionsRoot) {
+    dir = path2.join(opts.sessionsRoot, runId);
+    store = new DefaultSessionStore({ dir });
+  } else {
+    throw new Error(
+      "makeDirectorSessionFactory requires either `store` or `sessionsRoot`"
+    );
+  }
+  return {
+    dir,
+    directorRunId: runId,
+    async createSubagentSession({ subagentId, provider, model, title }) {
+      return store.create({
+        id: subagentId,
+        title: title ?? subagentId,
+        provider: provider ?? "unknown",
+        model: model ?? "unknown"
+      });
+    }
+  };
+}
+
 // src/defaults/autonomous-runner.ts
 var DoneConditionChecker = class {
   constructor(condition) {
     this.condition = condition;
+    this.compiledRegex = condition.type === "output_match" && condition.pattern ? new RegExp(condition.pattern) : null;
   }
   condition;
+  compiledRegex;
   check(state) {
     switch (this.condition.type) {
       case "iterations":
@@ -4568,11 +5706,8 @@ var DoneConditionChecker = class {
         }
         break;
       case "output_match":
-        if (this.condition.pattern && state.lastOutput) {
-          const regex = new RegExp(this.condition.pattern);
-          if (regex.test(state.lastOutput)) {
-            return { done: true, reason: `output matched pattern "${this.condition.pattern}"`, ...state };
-          }
+        if (this.compiledRegex && state.lastOutput && this.compiledRegex.test(state.lastOutput)) {
+          return { done: true, reason: `output matched pattern "${this.condition.pattern}"`, ...state };
         }
         break;
     }
@@ -4591,6 +5726,16 @@ var AutonomousRunner = class {
   stopped = false;
   doneChecker;
   async run() {
+    const offToolExecuted = this.opts.agent.events?.on?.("tool.executed", () => {
+      this.toolCalls++;
+    });
+    try {
+      return await this.runLoop();
+    } finally {
+      offToolExecuted?.();
+    }
+  }
+  async runLoop() {
     while (!this.stopped) {
       const check = this.doneChecker.check({
         iterations: this.iterations,
@@ -4617,7 +5762,6 @@ var AutonomousRunner = class {
         );
         this.iterations++;
         this.lastOutput = result.finalText;
-        this.toolCalls++;
         if (result.status === "failed" || result.status === "aborted") {
           const failedResult = {
             status: result.status,
@@ -4629,7 +5773,8 @@ var AutonomousRunner = class {
           return failedResult;
         }
       } catch (e) {
-        if (e.message.includes("timeout")) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (msg.includes("timeout")) {
           const timeoutResult = {
             status: "failed",
             error: toWrongStackError(e),
@@ -4658,14 +5803,11 @@ var AutonomousRunner = class {
 
 // src/defaults/spec-parser.ts
 var SpecParser = class {
-  constructor(opts = {}) {
-    this.opts = opts;
-  }
-  opts;
   parse(content) {
     const lines = content.split("\n");
     const sections = this.extractSections(lines);
     const requirements = this.extractRequirements(lines);
+    const now = Date.now();
     return {
       id: crypto.randomUUID(),
       title: this.extractTitle(lines),
@@ -4674,8 +5816,8 @@ var SpecParser = class {
       overview: this.extractOverview(lines),
       sections,
       requirements,
-      createdAt: Date.now(),
-      updatedAt: Date.now()
+      createdAt: now,
+      updatedAt: now
     };
   }
   extractTitle(lines) {
@@ -4767,20 +5909,13 @@ var SpecParser = class {
   parseRequirementLine(line, id) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) return null;
-    const typeMap = {
-      "functional": "functional",
-      "non-functional": "non-functional",
-      "security": "security",
-      "performance": "performance",
-      "ux": "ux"
-    };
+    const lower = trimmed.toLowerCase();
+    const types = ["functional", "non-functional", "security", "performance", "ux"];
     let type = "functional";
-    let priority = "medium";
-    for (const [key, val] of Object.entries(typeMap)) {
-      if (trimmed.toLowerCase().includes(`[${key}]`)) {
-        type = val;
-      }
+    for (const t2 of types) {
+      if (lower.includes(`[${t2}]`)) type = t2;
     }
+    let priority = "medium";
     if (trimmed.includes("[critical]") || trimmed.includes("[prio:high]")) {
       priority = "critical";
     } else if (trimmed.includes("[high]")) {
@@ -4870,9 +6005,10 @@ var SpecParser = class {
         warnings.push({ path: `requirement.${req.id}`, message: "No acceptance criteria defined" });
       }
     }
+    const reqIds = new Set(spec.requirements.map((r) => r.id));
     const blockedByIds = new Set(spec.requirements.flatMap((r) => r.blockedBy ?? []));
     for (const id of blockedByIds) {
-      if (!spec.requirements.find((r) => r.id === id)) {
+      if (!reqIds.has(id)) {
         errors.push({ path: "requirements", message: `BlockedBy references non-existent requirement: ${id}` });
       }
     }
@@ -4902,25 +6038,21 @@ var TaskGenerator = class {
         status: "pending"
       });
     }
-    const criticalReqs = spec.requirements.filter((r) => r.priority === "critical");
-    const highReqs = spec.requirements.filter((r) => r.priority === "high");
-    const mediumReqs = spec.requirements.filter((r) => r.priority === "medium");
-    const lowReqs = spec.requirements.filter((r) => r.priority === "low");
-    for (const req of criticalReqs) {
-      const task = this.createTaskFromRequirement(req, spec.title);
-      this.opts.taskTracker.addNode(task);
-    }
-    for (const req of highReqs) {
-      const task = this.createTaskFromRequirement(req, spec.title);
-      this.opts.taskTracker.addNode(task);
-    }
-    for (const req of mediumReqs) {
-      const task = this.createTaskFromRequirement(req, spec.title);
-      this.opts.taskTracker.addNode(task);
+    const byPriority = {
+      critical: [],
+      high: [],
+      medium: [],
+      low: []
+    };
+    for (const req of spec.requirements) {
+      const bucket = byPriority[req.priority] ?? byPriority.medium;
+      bucket.push(req);
     }
-    for (const req of lowReqs) {
-      const task = this.createTaskFromRequirement(req, spec.title);
-      this.opts.taskTracker.addNode(task);
+    const order = ["critical", "high", "medium", "low"];
+    for (const p of order) {
+      for (const req of byPriority[p]) {
+        this.opts.taskTracker.addNode(this.createTaskFromRequirement(req));
+      }
     }
     if (spec.apiEndpoints && spec.apiEndpoints.length > 0) {
       const apiParent = this.opts.taskTracker.addNode({
@@ -4954,17 +6086,15 @@ var TaskGenerator = class {
     });
     return graph;
   }
-  createTaskFromRequirement(req, specTitle) {
-    const type = this.mapRequirementType(req.type);
-    const tags = [req.type, req.priority];
+  createTaskFromRequirement(req) {
     return {
       title: req.description,
-      description: this.buildDescription(req, specTitle),
-      type,
-      priority: this.mapPriority(req.priority),
+      description: this.buildDescription(req),
+      type: this.mapRequirementType(req.type),
+      priority: req.priority,
       status: "pending",
       specRequirementId: req.id,
-      tags,
+      tags: [req.type, req.priority],
       estimateHours: this.estimateHours(req)
     };
   }
@@ -4979,7 +6109,7 @@ var TaskGenerator = class {
       estimateHours: this.estimateForEndpoint(endpoint)
     };
   }
-  buildDescription(req, specTitle) {
+  buildDescription(req) {
     const lines = [
       req.description,
       "",
@@ -5013,20 +6143,6 @@ var TaskGenerator = class {
         return "feature";
     }
   }
-  mapPriority(priority) {
-    switch (priority) {
-      case "critical":
-        return "critical";
-      case "high":
-        return "high";
-      case "medium":
-        return "medium";
-      case "low":
-        return "low";
-      default:
-        return "medium";
-    }
-  }
   estimateHours(req) {
     switch (req.priority) {
       case "critical":
@@ -5136,40 +6252,40 @@ var TaskTracker = class {
       this.graph.rootNodes.push(newNode.id);
     }
     this.graph.updatedAt = now;
-    this.opts.store.saveGraph(this.graph);
+    this.persist();
     return newNode;
   }
   addEdge(from, to, type = "depends_on") {
     if (!this.graph) throw new Error("No graph loaded");
-    const edge = {
+    this.graph.edges.push({
       id: crypto.randomUUID(),
       from,
       to,
       type
-    };
-    this.graph.edges.push(edge);
+    });
     this.graph.updatedAt = Date.now();
-    this.opts.store.saveGraph(this.graph);
+    this.persist();
   }
   updateNodeStatus(id, status, reason) {
     if (!this.graph) throw new Error("No graph loaded");
     const node = this.graph.nodes.get(id);
     if (!node) throw new Error(`Node ${id} not found`);
     const from = node.status;
+    const now = Date.now();
     node.status = status;
-    node.updatedAt = Date.now();
+    node.updatedAt = now;
     if (status === "completed") {
-      node.completedAt = Date.now();
+      node.completedAt = now;
     }
-    this.transitions.push({ from, to: status, timestamp: Date.now(), reason });
+    this.transitions.push({ from, to: status, timestamp: now, reason });
     if (status === "completed") {
       this.unblockDependents(id);
     }
     if (status === "in_progress") {
       this.checkAndBlockIfNeeded(id);
     }
-    this.graph.updatedAt = Date.now();
-    this.opts.store.saveGraph(this.graph);
+    this.graph.updatedAt = now;
+    this.persist();
   }
   getNode(id) {
     return this.graph?.nodes.get(id);
@@ -5190,9 +6306,7 @@ var TaskTracker = class {
     }
     if (sort) {
       nodes.sort((a, b) => {
-        const aVal = a[sort.field] ?? "";
-        const bVal = b[sort.field] ?? "";
-        const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+        const cmp = compareByField(a, b, sort.field);
         return sort.direction === "asc" ? cmp : -cmp;
       });
     }
@@ -5271,7 +6385,47 @@ var TaskTracker = class {
       }
     }
   }
+  /**
+   * Fire-and-forget persistence with attached error handler.
+   * Synchronous mutators (addNode/addEdge/updateNodeStatus) use this to
+   * avoid forcing an async cascade through every caller; if the store
+   * rejects, the configured `onPersistError` is invoked so failures are
+   * surfaced instead of swallowed by an unhandled promise rejection.
+   */
+  persist() {
+    if (!this.graph) return;
+    this.opts.store.saveGraph(this.graph).catch((err) => {
+      if (this.opts.onPersistError) this.opts.onPersistError(err);
+      else console.warn("[task-tracker] saveGraph failed:", err instanceof Error ? err.message : String(err));
+    });
+  }
+};
+var PRIORITY_RANK = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
 };
+var STATUS_RANK = {
+  in_progress: 0,
+  pending: 1,
+  review: 2,
+  blocked: 3,
+  failed: 4,
+  completed: 5
+};
+function compareByField(a, b, field) {
+  switch (field) {
+    case "priority":
+      return PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority];
+    case "status":
+      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    case "createdAt":
+      return a.createdAt - b.createdAt;
+    case "updatedAt":
+      return a.updatedAt - b.updatedAt;
+  }
+}
 
 // src/defaults/task-flow.ts
 var TaskFlow = class {
@@ -5323,9 +6477,10 @@ var TaskFlow = class {
         const task = batch[i];
         if (!result || !task) continue;
         if (result.status === "rejected") {
-          this.opts.tracker.updateNodeStatus(task.id, "failed", result.reason?.message);
-          this.emit("task.failed", { taskId: task.id, error: result.reason?.message ?? "unknown" });
-          ctx.onTaskFail?.(task, result.reason);
+          const reason = result.reason;
+          this.opts.tracker.updateNodeStatus(task.id, "failed", reason?.message);
+          this.emit("task.failed", { taskId: task.id, error: reason?.message ?? "unknown" });
+          ctx.onTaskFail?.(task, reason);
         } else {
           this.opts.tracker.updateNodeStatus(task.id, "completed");
           this.emit("task.completed", { taskId: task.id, result: result.value });
@@ -5613,7 +6768,7 @@ var ToolExecutor = class {
             return { result, tool, durationMs: Date.now() - start };
           }
         } else {
-          const suggestedPattern = this.subjectFor(tool.name, use.input) ?? tool.name;
+          const suggestedPattern = this.subjectFor(tool.name, use.input, tool.subjectKey) ?? tool.name;
           const pending = { type: "tool_confirm_pending", toolUseId: use.id, toolName: tool.name, input: use.input, suggestedPattern };
           return { result: pending, tool, durationMs: Date.now() - start };
         }
@@ -5645,15 +6800,31 @@ var ToolExecutor = class {
         span?.end();
       }
     };
+    const safeRun = async (use) => {
+      try {
+        return await runOne(use);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const scrubbed = this.opts.secretScrubber.scrub(msg);
+        const result = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Tool "${use.name}" execution failed: ${scrubbed}`,
+          is_error: true
+        };
+        budget = this.decrementBudget(result, budget);
+        return { result, tool: this.registry.get(use.name), durationMs: 0 };
+      }
+    };
     if (strategy === "sequential") {
       const outputs = [];
       for (const use of toolUses) {
-        if (use) outputs.push(await runOne(use));
+        if (use) outputs.push(await safeRun(use));
       }
       return { outputs, remainingBudget: budget };
     }
     if (strategy === "parallel") {
-      const outputs = await Promise.all(toolUses.map((use) => runOne(use)));
+      const outputs = await Promise.all(toolUses.map((use) => safeRun(use)));
       return { outputs, remainingBudget: budget };
     }
     const nonMutating = [];
@@ -5664,10 +6835,10 @@ var ToolExecutor = class {
       if (tool?.mutating) mutating.push(use);
       else nonMutating.push(use);
     }
-    const firstPass = await Promise.all(nonMutating.map((use) => runOne(use)));
+    const firstPass = await Promise.all(nonMutating.map((use) => safeRun(use)));
     const secondPass = [];
     for (const use of mutating) {
-      secondPass.push(await runOne(use));
+      secondPass.push(await safeRun(use));
     }
     return {
       outputs: [...firstPass, ...secondPass],
@@ -5702,7 +6873,8 @@ var ToolExecutor = class {
   }
   async runWithTimeout(tool, input, parentSignal, ctx, toolUseId) {
     if (parentSignal.aborted) {
-      throw parentSignal.reason instanceof Error ? parentSignal.reason : new Error(typeof parentSignal.reason === "string" ? parentSignal.reason : "aborted");
+      if (parentSignal.reason instanceof Error) throw parentSignal.reason;
+      throw new Error(typeof parentSignal.reason === "string" ? parentSignal.reason : "aborted");
     }
     const timeoutMs = tool.timeoutMs ?? this.iterationTimeoutMs;
     const ctrl = new AbortController();
@@ -5771,16 +6943,23 @@ var ToolExecutor = class {
    * Matches the logic in DefaultPermissionPolicy so the TUI shows the
    * same subject that the trust file would use.
    */
-  subjectFor(toolName, input) {
+  subjectFor(toolName, input, subjectKey) {
     if (!input || typeof input !== "object") return void 0;
     const obj = input;
     const globChars = /[*?\[\]]/g;
     const escapeGlob = (s) => s.replace(globChars, (c) => `\\${c}`);
+    const normalizePath = (s) => escapeGlob(s.replace(/\\/g, "/"));
+    if (subjectKey) {
+      const v = obj[subjectKey];
+      if (typeof v === "string") {
+        return subjectKey === "path" || subjectKey === "file" || subjectKey === "files" ? normalizePath(v) : escapeGlob(v);
+      }
+    }
     if (toolName === "bash" && typeof obj.command === "string") {
       return escapeGlob(obj.command);
     }
     if (typeof obj.path === "string") {
-      return escapeGlob(obj.path.replace(/\\/g, "/"));
+      return normalizePath(obj.path);
     }
     if (typeof obj.url === "string") {
       return escapeGlob(obj.url);
@@ -6204,8 +7383,9 @@ var DefaultHealthRegistry = class {
     return { status, timestamp: Date.now(), checks: results };
   }
   async runOne(check) {
+    let timer = null;
     const timeout = new Promise((resolve4) => {
-      setTimeout(
+      timer = setTimeout(
         () => resolve4({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
@@ -6214,6 +7394,8 @@ var DefaultHealthRegistry = class {
       return await Promise.race([check.check(), timeout]);
     } catch (err) {
       return { status: "unhealthy", detail: err instanceof Error ? err.message : String(err) };
+    } finally {
+      if (timer) clearTimeout(timer);
     }
   }
 };
@@ -6386,7 +7568,7 @@ var PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
 async function startMetricsServer(opts) {
   const { createServer } = await import('http');
   const host = opts.host ?? "127.0.0.1";
-  const path15 = opts.path ?? "/metrics";
+  const path17 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const server = createServer((req, res) => {
@@ -6396,7 +7578,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path15) {
+    if (url === path17) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -6447,7 +7629,7 @@ async function startMetricsServer(opts) {
   const boundPort = typeof addr === "object" && addr ? addr.port : opts.port;
   return {
     port: boundPort,
-    url: `http://${host}:${boundPort}${path15}`,
+    url: `http://${host}:${boundPort}${path17}`,
     close: () => new Promise((resolve4, reject) => {
       server.close((err) => err ? reject(err) : resolve4());
     })
@@ -6852,7 +8034,6 @@ function createContextManagerTool(opts = {}) {
               notes: `Invalid range [${from}, ${to}] for ${messages.length} messages.`
             };
           }
-          messages.slice(from, to + 1);
           const summaryText = input.text ?? '[summary placeholder \u2014 provide "text" to record the summary]';
           const summaryMsg = {
             role: "system",
@@ -7114,13 +8295,23 @@ async function streamProviderToResponse(provider, req, signal, ctx, events) {
     }
   } catch (err) {
     if (signal.aborted) {
-      state.stopReason = "max_tokens";
+      state.stopReason = "end_turn";
       return buildResponse(state);
     }
     throw err;
   } finally {
     try {
-      await iter.return?.();
+      let drainTimer = null;
+      try {
+        await Promise.race([
+          Promise.resolve(iter.return?.()),
+          new Promise((resolve4) => {
+            drainTimer = setTimeout(resolve4, 500);
+          })
+        ]);
+      } finally {
+        if (drainTimer) clearTimeout(drainTimer);
+      }
     } catch {
     }
   }
@@ -7177,12 +8368,24 @@ async function runProviderWithRetry(opts) {
         });
       }
       await new Promise((resolve4, reject) => {
-        const t2 = setTimeout(resolve4, delay);
-        const onAbort = () => {
+        let settled = false;
+        const cleanup = () => {
+          if (settled) return;
+          settled = true;
           clearTimeout(t2);
+        };
+        const onAbort = () => {
+          cleanup();
           reject(new Error("aborted"));
         };
-        if (signal.aborted) onAbort();
+        const t2 = setTimeout(() => {
+          cleanup();
+          resolve4();
+        }, delay);
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
         signal.addEventListener("abort", onAbort, { once: true });
       });
       attempt++;
@@ -7306,9 +8509,6 @@ var Agent = class {
   get scrubber() {
     return this.container.resolve(TOKENS.SecretScrubber);
   }
-  get compactor() {
-    return this.container.has(TOKENS.Compactor) ? this.container.resolve(TOKENS.Compactor) : void 0;
-  }
   get renderer() {
     return this.container.has(TOKENS.Renderer) ? this.container.resolve(TOKENS.Renderer) : void 0;
   }
@@ -7354,6 +8554,7 @@ var Agent = class {
     let iterations = 0;
     let effectiveLimit = opts.maxIterations ?? this.maxIterations;
     const hasHardLimit = effectiveLimit > 0 && Number.isFinite(effectiveLimit);
+    let recoveryRetries = 0;
     for (let i = 0; ; i++) {
       iterations = i + 1;
       if (controller.signal.aborted) {
@@ -7383,17 +8584,33 @@ var Agent = class {
           logger: this.logger,
           tracer: this.tracer
         });
+        recoveryRetries = 0;
       } catch (err) {
         if (controller.signal.aborted) {
           this.events.emit("error", { err: toError(err), phase: "provider" });
           return { status: "aborted", iterations, error: toWrongStackError(err, "AGENT_ABORTED") };
         }
         const recovered = await this.errorHandler.recover(err, this.ctx);
-        if (!recovered) {
+        if (!recovered || recovered.action === "fail") {
           this.events.emit("error", { err: toError(err), phase: "provider" });
-          return { status: "failed", iterations, error: toWrongStackError(err) };
+          return {
+            status: "failed",
+            iterations,
+            error: toWrongStackError(recovered?.error ?? err)
+          };
         }
-        res = recovered;
+        if (recovered.action === "retry") {
+          recoveryRetries++;
+          if (recoveryRetries > 2) {
+            this.events.emit("error", { err: toError(err), phase: "provider" });
+            return { status: "failed", iterations, error: toWrongStackError(err) };
+          }
+          if (recovered.model) this.ctx.model = recovered.model;
+          this.logger.info(`Recovered provider error via ${recovered.reason}; retrying turn`);
+          continue;
+        }
+        recoveryRetries = 0;
+        res = recovered.response;
       }
       const responseResult = await this.processResponse(res, req);
       if (responseResult.aborted) {
@@ -7467,7 +8684,7 @@ var Agent = class {
    * update session, render text, handle abort.
    */
   async processResponse(res, req) {
-    await this.pipelines.response.run(res);
+    res = await this.pipelines.response.run(res);
     this.events.emit("provider.response", {
       ctx: this.ctx,
       usage: res.usage,
@@ -7538,6 +8755,7 @@ var Agent = class {
             isError: !!reRunResult.result.is_error
           });
           this.events.emit("tool.executed", {
+            id: reRunResult.result.tool_use_id,
             name: tool.name,
             durationMs: reRunResult.durationMs,
             ok: !reRunResult.result.is_error,
@@ -7545,7 +8763,6 @@ var Agent = class {
             output: truncateForEvent(reRunResult.result.content)
           });
         }
-        this.ctx.state.appendMessage({ role: "user", content: [reRunResult.result] });
         continue;
       }
       const use = useById.get(result.tool_use_id);
@@ -7564,6 +8781,7 @@ var Agent = class {
         isError: !!result.is_error
       });
       this.events.emit("tool.executed", {
+        id: result.tool_use_id,
         name: use.name,
         durationMs,
         ok: !result.is_error,
@@ -7604,12 +8822,11 @@ var Agent = class {
     }
   }
   /**
-   * Run context window pipeline if compactor is present.
+   * Run context window pipeline. The pipeline may be empty, or it may contain
+   * middleware with its own injected dependencies.
    */
   async compactContextIfNeeded() {
-    if (this.compactor) {
-      await this.pipelines.contextWindow.run(this.ctx);
-    }
+    await this.pipelines.contextWindow.run(this.ctx);
   }
 };
 function toError(err) {
@@ -7627,7 +8844,6 @@ var ConversationState = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
-  // ─── Read API ───────────────────────────────────────────────────────
   get messages() {
     return this.ctx.messages;
   }
@@ -7642,25 +8858,24 @@ var ConversationState = class {
    * that need a stable view across an async boundary.
    */
   snapshot() {
-    return {
-      messages: [...this.ctx.messages],
-      todos: [...this.ctx.todos],
-      meta: { ...this.ctx.meta }
-    };
+    return Object.freeze({
+      messages: Object.freeze([...this.ctx.messages]),
+      todos: Object.freeze([...this.ctx.todos]),
+      meta: Object.freeze({ ...this.ctx.meta })
+    });
   }
-  // ─── Write API (preferred — fires onChange) ─────────────────────────
   appendMessage(message) {
-    this.ctx.messages.push(message);
+    this.ctx.messages.splice(this.ctx.messages.length, 0, message);
     this.emit({ kind: "message_appended", message });
   }
   replaceMessages(messages) {
     this.ctx.messages.length = 0;
-    this.ctx.messages.push(...messages);
+    this.ctx.messages.splice(0, 0, ...messages);
     this.emit({ kind: "messages_replaced", messages: [...messages] });
   }
   replaceTodos(todos) {
     this.ctx.todos.length = 0;
-    this.ctx.todos.push(...todos);
+    this.ctx.todos.splice(0, 0, ...todos);
     this.emit({ kind: "todos_replaced", todos: [...todos] });
   }
   setMeta(key, value) {
@@ -7672,13 +8887,15 @@ var ConversationState = class {
     delete this.ctx.meta[key];
     this.emit({ kind: "meta_deleted", key });
   }
-  // ─── Subscription ───────────────────────────────────────────────────
+  clearMeta() {
+    const keys = Object.keys(this.ctx.meta);
+    if (keys.length === 0) return;
+    for (const key of keys) delete this.ctx.meta[key];
+    this.emit({ kind: "meta_cleared" });
+  }
   /**
-   * Subscribe to mutations that go through this wrapper. Note: mutations
-   * that bypass the wrapper (e.g. `ctx.messages.push(...)` directly) are
-   * NOT observed — by design during migration, since we don't want to
-   * monkey-patch arrays. Migrating call sites to use this API is the
-   * dev-plan #1 work.
+   * Subscribe to mutations that go through this wrapper. Direct mutations of
+   * the compatibility arrays are intentionally not observed.
    */
   onChange(listener) {
     this.listeners.add(listener);
@@ -7895,34 +9112,60 @@ You operate inside the user's terminal with direct read and write access to thei
 
 ## Core principles
 
-1. Read before you write. Always inspect the relevant files before proposing changes. Assumptions about code you haven't read are bugs in waiting.
-
-2. Prefer surgical edits over rewrites. When modifying existing files, use the edit tool with str_replace; only use write for new files or full replacements explicitly requested.
+1. **Read before you write.** Always inspect the relevant files before proposing changes. Assumptions about code you haven't read are bugs in waiting.
+2. **Prefer surgical edits over rewrites.** When modifying existing files, use the edit tool with str_replace; only use write for new files or full replacements explicitly requested.
+3. **Show your work.** Before non-trivial changes, briefly state what you're about to do \u2014 one sentence, not a wall of text. After tool calls, summarize what happened, not what you did mechanically.
+4. **Be honest about limits.** If you don't know, say so. If something failed, say what failed and what you'll try next. Never fabricate file contents, API responses, or test results.
+5. **Be concise.** The user is a developer in a terminal. No marketing language, no "great question!", no bullet-point lists when prose works. If a one-liner answers, a one-liner is the answer.
+6. **Ask when blocked, proceed when not.** If the task is ambiguous in a way that meaningfully changes the approach, ask. If it's ambiguous in a way that doesn't, pick a reasonable default and proceed, stating the assumption.
+7. **Trust the tools.** If a permission prompt is shown, the user will answer. Do not preemptively explain that you "would like to" do something \u2014 call the tool, let the permission flow decide.
+8. **Format for scanability.** Use code blocks for code, backticks for file paths, bold for key terms. One-liners stay one line. Paragraphs max 3 sentences.
+9. **Recover explicitly.** When a tool fails, state: (1) what failed, (2) what you tried, (3) what you'll attempt next. Never silently skip.
 
-3. Show your work. Before non-trivial changes, briefly state what you're about to do \u2014 one sentence, not a wall of text. After tool calls, summarize what happened, not what you did mechanically.
+## Decision heuristics
 
-4. Honest about limits. If you don't know, say so. If something failed, say what failed and what you'll try next. Never fabricate file contents, API responses, or test results.
+- **Task is ambiguous** (unclear which file, conflicting requirements) \u2192 ask before proceeding
+- **Task is clear, approach is unknown** \u2192 try one approach, report what happened
+- **Tool fails** \u2192 retry once with adjusted params, then report failure
+- **Permission prompt shown** \u2192 wait for user, do not act unilaterally
+- **Context window filling up** \u2192 use context_manager proactively; don't wait to be told
 
-5. Concise output. The user is a developer in a terminal. No marketing language, no "great question!", no bullet-point lists when prose works. If a one-liner answers, a one-liner is the answer.
+## How you work
 
-6. Ask when blocked, proceed when not. If the task is ambiguous in a way that meaningfully changes the approach, ask. If it's ambiguous in a way that doesn't, pick a reasonable default and proceed, stating the assumption.
-
-7. Trust the tools. If a permission prompt is shown, the user will answer. Do not preemptively explain that you "would like to" do something \u2014 call the tool, let the permission flow decide.
-
-## What you do not do
-
-- You do not lecture about software engineering principles unless asked.
-- You do not add comments to code unless they materially help or were requested.
-- You do not refactor adjacent code while fixing a bug, unless asked.
-- You do not claim work is "production-ready" or "fully tested" \u2014 the user decides that.
-- You do not apologize for failures. You report them and proceed.`;
+- **Stay focused.** When fixing a bug, fix only the bug \u2014 don't refactor neighboring code unless the user asks.
+- **Comment with purpose.** Add comments only when they explain why, not what. The code already says what.
+- **Own your output.** Never call work "production-ready" or "fully tested" \u2014 the user makes that call.
+- **Move on from mistakes.** When something fails, report what happened and what you'll do next. No apologies, no hand-wringing.
+- **Stay in your lane.** Don't lecture about software engineering principles unless explicitly asked \u2014 the user is the expert on their codebase.`;
 var DefaultSystemPromptBuilder = class {
   constructor(opts = {}) {
     this.opts = opts;
   }
   opts;
-  envCache;
+  /**
+   * Cached environment block, keyed by projectRoot. A single builder
+   * instance is normally reused across turns of the same agent run, but
+   * tests and library consumers may reuse it across runs with different
+   * roots; keying the cache prevents leaking the first call's project
+   * state into a later call against an unrelated project.
+   */
+  envCacheByRoot = /* @__PURE__ */ new Map();
+  skillCache;
   async build(ctx) {
+    if (this.opts.skillLoader && !this.skillCache) {
+      try {
+        const entries = await this.opts.skillLoader.listEntries();
+        if (entries.length > 0) {
+          const lines = [];
+          for (const e of entries) {
+            const scopeTag = e.scope.length > 0 ? ` \u2014 ${e.scope.slice(0, 4).join(", ")}` : "";
+            lines.push(`- **${e.name}**${scopeTag}  (${e.trigger})`);
+          }
+          this.skillCache = lines.join("\n");
+        }
+      } catch {
+      }
+    }
     const layer1 = LAYER_1_IDENTITY;
     const layer2 = this.buildToolUsage(ctx.tools);
     const layer3 = await this.buildEnvironment(ctx);
@@ -7958,8 +9201,20 @@ var DefaultSystemPromptBuilder = class {
 ### ${t2.name}
 ${hint.trim()}`);
     }
+    lines.push(`
+## Common patterns
+
+- **Inspect before edit:** \`read\`/\`glob\`/\`grep\` \u2192 locate target \u2192 \`edit\`
+- **Search then operate:** \`grep\`/\`glob\` \u2192 identify targets \u2192 \`batch_tool_use\` or iterative \`edit\`
+- **Verify after mutate:** \`write\`/\`edit\`/\`patch\` \u2192 \`read\` back to confirm \u2192 report outcome
+- **Explore project:** \`glob\` for structure \u2192 \`read\` key files \u2192 \`grep\` for patterns
+- **Batch ops:** Use \`replace\` with glob patterns for multi-file surgical changes
+
+When unsure about a file's current state, read it first rather than assuming.`);
     const hasContextManager = tools.some((t2) => t2.name === "context_manager");
     if (hasContextManager) {
+      const maxCtx = this.opts.modelCapabilities?.maxContextTokens ?? 128e3;
+      const threshold = maxCtx <= 32e3 ? "50" : "70";
       lines.push(`
 ## Context management
 
@@ -7967,7 +9222,7 @@ When the conversation grows long and context window usage exceeds what you can t
 use the context_manager tool proactively \u2014 do NOT wait to be told:
 
 - Call \`context_manager\` with \`{"action":"check"}\` to see current token budget and message counts.
-- When the conversation exceeds ~70% of your context window, call \`{"action":"summary"}\` or \`{"action":"compact"}\` to reclaim space.
+- When the conversation exceeds ~${threshold}% of your context window, call \`{"action":"summary"}\` or \`{"action":"compact"}\` to reclaim space.
 - Use \`{"action":"prune"}\` to surgically remove specific irrelevant message ranges (e.g. old debug output).
 - Use \`{"action":"add_note"}\` to inject a summary note at a specific point after a complex operation.
 
@@ -7977,14 +9232,17 @@ summarize it, and let the tool result hold only the summary.`);
     return lines.join("\n");
   }
   async buildEnvironment(ctx) {
-    if (this.envCache) return this.envCache;
+    const cached = this.envCacheByRoot.get(ctx.projectRoot);
+    if (cached) return cached;
     const today = this.opts.todayIso ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const platform2 = `${os3.platform()} ${os3.release()}`;
     const shell = process.env.SHELL ?? process.env.ComSpec ?? "unknown";
     const node = process.version;
     const isGit = await this.dirExists(path2.join(ctx.projectRoot, ".git"));
-    const git = isGit ? await this.gitStatus(ctx.projectRoot) : "not a git repo";
-    const langs = await this.detectLanguages(ctx.projectRoot);
+    const [git, langs] = await Promise.all([
+      isGit ? this.gitStatus(ctx.projectRoot) : Promise.resolve("not a git repo"),
+      this.detectLanguages(ctx.projectRoot)
+    ]);
     const lines = [
       "## Environment",
       "",
@@ -8002,8 +9260,17 @@ summarize it, and let the tool result hold only the summary.`);
         `- Running on: ${ctx.provider ?? "<unknown provider>"}/${ctx.model ?? "<unknown model>"}`
       );
     }
+    if (this.opts.modeId && this.opts.modeId !== "default") {
+      lines.push(`- Mode: ${this.opts.modeId}`);
+    }
+    if (this.opts.modelCapabilities) {
+      lines.push(`- Context window: ${this.opts.modelCapabilities.maxContextTokens.toLocaleString()} tokens max`);
+    }
+    if (this.skillCache) {
+      lines.push("", "## Skills in scope for this session", this.skillCache);
+    }
     const text = lines.join("\n");
-    this.envCache = text;
+    this.envCacheByRoot.set(ctx.projectRoot, text);
     return text;
   }
   async buildMemoryAndSkills() {
@@ -8017,16 +9284,10 @@ ${mem}`);
       } catch {
       }
     }
-    if (this.opts.skillLoader) {
-      try {
-        const manifest = await this.opts.skillLoader.manifestText();
-        if (manifest.trim()) parts.push(manifest);
-      } catch {
-      }
-    }
     return parts.join("\n\n");
   }
   async buildMode() {
+    if (this.opts.modePrompt) return this.opts.modePrompt;
     if (!this.opts.modeStore) return "";
     const mode = await this.opts.modeStore.getActiveMode();
     if (!mode?.prompt) return "";
@@ -8042,8 +9303,19 @@ ${mem}`);
   }
   async gitStatus(root) {
     return new Promise((resolve4) => {
+      let settled = false;
+      const finish = (s) => {
+        if (settled) return;
+        settled = true;
+        resolve4(s);
+      };
+      let proc;
+      const timer = setTimeout(() => {
+        proc?.kill("SIGKILL");
+        finish("git timeout");
+      }, 2e3);
       try {
-        const proc = spawn("git", ["status", "--porcelain=v1", "--branch"], {
+        proc = spawn("git", ["status", "--porcelain=v1", "--branch"], {
           cwd: root,
           stdio: ["ignore", "pipe", "ignore"]
         });
@@ -8051,19 +9323,24 @@ ${mem}`);
         proc.stdout?.on("data", (c) => {
           buf += c.toString();
         });
-        proc.on("error", () => resolve4("git error"));
+        proc.on("error", () => {
+          clearTimeout(timer);
+          finish("git error");
+        });
         proc.on("close", () => {
+          clearTimeout(timer);
           const lines = buf.split("\n").filter(Boolean);
           const branchLine = lines[0] ?? "";
-          const branchMatch = /## ([^\s.]+)/.exec(branchLine);
+          const branchMatch = branchLine.match(/## ([^\s.]+)/);
           const branch = branchMatch?.[1] ?? "detached";
           const dirty = lines.slice(1);
           const staged = dirty.filter((l) => /^[MARCD]/.test(l)).length;
           const modified = dirty.length - staged;
-          resolve4(`branch=${branch}, ${modified} modified, ${staged} staged`);
+          finish(`branch=${branch}, ${modified} modified, ${staged} staged`);
         });
       } catch {
-        resolve4("git unavailable");
+        clearTimeout(timer);
+        finish("git unavailable");
       }
     });
   }
@@ -8081,14 +9358,17 @@ ${mem}`);
       ["composer.json", "PHP"],
       ["mix.exs", "Elixir"]
     ];
-    const langs = /* @__PURE__ */ new Set();
-    for (const [marker, lang] of checks) {
-      try {
-        await fsp.access(path2.join(root, marker));
-        langs.add(lang);
-      } catch {
-      }
-    }
+    const hits = await Promise.all(
+      checks.map(async ([marker, lang]) => {
+        try {
+          await fsp.access(path2.join(root, marker));
+          return lang;
+        } catch {
+          return null;
+        }
+      })
+    );
+    const langs = new Set(hits.filter((l) => l !== null));
     return langs.size === 0 ? "unknown" : Array.from(langs).join(", ");
   }
 };
@@ -8387,7 +9667,7 @@ var noopSlashCommands = {
 };
 
 // src/plugin/loader.ts
-var KERNEL_API_VERSION = "0.1.1";
+var KERNEL_API_VERSION = "0.1.8";
 function parseSemver(v) {
   const parts = v.replace(/^[^0-9]*/, "").split(".").map((s) => Number.parseInt(s, 10) || 0);
   return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
@@ -8619,6 +9899,6 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
   });
 }
 
-export { Agent, AgentError, AutoCompactionMiddleware, AutonomousRunner, BudgetExceededError, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_SPEC_TEMPLATE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, DoneConditionChecker, ENCRYPTED_PREFIX, EventBus, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, RecoveryLock, RunController, SelectiveCompactor, SessionError, SlashCommandRegistry, SpecDrivenDev, SpecParser, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskTracker, ToolError, ToolExecutor, ToolRegistry, WrongStackError, allServers, asBlocks, asText, atomicWrite, awsServer, blockServer, braveSearchServer, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, color, compileGlob, computeTaskProgress, context7Server, contextManagerTool, createContextManagerTool, createDefaultPipelines, createMessage, createToolOutputSerializer, decryptConfigSecrets, detectNewlineStyle, encryptConfigSecrets, ensureDir, estimateTextTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, githubServer, googleMapsServer, isAgentError, isConfigError, isImageBlock, isPluginError, isSessionError, isTextBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, loadPlugins, loadProjectModes, loadUserModes, makeAgentSubagentRunner, matchAny, matchGlob, migratePlaintextSecrets, normalizeToLf, projectHash, renderPrometheus, resolveWstackPaths, rewriteConfigEncrypted, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, sentinelServer, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState };
+export { Agent, AgentError, AutoCompactionMiddleware, AutonomousRunner, BudgetExceededError, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DoneConditionChecker, ENCRYPTED_PREFIX, EventBus, FleetBus, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, RecoveryLock, RunController, SelectiveCompactor, SessionError, SlashCommandRegistry, SpecDrivenDev, SpecParser, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskTracker, ToolError, ToolExecutor, ToolRegistry, WrongStackError, allServers, asBlocks, asText, atomicWrite, awsServer, blockServer, braveSearchServer, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, color, compileGlob, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createContextManagerTool, createDefaultPipelines, createMessage, createToolOutputSerializer, decryptConfigSecrets, detectNewlineStyle, encryptConfigSecrets, ensureDir, estimateTextTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, githubServer, googleMapsServer, isAgentError, isConfigError, isImageBlock, isPluginError, isSessionError, isTextBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, loadPlugins, loadProjectModes, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, normalizeToLf, projectHash, renderPrometheus, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, sentinelServer, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map