@wrongstack/core 0.1.10 → 0.3.1

package/dist/index.js

@@ -395,6 +395,7 @@ var Pipeline = class {
 // src/kernel/events.ts
 var EventBus = class {
   listeners = /* @__PURE__ */ new Map();
+  wildcards = [];
   logger;
   setLogger(logger) {
     this.logger = logger;
@@ -421,24 +422,73 @@ var EventBus = class {
       this.off(event, wrapper);
     };
   }
+  /**
+   * Subscribe to all events whose name matches a glob-style prefix.
+   * `'tool.*'` matches `tool.started`, `tool.executed`, `tool.progress`, etc.
+   * `'*'` matches every event.
+   *
+   * The handler receives `(eventName, payload)` with the event name as a
+   * string and the payload as `unknown`. Use for logging, debugging, or
+   * metrics collection across a family of events.
+   *
+   * Returns an unsubscribe function.
+   */
+  onPattern(pattern, fn) {
+    const match = makePatternMatcher(pattern);
+    const entry = { match, fn };
+    this.wildcards.push(entry);
+    return () => {
+      const idx = this.wildcards.indexOf(entry);
+      if (idx >= 0) this.wildcards.splice(idx, 1);
+    };
+  }
+  /**
+   * Subscribe to all events whose name matches a RegExp.
+   * More flexible than `onPattern` — use when you need regex features
+   * (alternation, character classes, capture groups).
+   *
+   * Returns an unsubscribe function.
+   */
+  onRegex(regex, fn) {
+    const entry = { match: (e) => regex.test(e), fn };
+    this.wildcards.push(entry);
+    return () => {
+      const idx = this.wildcards.indexOf(entry);
+      if (idx >= 0) this.wildcards.splice(idx, 1);
+    };
+  }
   emit(event, payload) {
     const set = this.listeners.get(event);
-    if (!set) return;
-    for (const fn of set) {
-      try {
-        fn(payload);
-      } catch (err) {
-        this.logger?.error(`EventBus listener for "${event}" threw`, err);
+    if (set) {
+      for (const fn of set) {
+        try {
+          fn(payload);
+        } catch (err) {
+          this.logger?.error(`EventBus listener for "${event}" threw`, err);
+        }
+      }
+    }
+    if (this.wildcards.length > 0) {
+      const name = event;
+      for (const { match, fn } of this.wildcards) {
+        if (!match(name)) continue;
+        try {
+          fn(name, payload);
+        } catch (err) {
+          this.logger?.error(`EventBus wildcard listener for "${name}" threw`, err);
+        }
       }
     }
   }
   clear() {
     this.listeners.clear();
+    this.wildcards.length = 0;
   }
   /**
    * V2-D: introspection helper. Pass an `event` to count handlers for a
    * single key, or omit to get the total across every event. Used by the
    * leak-detection smoke test to flag handler accumulation across runs.
+   * Does NOT include wildcard listeners.
    */
   listenerCount(event) {
     if (event !== void 0) return this.listeners.get(event)?.size ?? 0;
@@ -446,7 +496,21 @@ var EventBus = class {
     for (const set of this.listeners.values()) total += set.size;
     return total;
   }
+  /**
+   * Number of wildcard listeners currently registered.
+   */
+  wildcardCount() {
+    return this.wildcards.length;
+  }
 };
+function makePatternMatcher(pattern) {
+  if (pattern === "*") return () => true;
+  if (pattern.endsWith(".*")) {
+    const prefix = pattern.slice(0, -2);
+    return (e) => e.startsWith(`${prefix}.`);
+  }
+  return (e) => e === pattern;
+}
 
 // src/kernel/tokens.ts
 var t = (name) => Symbol(name);
@@ -468,7 +532,9 @@ var TOKENS = {
   SystemPromptBuilder: t("SystemPromptBuilder"),
   SecretScrubber: t("SecretScrubber"),
   ModelsRegistry: t("ModelsRegistry"),
-  ModeStore: t("ModeStore")
+  ModeStore: t("ModeStore"),
+  /** Replaces the entire provider call layer — retry, streaming, tracing. */
+  ProviderRunner: t("ProviderRunner")
 };
 
 // src/kernel/run-controller.ts
@@ -1539,7 +1605,7 @@ async function atomicWrite(targetPath, content, opts = {}) {
     if (mode !== void 0) {
       await fsp2.chmod(tmp, mode);
     }
-    await fsp2.rename(tmp, targetPath);
+    await renameWithRetry(tmp, targetPath);
   } catch (err) {
     try {
       await fsp2.unlink(tmp);
@@ -1551,6 +1617,29 @@ async function atomicWrite(targetPath, content, opts = {}) {
 async function ensureDir(dir) {
   await fsp2.mkdir(dir, { recursive: true });
 }
+var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fsp2.rename(from, to);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fsp2.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve4) => setTimeout(resolve4, delays[i]));
+    }
+  }
+  throw lastErr;
+}
 
 // src/models/models-registry.ts
 var DEFAULT_URL = "https://models.dev/api.json";
@@ -3116,11 +3205,11 @@ function validateAgainstSchema(value, schema) {
   walk2(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk2(value, schema, path17, errors) {
+function walk2(value, schema, path18, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path17 || "<root>",
+        path: path18 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -3129,7 +3218,7 @@ function walk2(value, schema, path17, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path17 || "<root>",
+        path: path18 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -3139,19 +3228,19 @@ function walk2(value, schema, path17, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path17, req), message: "required property missing" });
+        errors.push({ path: joinPath(path18, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk2(obj[key], subSchema, joinPath(path17, key), errors);
+          walk2(obj[key], subSchema, joinPath(path18, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk2(item, schema.items, `${path17}[${i}]`, errors));
+    value.forEach((item, i) => walk2(item, schema.items, `${path18}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -3439,6 +3528,12 @@ var FileSessionWriter = class {
   tokenIn = 0;
   tokenOut = 0;
   filePath;
+  /** Public accessor for the JSONL path — required by SessionWriter so
+   *  observability surfaces (`/fleet log`, FleetPanel) can locate the
+   *  transcript without recomputing the path from session metadata. */
+  get transcriptPath() {
+    return this.filePath || void 0;
+  }
   initDone = false;
   resumed;
   appendFailCount = 0;
@@ -4368,6 +4463,272 @@ var SessionAnalyzer = class {
     return last - first;
   }
 };
+async function loadTodosCheckpoint(filePath) {
+  let raw;
+  try {
+    raw = await fsp2.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || !Array.isArray(parsed.todos)) return null;
+    return parsed.todos.filter(
+      (t2) => !!t2 && typeof t2.id === "string" && typeof t2.content === "string" && typeof t2.status === "string"
+    );
+  } catch {
+    return null;
+  }
+}
+async function saveTodosCheckpoint(filePath, sessionId, todos) {
+  const payload = {
+    version: 1,
+    sessionId,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    todos: [...todos]
+  };
+  try {
+    await atomicWrite(filePath, JSON.stringify(payload, null, 2), { mode: 384 });
+  } catch (err) {
+    console.warn(
+      "[todos-checkpoint] save failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
+function attachTodosCheckpoint(state, filePath, sessionId) {
+  let timer = null;
+  let pending = null;
+  const flush = () => {
+    timer = null;
+    if (pending) {
+      void saveTodosCheckpoint(filePath, sessionId, pending);
+      pending = null;
+    }
+  };
+  const unsubscribe = state.onChange((change) => {
+    if (change.kind !== "todos_replaced") return;
+    pending = change.todos;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(flush, 150);
+  });
+  return () => {
+    unsubscribe();
+    if (timer) {
+      clearTimeout(timer);
+      flush();
+    }
+  };
+}
+async function loadPlan(filePath) {
+  let raw;
+  try {
+    raw = await fsp2.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || !Array.isArray(parsed.items)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function savePlan(filePath, plan) {
+  try {
+    await atomicWrite(filePath, JSON.stringify(plan, null, 2), { mode: 384 });
+  } catch (err) {
+    console.warn(
+      "[plan-store] save failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
+function emptyPlan(sessionId, title) {
+  return {
+    version: 1,
+    sessionId,
+    title,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    items: []
+  };
+}
+function addPlanItem(plan, title, details) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const item = {
+    id: `plan_${Date.now()}_${randomUUID().slice(0, 6)}`,
+    title,
+    details,
+    status: "open",
+    createdAt: now,
+    updatedAt: now
+  };
+  return {
+    plan: { ...plan, items: [...plan.items, item], updatedAt: now },
+    item
+  };
+}
+function removePlanItem(plan, idOrIndex) {
+  const idx = matchIndex(plan, idOrIndex);
+  if (idx === -1) return plan;
+  return {
+    ...plan,
+    items: plan.items.filter((_, i) => i !== idx),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function setPlanItemStatus(plan, idOrIndex, status) {
+  const idx = matchIndex(plan, idOrIndex);
+  if (idx === -1) return plan;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const items = plan.items.map(
+    (it, i) => i === idx ? { ...it, status, updatedAt: now } : it
+  );
+  return { ...plan, items, updatedAt: now };
+}
+function clearPlan(plan) {
+  return { ...plan, items: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function formatPlan(plan) {
+  if (plan.items.length === 0) return "Plan is empty.";
+  const lines = [];
+  if (plan.title) lines.push(`# ${plan.title}`);
+  plan.items.forEach((it, i) => {
+    const mark = it.status === "done" ? "[x]" : it.status === "in_progress" ? "[~]" : "[ ]";
+    lines.push(`${i + 1}. ${mark} ${it.title}`);
+    if (it.details) {
+      for (const line of it.details.split("\n")) lines.push(`     ${line}`);
+    }
+  });
+  return lines.join("\n");
+}
+function matchIndex(plan, idOrIndex) {
+  const asNum = Number.parseInt(idOrIndex, 10);
+  if (!Number.isNaN(asNum) && asNum >= 1 && asNum <= plan.items.length) return asNum - 1;
+  const byId = plan.items.findIndex((it) => it.id === idOrIndex);
+  if (byId !== -1) return byId;
+  const lower = idOrIndex.toLowerCase();
+  return plan.items.findIndex((it) => it.title.toLowerCase().includes(lower));
+}
+function attachPlanCheckpoint(_state, _filePath, _sessionId) {
+  return () => void 0;
+}
+async function loadDirectorState(filePath) {
+  let raw;
+  try {
+    raw = await fsp2.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+var DirectorStateCheckpoint = class {
+  snapshot;
+  filePath;
+  timer = null;
+  debounceMs;
+  writing = false;
+  rewriteRequested = false;
+  constructor(filePath, init, debounceMs = 250) {
+    this.filePath = filePath;
+    this.debounceMs = debounceMs;
+    this.snapshot = {
+      version: 1,
+      directorRunId: init.directorRunId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      spawnCount: 0,
+      maxSpawns: init.maxSpawns,
+      spawnDepth: init.spawnDepth,
+      maxSpawnDepth: init.maxSpawnDepth,
+      subagents: [],
+      tasks: []
+    };
+  }
+  current() {
+    return this.snapshot;
+  }
+  recordSpawn(sub, spawnCount) {
+    this.snapshot = {
+      ...this.snapshot,
+      spawnCount,
+      subagents: [...this.snapshot.subagents.filter((s) => s.id !== sub.id), sub]
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskAssigned(task) {
+    const exists = this.snapshot.tasks.some((t2) => t2.taskId === task.taskId);
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: exists ? this.snapshot.tasks.map((t2) => t2.taskId === task.taskId ? { ...t2, ...task } : t2) : [...this.snapshot.tasks, task]
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskStatus(taskId, patch) {
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: this.snapshot.tasks.map(
+        (t2) => t2.taskId === taskId ? { ...t2, ...patch } : t2
+      )
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  setUsage(usage) {
+    this.snapshot = { ...this.snapshot, usage };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  /** Force a synchronous flush — used by Director.shutdown(). */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.persist();
+  }
+  bumpUpdatedAt() {
+    this.snapshot = { ...this.snapshot, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  schedule() {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.persist();
+    }, this.debounceMs);
+  }
+  async persist() {
+    if (this.writing) {
+      this.rewriteRequested = true;
+      return;
+    }
+    this.writing = true;
+    try {
+      await atomicWrite(this.filePath, JSON.stringify(this.snapshot, null, 2), {
+        mode: 384
+      });
+    } catch (err) {
+      console.warn(
+        "[director-state] checkpoint write failed:",
+        err instanceof Error ? err.message : String(err)
+      );
+    } finally {
+      this.writing = false;
+      if (this.rewriteRequested) {
+        this.rewriteRequested = false;
+        this.schedule();
+      }
+    }
+  }
+};
 var DefaultPermissionPolicy = class {
   policy = {};
   loaded = false;
@@ -4476,6 +4837,18 @@ var DefaultPermissionPolicy = class {
     return void 0;
   }
 };
+var AutoApprovePermissionPolicy = class {
+  async evaluate(tool) {
+    if (tool.permission === "deny") {
+      return { permission: "deny", source: "default", reason: "tool default deny" };
+    }
+    return { permission: "auto", source: "yolo" };
+  }
+  async trust() {
+  }
+  async reload() {
+  }
+};
 var DefaultSkillLoader = class {
   dirs;
   cache;
@@ -4605,103 +4978,399 @@ function parseDescription(raw) {
   return { trigger, scope };
 }
 
-// src/execution/intelligent-compactor.ts
-var IntelligentCompactor = class {
-  provider;
-  warnThreshold;
-  softThreshold;
-  hardThreshold;
-  maxContext;
-  preserveK;
-  eliseThreshold;
-  summarizerPrompt;
-  summarizerModel;
-  constructor(opts) {
-    this.provider = opts.provider;
-    this.warnThreshold = opts.warnThreshold ?? 0.6;
-    this.softThreshold = opts.softThreshold ?? 0.75;
-    this.hardThreshold = opts.hardThreshold ?? 0.9;
-    this.maxContext = opts.maxContext ?? 128e3;
-    this.preserveK = opts.preserveK ?? 4;
-    this.eliseThreshold = opts.eliseThreshold ?? 500;
-    this.summarizerPrompt = opts.summarizerPrompt ?? "You are a context summarizer. Given a list of conversation messages, produce a concise but complete summary that preserves all factual information, decisions made, and any state changes (e.g. file edits, todo updates). Do not add commentary. Output only the summary.";
-    this.summarizerModel = opts.summarizerModel;
-  }
-  async compact(ctx, opts = {}) {
-    const beforeTokens = this.estimateTokens(ctx.messages);
-    const reductions = [];
-    const load = beforeTokens / this.maxContext;
-    const aggressive = load >= this.hardThreshold ? true : opts.aggressive ?? load >= this.softThreshold;
-    const saved1 = this.eliseOldToolResults(ctx);
-    if (saved1 > 0) reductions.push({ phase: "elision", saved: saved1 });
-    if (aggressive) {
-      const saved2 = await this.summarizeAncientTurns(ctx);
-      if (saved2 > 0) reductions.push({ phase: "summary", saved: saved2 });
-    } else if (load >= this.warnThreshold) {
-      const saved2 = this.lightweightCompact(ctx);
-      if (saved2 > 0) reductions.push({ phase: "elision", saved: saved2 });
-    }
-    const afterTokens = this.estimateTokens(ctx.messages);
-    return { before: beforeTokens, after: afterTokens, reductions };
-  }
-  async summarizeAncientTurns(ctx) {
-    const messages = ctx.messages;
-    const cutoff = Math.max(0, messages.length - this.preserveK * 2);
-    if (cutoff <= 2) return 0;
-    const boundary = this.findSafeBoundary(messages, 0, cutoff);
-    if (boundary <= 1) return 0;
-    const toSummarize = messages.slice(0, boundary);
-    const removedTokens = this.estimateTokens(toSummarize);
-    let summaryText;
-    try {
-      summaryText = await this.callSummarizer(toSummarize, ctx);
-    } catch {
-      summaryText = `[${toSummarize.length} earlier turns omitted \u2014 key decisions and file states preserved in context]`;
-    }
-    const summaryMsg = {
-      role: "system",
-      content: `[prior_turns_summary: ${summaryText}]`
-    };
-    const summaryTokens = this.estimateTokens([summaryMsg]);
-    const tail = ctx.messages.slice(boundary);
-    ctx.state.replaceMessages([summaryMsg, ...tail]);
-    return Math.max(0, removedTokens - summaryTokens);
-  }
-  findSafeBoundary(messages, from, to) {
-    for (let i = to; i >= from; i--) {
-      const m = messages[i];
-      if (!m) continue;
-      if (m.role === "user" && this.hasTextContent(m)) {
-        return this.findExchangeStart(messages, i);
+// src/core/streaming-response-builder.ts
+function buildResponse(state) {
+  const content = [];
+  for (const b of state.blockOrder) {
+    if (b.kind === "text") {
+      const txt = state.textBuffers[b.idx] ?? "";
+      if (txt) content.push({ type: "text", text: txt });
+    } else if (b.kind === "thinking") {
+      const t2 = state.thinking[b.idx];
+      if (!t2) continue;
+      if (!t2.textBuf && !t2.signature) continue;
+      const block = { type: "thinking", thinking: t2.textBuf };
+      if (t2.signature) block.signature = t2.signature;
+      if (t2.providerMeta && Object.keys(t2.providerMeta).length > 0) {
+        block.providerMeta = t2.providerMeta;
       }
-    }
-    return -1;
-  }
-  findExchangeStart(messages, userIndex) {
-    for (let i = userIndex - 1; i >= 0; i--) {
-      const m = messages[i];
-      if (!m) continue;
-      if (m.role === "assistant") {
-        const hasToolUse = Array.isArray(m.content) ? m.content.some((b) => b.type === "tool_use") : false;
-        if (!hasToolUse) {
-          return i + 1;
+      content.push(block);
+    } else {
+      const tb = state.tools.get(b.id);
+      if (tb) {
+        const block = {
+          type: "tool_use",
+          id: b.id,
+          name: tb.name,
+          input: tb.input ?? {}
+        };
+        if (tb.providerMeta && Object.keys(tb.providerMeta).length > 0) {
+          block.providerMeta = tb.providerMeta;
         }
-      } else if (m.role !== "user") ; else {
-        return i;
+        content.push(block);
       }
     }
-    return 0;
   }
-  async callSummarizer(messages, ctx) {
-    const prompt = [
-      { type: "text", text: this.summarizerPrompt },
-      { type: "text", text: "\n\nConversation to summarize:\n" },
-      ...this.messagesToText(messages)
-    ];
-    const req = {
-      model: this.summarizerModel ?? ctx.model,
-      system: prompt,
-      messages: [],
+  if (content.length === 0) content.push({ type: "text", text: "" });
+  return { content, stopReason: state.stopReason, usage: state.usage, model: state.model };
+}
+function createStreamingState(model) {
+  return {
+    model,
+    stopReason: "end_turn",
+    usage: { input: 0, output: 0 },
+    textBuffers: [],
+    currentTextIndex: -1,
+    tools: /* @__PURE__ */ new Map(),
+    thinking: [],
+    currentThinkingIndex: -1,
+    blockOrder: []
+  };
+}
+function handleMessageStart(state, model) {
+  state.model = model;
+}
+function handleContentBlockStart(state, ev) {
+  const kind = ev.kind ?? "text";
+  if (kind === "text") {
+    state.currentTextIndex = state.textBuffers.length;
+    state.textBuffers.push("");
+    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+  } else if (kind === "tool_use") {
+    const id = ev.id ?? crypto.randomUUID();
+    state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
+    state.blockOrder.push({ kind: "tool", id });
+    state.currentTextIndex = -1;
+  } else if (kind === "thinking") {
+    state.currentThinkingIndex = state.thinking.length;
+    state.thinking.push({
+      textBuf: "",
+      ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+    });
+    state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
+    state.currentTextIndex = -1;
+  }
+}
+function handleContentBlockStop(state, ev) {
+}
+function handleTextDelta(state, text) {
+  if (state.currentTextIndex === -1) {
+    state.currentTextIndex = state.textBuffers.length;
+    state.textBuffers.push("");
+    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+  }
+  state.textBuffers[state.currentTextIndex] = (state.textBuffers[state.currentTextIndex] ?? "") + text;
+}
+function handleToolUseStart(state, ev) {
+  state.currentTextIndex = -1;
+  state.tools.set(ev.id, { name: ev.name, partial: "" });
+  state.blockOrder.push({ kind: "tool", id: ev.id });
+}
+function handleToolUseInputDelta(state, ev) {
+  const t2 = state.tools.get(ev.id);
+  if (t2) t2.partial += ev.partial;
+}
+function safeJsonOrRaw(s) {
+  if (!s) return {};
+  try {
+    return JSON.parse(s);
+  } catch {
+    return { _raw: s };
+  }
+}
+function handleToolUseStop(state, ev) {
+  const t2 = state.tools.get(ev.id);
+  if (t2) {
+    t2.input = ev.input !== void 0 ? ev.input : safeJsonOrRaw(t2.partial);
+    if (ev.providerMeta) t2.providerMeta = ev.providerMeta;
+  }
+  state.currentTextIndex = -1;
+}
+function handleThinkingStart(state, ev) {
+  state.currentThinkingIndex = state.thinking.length;
+  state.thinking.push({
+    textBuf: "",
+    ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+  });
+  state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
+  state.currentTextIndex = -1;
+}
+function handleThinkingDelta(state, text) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
+  }
+  const t2 = state.thinking[state.currentThinkingIndex];
+  if (t2) t2.textBuf += text;
+}
+function handleThinkingSignature(state, signature) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
+  }
+  const t2 = state.thinking[state.currentThinkingIndex];
+  if (t2) t2.signature = signature;
+}
+function handleThinkingStop(state) {
+  state.currentThinkingIndex = -1;
+}
+function handleMessageStop(state, ev) {
+  state.stopReason = ev.stopReason ?? "end_turn";
+  state.usage = ev.usage ?? { input: 0, output: 0 };
+}
+async function streamProviderToResponse(provider, req, signal, ctx, events) {
+  const state = createStreamingState(req.model);
+  const iter = provider.stream(req, { signal })[Symbol.asyncIterator]();
+  try {
+    for (; ; ) {
+      const next = await iter.next();
+      if (next.done) break;
+      const ev = next.value;
+      switch (ev.type) {
+        case "message_start":
+          handleMessageStart(state, ev.model);
+          break;
+        case "content_block_start":
+          handleContentBlockStart(state, ev);
+          break;
+        case "content_block_stop":
+          handleContentBlockStop(state, ev);
+          break;
+        case "text_delta":
+          handleTextDelta(state, ev.text);
+          events.emit("provider.text_delta", { ctx, text: ev.text });
+          break;
+        case "tool_use_start":
+          handleToolUseStart(state, ev);
+          events.emit("provider.tool_use_start", { ctx, id: ev.id, name: ev.name });
+          break;
+        case "tool_use_input_delta":
+          handleToolUseInputDelta(state, ev);
+          break;
+        case "tool_use_stop":
+          handleToolUseStop(state, ev);
+          events.emit("provider.tool_use_stop", { ctx, id: ev.id });
+          break;
+        case "thinking_start":
+          handleThinkingStart(state, ev);
+          break;
+        case "thinking_delta":
+          handleThinkingDelta(state, ev.text);
+          events.emit("provider.thinking_delta", { ctx, text: ev.text });
+          break;
+        case "thinking_signature":
+          handleThinkingSignature(state, ev.signature);
+          break;
+        case "thinking_stop":
+          handleThinkingStop(state);
+          break;
+        case "message_stop":
+          handleMessageStop(state, ev);
+          break;
+      }
+    }
+  } catch (err) {
+    if (signal.aborted) {
+      state.stopReason = "end_turn";
+      return buildResponse(state);
+    }
+    throw err;
+  } finally {
+    try {
+      let drainTimer = null;
+      try {
+        await Promise.race([
+          Promise.resolve(iter.return?.()),
+          new Promise((resolve4) => {
+            drainTimer = setTimeout(resolve4, 500);
+          })
+        ]);
+      } finally {
+        if (drainTimer) clearTimeout(drainTimer);
+      }
+    } catch {
+    }
+  }
+  return buildResponse(state);
+}
+
+// src/core/provider-runner.ts
+async function runProviderWithRetry(opts) {
+  const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
+  let attempt = 0;
+  for (; ; ) {
+    const span = tracer?.startSpan("provider.complete", {
+      "provider.id": provider.id,
+      "provider.model": request.model,
+      "provider.streaming": provider.capabilities.streaming,
+      "provider.attempt": attempt
+    });
+    try {
+      const res = provider.capabilities.streaming ? await streamProviderToResponse(provider, request, signal, ctx, events) : await provider.complete(request, { signal });
+      span?.setAttribute("provider.stopReason", res.stopReason);
+      span?.setAttribute("provider.usage_in", res.usage.input);
+      span?.setAttribute("provider.usage_out", res.usage.output);
+      span?.end();
+      return res;
+    } catch (err) {
+      if (err instanceof Error) span?.recordError(err);
+      span?.end();
+      if (signal.aborted) throw err;
+      const isProviderErr = err instanceof ProviderError;
+      const errAsErr = err instanceof Error ? err : new Error(String(err));
+      const canRetry = retry.shouldRetry(isProviderErr ? err : errAsErr, attempt);
+      const description = isProviderErr ? err.describe() : errAsErr.message;
+      if (!canRetry) {
+        if (isProviderErr) {
+          events.emit("provider.error", {
+            providerId: err.providerId,
+            status: err.status,
+            description,
+            retryable: false
+          });
+        }
+        throw err;
+      }
+      const delay = Math.round(retry.delayMs(attempt));
+      const attemptNum = attempt + 1;
+      logger.warn(`Provider retry ${attemptNum} in ${delay}ms \u2014 ${description}`);
+      if (isProviderErr) {
+        events.emit("provider.retry", {
+          providerId: err.providerId,
+          attempt: attemptNum,
+          delayMs: delay,
+          status: err.status,
+          description
+        });
+      }
+      await new Promise((resolve4, reject) => {
+        let settled = false;
+        const onAbort = () => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(t2);
+          reject(new Error("aborted"));
+        };
+        const t2 = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(t2);
+          signal.removeEventListener("abort", onAbort);
+          resolve4();
+        }, delay);
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      });
+      attempt++;
+    }
+  }
+}
+
+// src/execution/provider-runner-impl.ts
+var DefaultProviderRunner = class {
+  async run(opts) {
+    return runProviderWithRetry(opts);
+  }
+};
+
+// src/execution/intelligent-compactor.ts
+var IntelligentCompactor = class {
+  provider;
+  warnThreshold;
+  softThreshold;
+  hardThreshold;
+  maxContext;
+  preserveK;
+  eliseThreshold;
+  summarizerPrompt;
+  summarizerModel;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.warnThreshold = opts.warnThreshold ?? 0.6;
+    this.softThreshold = opts.softThreshold ?? 0.75;
+    this.hardThreshold = opts.hardThreshold ?? 0.9;
+    this.maxContext = opts.maxContext ?? 128e3;
+    this.preserveK = opts.preserveK ?? 4;
+    this.eliseThreshold = opts.eliseThreshold ?? 500;
+    this.summarizerPrompt = opts.summarizerPrompt ?? "You are a context summarizer. Given a list of conversation messages, produce a concise but complete summary that preserves all factual information, decisions made, and any state changes (e.g. file edits, todo updates). Do not add commentary. Output only the summary.";
+    this.summarizerModel = opts.summarizerModel;
+  }
+  async compact(ctx, opts = {}) {
+    const beforeTokens = this.estimateTokens(ctx.messages);
+    const reductions = [];
+    const load = beforeTokens / this.maxContext;
+    const aggressive = load >= this.hardThreshold ? true : opts.aggressive ?? load >= this.softThreshold;
+    const saved1 = this.eliseOldToolResults(ctx);
+    if (saved1 > 0) reductions.push({ phase: "elision", saved: saved1 });
+    if (aggressive) {
+      const saved2 = await this.summarizeAncientTurns(ctx);
+      if (saved2 > 0) reductions.push({ phase: "summary", saved: saved2 });
+    } else if (load >= this.warnThreshold) {
+      const saved2 = this.lightweightCompact(ctx);
+      if (saved2 > 0) reductions.push({ phase: "elision", saved: saved2 });
+    }
+    const afterTokens = this.estimateTokens(ctx.messages);
+    return { before: beforeTokens, after: afterTokens, reductions };
+  }
+  async summarizeAncientTurns(ctx) {
+    const messages = ctx.messages;
+    const cutoff = Math.max(0, messages.length - this.preserveK * 2);
+    if (cutoff <= 2) return 0;
+    const boundary = this.findSafeBoundary(messages, 0, cutoff);
+    if (boundary <= 1) return 0;
+    const toSummarize = messages.slice(0, boundary);
+    const removedTokens = this.estimateTokens(toSummarize);
+    let summaryText;
+    try {
+      summaryText = await this.callSummarizer(toSummarize, ctx);
+    } catch {
+      summaryText = `[${toSummarize.length} earlier turns omitted \u2014 key decisions and file states preserved in context]`;
+    }
+    const summaryMsg = {
+      role: "system",
+      content: `[prior_turns_summary: ${summaryText}]`
+    };
+    const summaryTokens = this.estimateTokens([summaryMsg]);
+    const tail = ctx.messages.slice(boundary);
+    ctx.state.replaceMessages([summaryMsg, ...tail]);
+    return Math.max(0, removedTokens - summaryTokens);
+  }
+  findSafeBoundary(messages, from, to) {
+    for (let i = to; i >= from; i--) {
+      const m = messages[i];
+      if (!m) continue;
+      if (m.role === "user" && this.hasTextContent(m)) {
+        return this.findExchangeStart(messages, i);
+      }
+    }
+    return -1;
+  }
+  findExchangeStart(messages, userIndex) {
+    for (let i = userIndex - 1; i >= 0; i--) {
+      const m = messages[i];
+      if (!m) continue;
+      if (m.role === "assistant") {
+        const hasToolUse = Array.isArray(m.content) ? m.content.some((b) => b.type === "tool_use") : false;
+        if (!hasToolUse) {
+          return i + 1;
+        }
+      } else if (m.role !== "user") ; else {
+        return i;
+      }
+    }
+    return 0;
+  }
+  async callSummarizer(messages, ctx) {
+    const prompt = [
+      { type: "text", text: this.summarizerPrompt },
+      { type: "text", text: "\n\nConversation to summarize:\n" },
+      ...this.messagesToText(messages)
+    ];
+    const req = {
+      model: this.summarizerModel ?? ctx.model,
+      system: prompt,
+      messages: [],
       maxTokens: 1024
     };
     const ac = ctx.signal ? void 0 : new AbortController();
@@ -5516,6 +6185,10 @@ var FleetBus = class {
       "iteration.started",
       "iteration.completed",
       "provider.text_delta",
+      // Subagent extended-thinking output. Forwarded so the FleetPanel /
+      // /fleet log can surface "the planner is thinking…" instead of a
+      // silent gap between iteration.started and the first text_delta.
+      "provider.thinking_delta",
       "provider.response",
       "provider.retry",
       "provider.error",
@@ -5764,14 +6437,34 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   completedResults = [];
   totalIterations = 0;
   inFlight = 0;
+  /**
+   * Subagents currently being stopped. Set on entry to `stop()`, cleared
+   * once `recordCompletion` lands the terminal TaskResult. Used by
+   * `runDispatched` and `findIdleSubagent` to refuse mid-flight dispatch
+   * to a subagent the caller has already asked to terminate — closes the
+   * assign+terminate race where a fresh task could land on a worker that
+   * was about to be killed.
+   */
+  terminating = /* @__PURE__ */ new Set();
   constructor(config, options = {}) {
     super();
     this.coordinatorId = config.coordinatorId;
     this.config = config;
     this.runner = options.runner;
   }
+  /**
+   * Replace the runner after construction. Used when the runner depends
+   * on infrastructure (e.g. FleetBus) that isn't available until after
+   * the coordinator's owning Director is built.
+   */
+  setRunner(runner) {
+    this.runner = runner;
+  }
   async spawn(subagent) {
     const id = subagent.id || randomUUID();
+    if (this.subagents.has(id)) {
+      throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
+    }
     const context = {
       subagentId: id,
       tasks: [],
@@ -5815,6 +6508,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   async stop(subagentId) {
     const subagent = this.subagents.get(subagentId);
     if (!subagent) return;
+    this.terminating.add(subagentId);
     subagent.abortController.abort();
     subagent.status = "stopped";
     subagent.currentTask = void 0;
@@ -5822,6 +6516,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
   }
   async stopAll() {
+    this.drainPendingAsAborted("Coordinator stopAll() drained the pending queue");
     await Promise.allSettled([...this.subagents.keys()].map((id) => this.stop(id)));
   }
   getStatus() {
@@ -5855,7 +6550,14 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   tryDispatchNext() {
     while (this.canDispatch()) {
       const subagentId = this.findIdleSubagent();
-      if (!subagentId) return;
+      if (!subagentId) {
+        if (this.pendingTasks.length > 0 && !this.hasLiveSubagent()) {
+          this.drainPendingAsAborted(
+            "No live subagent available \u2014 all stopped or mid-termination"
+          );
+        }
+        return;
+      }
       const task = this.pendingTasks.shift();
       if (!task) return;
       this.runDispatched(subagentId, task).catch((err) => {
@@ -5863,7 +6565,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
           subagentId,
           taskId: task.id,
           status: "failed",
-          error: err instanceof Error ? err.message : String(err),
+          error: classifySubagentError(err),
           iterations: 0,
           toolCalls: 0,
           durationMs: 0
@@ -5877,13 +6579,76 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   }
   findIdleSubagent() {
     for (const [id, s] of this.subagents) {
-      if (s.status === "idle") return id;
+      if (s.status === "idle" && !this.terminating.has(id)) return id;
     }
     return null;
   }
+  /**
+   * Returns true iff at least one spawned subagent could still
+   * process a task. A "live" subagent is one that is not stopped
+   * AND not mid-termination — `running` workers count because they
+   * will eventually finish and become idle.
+   *
+   * When no subagent has ever been spawned, returns `true` so a
+   * pre-spawn `assign()` simply queues (legacy behaviour). The
+   * dead-end detection only fires after `stop()` has retired every
+   * spawned worker.
+   *
+   * Used by `tryDispatchNext` to detect a dead-end pending queue.
+   */
+  hasLiveSubagent() {
+    if (this.subagents.size === 0) return true;
+    for (const [id, s] of this.subagents) {
+      if (s.status !== "stopped" && !this.terminating.has(id)) return true;
+    }
+    return false;
+  }
+  /**
+   * Drain every pending task with a synthetic `aborted_by_parent`
+   * completion event. Same shape as the `stopAll()` drain — we go
+   * around `recordCompletion` because pending tasks were never
+   * counted in `inFlight` and routing them through would trip the
+   * underflow guard on every task after the first.
+   */
+  drainPendingAsAborted(message) {
+    const dropped = this.pendingTasks.splice(0, this.pendingTasks.length);
+    for (const t2 of dropped) {
+      const synthetic = {
+        subagentId: t2.subagentId ?? "unassigned",
+        taskId: t2.id,
+        status: "stopped",
+        error: {
+          kind: "aborted_by_parent",
+          message,
+          retryable: false
+        },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      };
+      this.completedResults.push(synthetic);
+      this.emit("task.completed", { task: t2, result: synthetic });
+    }
+  }
   async runDispatched(subagentId, task) {
     const subagent = this.subagents.get(subagentId);
     if (!subagent) return;
+    if (this.terminating.has(subagentId) || subagent.status === "stopped") {
+      this.recordCompletion({
+        subagentId,
+        taskId: task.id,
+        status: "stopped",
+        error: {
+          kind: "aborted_by_parent",
+          message: "Subagent was terminated before task could start",
+          retryable: false
+        },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      });
+      return;
+    }
     subagent.status = "running";
     subagent.currentTask = task.id;
     task.subagentId = subagentId;
@@ -5929,7 +6694,9 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
         subagentId,
         taskId: task.id,
         status,
-        error: err instanceof Error ? err.message : String(err),
+        error: classifySubagentError(err, {
+          parentAborted: subagent.abortController.signal.aborted
+        }),
         iterations: usage.iterations,
         toolCalls: usage.toolCalls,
         durationMs: Date.now() - startTime
@@ -5968,19 +6735,14 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     }
     const subagent = this.subagents.get(result.subagentId);
     if (subagent && subagent.status !== "stopped") {
-      const failed = result.status === "failed" || result.status === "timeout";
-      subagent.status = failed ? "error" : "idle";
+      result.status === "failed" || result.status === "timeout";
+      subagent.status = "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";
-          this.tryDispatchNext();
-        });
-      }
     }
+    this.terminating.delete(result.subagentId);
     this.emit("task.completed", {
       task: subagent?.context.tasks.find((t2) => t2.id === result.taskId) ?? { id: result.taskId },
       result
@@ -6003,6 +6765,99 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     return false;
   }
 };
+function classifySubagentError(err, hints = {}) {
+  const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
+  const baseMessage = err instanceof Error ? err.message : String(err);
+  if (err instanceof ProviderError) {
+    return providerErrorToSubagentError(err, baseMessage, cause);
+  }
+  if (err instanceof BudgetExceededError) {
+    const map = {
+      iterations: "budget_iterations",
+      tool_calls: "budget_tool_calls",
+      tokens: "budget_tokens",
+      cost: "budget_cost",
+      timeout: "budget_timeout"
+    };
+    return {
+      kind: map[err.kind],
+      message: baseMessage,
+      // Budgets are user-configured ceilings, not transient failures —
+      // retrying with the same budget will hit the same ceiling. The
+      // orchestrator must raise the budget or narrow the task first.
+      retryable: false,
+      cause
+    };
+  }
+  if (hints.parentAborted) {
+    return {
+      kind: "aborted_by_parent",
+      message: baseMessage,
+      retryable: false,
+      cause
+    };
+  }
+  const lower = baseMessage.toLowerCase();
+  if (/agent aborted$/i.test(baseMessage)) {
+    return {
+      kind: "aborted_by_parent",
+      message: baseMessage,
+      retryable: false,
+      cause
+    };
+  }
+  if (/agent exhausted iteration limit$/i.test(baseMessage)) {
+    return { kind: "budget_iterations", message: baseMessage, retryable: false, cause };
+  }
+  if (/empty response$/i.test(baseMessage)) {
+    return { kind: "empty_response", message: baseMessage, retryable: false, cause };
+  }
+  if (/^tool failed: /i.test(baseMessage)) {
+    return { kind: "tool_failed", message: baseMessage, retryable: false, cause };
+  }
+  if (lower.includes("bridge transport") || /bridge.*(closed|disconnect)/i.test(baseMessage)) {
+    return { kind: "bridge_failed", message: baseMessage, retryable: false, cause };
+  }
+  if (/context length|max.*tokens?.*exceeded|prompt is too long/i.test(baseMessage)) {
+    return { kind: "context_overflow", message: baseMessage, retryable: false, cause };
+  }
+  return {
+    kind: "unknown",
+    message: baseMessage,
+    retryable: false,
+    cause
+  };
+}
+function providerErrorToSubagentError(err, message, cause) {
+  const status = err.status;
+  if (status === 429 || err.body?.type === "rate_limit_error") {
+    return {
+      kind: "provider_rate_limit",
+      message,
+      retryable: true,
+      // Conservative default: 5s. Provider-specific code can override
+      // by emitting an error whose body carries an explicit hint.
+      backoffMs: 5e3,
+      cause
+    };
+  }
+  if (status === 401 || status === 403 || err.body?.type === "authentication_error") {
+    return { kind: "provider_auth", message, retryable: false, cause };
+  }
+  if (status === 408 || status === 0) {
+    return { kind: "provider_timeout", message, retryable: true, cause };
+  }
+  if (status >= 500 && status < 600) {
+    return {
+      kind: "provider_5xx",
+      message,
+      retryable: true,
+      backoffMs: 3e3,
+      cause
+    };
+  }
+  return { kind: "unknown", message, retryable: err.retryable, cause };
+}
 
 // src/coordination/director.ts
 var DirectorBudgetError = class extends Error {
@@ -6066,6 +6921,27 @@ var Director = class {
   spawnDepth;
   /** Live spawn counter for `maxSpawns` enforcement. */
   spawnCount = 0;
+  /** Optional checkpoint mirror — writes the live task graph + roster to disk. */
+  stateCheckpoint;
+  /** Optional session writer for emitting task_* / agent_* lifecycle events. */
+  sessionWriter;
+  /** Debounce timer for periodic manifest writes. */
+  manifestTimer = null;
+  manifestDebounceMs;
+  /** Resolves task descriptions back from `assign()` so completion events
+   *  can also carry a human-readable title. */
+  taskDescriptions = /* @__PURE__ */ new Map();
+  /** Snapshot of which subagent owns each task — drives state-checkpoint
+   *  status updates without re-walking the manifest. */
+  taskOwners = /* @__PURE__ */ new Map();
+  /**
+   * Handle to the coordinator-side `task.completed` listener so we can
+   * unsubscribe in `shutdown()`. Without this, repeated Director
+   * construction (e.g. tests, hot reloads) accumulates listeners on a
+   * cached coordinator and slowly drifts the EventEmitter past its
+   * default cap.
+   */
+  taskCompletedListener = null;
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID();
     this.manifestPath = opts.manifestPath;
@@ -6076,6 +6952,14 @@ var Director = class {
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
     this.spawnDepth = opts.spawnDepth ?? 0;
+    this.sessionWriter = opts.sessionWriter ?? null;
+    this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
+    this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
+      directorRunId: this.id,
+      maxSpawns: opts.maxSpawns,
+      spawnDepth: this.spawnDepth,
+      maxSpawnDepth: this.maxSpawnDepth
+    }) : null;
     if (this.sharedScratchpadPath) {
       void fsp2.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(() => void 0);
     }
@@ -6094,7 +6978,7 @@ var Director = class {
       { ...opts.config, coordinatorId: this.id },
       { runner: opts.runner }
     );
-    this.coordinator.on("task.completed", (payload) => {
+    this.taskCompletedListener = (payload) => {
       const r = payload.result;
       this.completed.set(r.taskId, r);
       const waiter = this.taskWaiters.get(r.taskId);
@@ -6102,7 +6986,54 @@ var Director = class {
         waiter.resolve(r);
         this.taskWaiters.delete(r.taskId);
       }
-    });
+      const title = this.taskDescriptions.get(r.taskId) ?? payload.task.description ?? r.taskId;
+      const failed = r.status !== "success";
+      const errorString = r.error ? `${r.error.kind}: ${r.error.message}` : void 0;
+      this.stateCheckpoint?.recordTaskStatus(r.taskId, {
+        status: failed ? r.status : "completed",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        iterations: r.iterations,
+        toolCalls: r.toolCalls,
+        durationMs: r.durationMs,
+        error: errorString
+      });
+      this.stateCheckpoint?.setUsage(this.usage.snapshot());
+      void this.appendSessionEvent(
+        failed ? {
+          type: "task_failed",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          taskId: r.taskId,
+          title,
+          error: errorString ?? r.status
+        } : {
+          type: "task_completed",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          taskId: r.taskId,
+          title
+        }
+      );
+      this.scheduleManifest();
+    };
+    this.coordinator.on("task.completed", this.taskCompletedListener);
+  }
+  /** Best-effort session-writer append. Swallows failures — the director
+   *  must not break a fleet run because the session JSONL handle closed. */
+  async appendSessionEvent(event) {
+    if (!this.sessionWriter) return;
+    try {
+      await this.sessionWriter.append(event);
+    } catch {
+    }
+  }
+  /** Debounced manifest writer. A burst of spawn/assign/complete events
+   *  collapses into one write. Set `manifestDebounceMs` to 0 to disable. */
+  scheduleManifest() {
+    if (!this.manifestPath || this.manifestDebounceMs <= 0) return;
+    if (this.manifestTimer) return;
+    this.manifestTimer = setTimeout(() => {
+      this.manifestTimer = null;
+      void this.writeManifest().catch(() => void 0);
+    }, this.manifestDebounceMs);
   }
   /**
    * Spawn a subagent. Identical to the coordinator's `spawn()` but
@@ -6141,6 +7072,25 @@ var Director = class {
       model: config.model,
       taskIds: []
     });
+    const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.stateCheckpoint?.recordSpawn(
+      {
+        id: result.subagentId,
+        name: config.name,
+        role: config.role,
+        provider: config.provider,
+        model: config.model,
+        spawnedAt
+      },
+      this.spawnCount
+    );
+    void this.appendSessionEvent({
+      type: "agent_spawned",
+      ts: spawnedAt,
+      agentId: result.subagentId,
+      role: config.role ?? config.name
+    });
+    this.scheduleManifest();
     return result.subagentId;
   }
   /**
@@ -6261,13 +7211,42 @@ var Director = class {
    * — calling shutdown twice is a no-op on the second invocation.
    */
   async shutdown() {
+    if (this.manifestTimer) {
+      clearTimeout(this.manifestTimer);
+      this.manifestTimer = null;
+    }
+    if (this.taskCompletedListener) {
+      this.coordinator.off("task.completed", this.taskCompletedListener);
+      this.taskCompletedListener = null;
+    }
     await this.coordinator.stopAll();
     for (const b of this.subagentBridges.values()) {
-      await b.stop().catch(() => void 0);
+      await b.stop().catch((err) => this.logShutdownError("subagent_bridge_stop", err));
     }
     this.subagentBridges.clear();
-    await this.bridge.stop().catch(() => void 0);
-    if (this.manifestPath) await this.writeManifest().catch(() => void 0);
+    await this.bridge.stop().catch((err) => this.logShutdownError("director_bridge_stop", err));
+    if (this.manifestPath)
+      await this.writeManifest().catch((err) => this.logShutdownError("manifest_write", err));
+    if (this.stateCheckpoint) {
+      this.stateCheckpoint.setUsage(this.usage.snapshot());
+      await this.stateCheckpoint.flush().catch((err) => this.logShutdownError("state_checkpoint_flush", err));
+    }
+  }
+  /**
+   * Funnel for shutdown-phase errors. We can't throw — `shutdown()` is
+   * called from process-exit paths where an uncaught throw would lose
+   * the manifest write that comes after. But we MUST NOT silently
+   * swallow either — a persistent bridge-close failure would otherwise
+   * mask a real bug. `process.emitWarning` is the right tier:
+   * surfaces on stderr by default, lets the host plug a warning
+   * listener for structured collection, and never affects exit code.
+   */
+  logShutdownError(phase, err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    process.emitWarning(
+      `Director shutdown phase "${phase}" failed: ${detail}`,
+      "DirectorShutdownWarning"
+    );
   }
   /**
    * Hand a task to the coordinator. Returns the assigned task id so
@@ -6281,6 +7260,23 @@ var Director = class {
       if (entry) entry.taskIds.push(taskWithId.id);
     }
     await this.coordinator.assign(taskWithId);
+    this.taskDescriptions.set(taskWithId.id, taskWithId.description);
+    if (taskWithId.subagentId) this.taskOwners.set(taskWithId.id, taskWithId.subagentId);
+    const assignedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.stateCheckpoint?.recordTaskAssigned({
+      taskId: taskWithId.id,
+      subagentId: taskWithId.subagentId,
+      description: taskWithId.description,
+      status: "running",
+      assignedAt
+    });
+    void this.appendSessionEvent({
+      type: "task_created",
+      ts: assignedAt,
+      taskId: taskWithId.id,
+      title: taskWithId.description
+    });
+    this.scheduleManifest();
     return taskWithId.id;
   }
   /**
@@ -6340,6 +7336,23 @@ var Director = class {
   snapshot() {
     return this.usage.snapshot();
   }
+  /**
+   * Look up provider/model metadata for a spawned subagent. Returns
+   * undefined when the subagent id is unknown (not yet spawned, or
+   * already torn down). Callers — notably the TUI fleet panel — use
+   * this to render human-readable provider/model tags next to each
+   * subagent row without reaching into private state.
+   */
+  getSubagentMeta(id) {
+    const usage = this.subagentMeta.get(id);
+    const manifest = this.manifestEntries.get(id);
+    if (!usage && !manifest) return void 0;
+    return {
+      provider: usage?.provider ?? manifest?.provider,
+      model: usage?.model ?? manifest?.model,
+      name: manifest?.name
+    };
+  }
   /**
    * Compose the leader/director-agent system prompt: fleet preamble +
    * (optional) roster summary + user base prompt. Pass the result to your
@@ -6639,12 +7652,260 @@ function makeFleetUsageTool(director) {
     }
   };
 }
+function createDelegateTool(opts) {
+  const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
+  const rosterIds = opts.roster ? Object.keys(opts.roster) : [];
+  const inputSchema = {
+    type: "object",
+    properties: {
+      task: {
+        type: "string",
+        description: "What the subagent should do \u2014 natural language, complete sentence(s). The subagent has its own tool slice, its own LLM call, and returns when its task is done."
+      },
+      role: {
+        type: "string",
+        description: rosterIds.length > 0 ? `Roster role (preferred). One of: ${rosterIds.join(", ")}. Picks a pre-tuned config (prompt, budgets, tools) for that role.` : "No roster is configured \u2014 pass `name` instead.",
+        enum: rosterIds.length > 0 ? rosterIds : void 0
+      },
+      name: {
+        type: "string",
+        description: "Display name for the subagent when not using a roster role. Required when `role` is omitted."
+      },
+      provider: {
+        type: "string",
+        description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the host provider when omitted.'
+      },
+      model: {
+        type: "string",
+        description: "Model id within the provider. Defaults to the host model when omitted."
+      },
+      systemPromptOverride: {
+        type: "string",
+        description: "Optional extra prompt text appended to the role baseline."
+      },
+      timeoutMs: {
+        type: "number",
+        description: `Wall-clock budget for this delegate in milliseconds. No hard cap \u2014 set as high as the task realistically needs (a monorepo audit can take hours, a single-file lint takes seconds). Default ${Math.round(defaultTimeoutMs / 1e3 / 60)} minutes.`
+      },
+      maxIterations: {
+        type: "number",
+        description: "Maximum LLM iterations the subagent may take. Unset = use the role/coordinator default. Raise this for tasks with many tool-think-tool cycles (deep code analysis, multi-file refactors)."
+      },
+      maxToolCalls: {
+        type: "number",
+        description: "Maximum number of tool invocations the subagent may make. Unset = use the role/coordinator default. Raise this for tasks that touch many files (large grep + read + report)."
+      }
+    },
+    required: ["task"]
+  };
+  return {
+    name: "delegate",
+    description: "Hand a discrete piece of work to a dedicated subagent and wait for its result. The subagent has its own context, its own LLM call, and its own budget \u2014 use this when a task is self-contained, would otherwise blow up your context, or benefits from a specialized role (bug-hunter, security-scanner, refactor-planner, audit-log). YOU decide how big the budget is: pass `timeoutMs`, `maxIterations`, and `maxToolCalls` sized to the actual work. There is no hidden cap forcing a 3-minute / 80-iteration limit \u2014 if a monorepo audit needs 2 hours and 500 tool calls, ask for that. Call multiple delegates in parallel through the provider's parallel-tool-call surface to fan work out across roles.",
+    usageHint: "Set `task` to a complete instruction. Either pick `role` from the roster or pass `name` + `provider` + `model`. For non-trivial work, also pass `timeoutMs` (the wall-clock budget you actually need), `maxIterations`, and `maxToolCalls` \u2014 defaults are intentionally generous (4 hours) but the right values depend on scope. Returns the subagent's `TaskResult` \u2014 including the textual `result`, iteration count, tool count, and duration. Auto-promotes the host into director mode on first call.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input ?? {};
+      if (typeof i.task !== "string" || !i.task.trim()) {
+        return { ok: false, error: "`task` is required." };
+      }
+      let director = await opts.host.ensureDirector();
+      if (!director) {
+        director = await opts.host.promoteToDirector();
+      }
+      if (!director) {
+        const reason = opts.host.getPromotionBlockReason?.();
+        return {
+          ok: false,
+          error: reason ?? "Director could not be activated \u2014 multi-agent host already running in legacy non-director mode. Restart with `--director` for fleet support."
+        };
+      }
+      const timeoutMs = i.timeoutMs ?? defaultTimeoutMs;
+      let cfg;
+      if (i.role) {
+        const base = opts.roster?.[i.role];
+        if (!base) {
+          return {
+            ok: false,
+            error: `Unknown role "${i.role}". Available: ${rosterIds.join(", ") || "(no roster configured)"}.`
+          };
+        }
+        cfg = { ...base };
+        if (i.systemPromptOverride) cfg.systemPromptOverride = i.systemPromptOverride;
+        if (i.provider) cfg.provider = i.provider;
+        if (i.model) cfg.model = i.model;
+      } else {
+        if (!i.name) {
+          return {
+            ok: false,
+            error: "Either `role` (from the roster) or `name` is required."
+          };
+        }
+        cfg = {
+          name: i.name,
+          provider: i.provider,
+          model: i.model,
+          systemPromptOverride: i.systemPromptOverride
+        };
+      }
+      if (typeof i.maxIterations === "number" && i.maxIterations > 0) {
+        cfg.maxIterations = i.maxIterations;
+      }
+      if (typeof i.maxToolCalls === "number" && i.maxToolCalls > 0) {
+        cfg.maxToolCalls = i.maxToolCalls;
+      }
+      const SUBAGENT_TIMEOUT_BUFFER_MS = 3e4;
+      const desiredSubTimeout = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
+      if (!cfg.timeoutMs || cfg.timeoutMs > desiredSubTimeout) {
+        cfg.timeoutMs = desiredSubTimeout;
+      }
+      try {
+        const subagentId = await director.spawn(cfg);
+        const taskId = await director.assign({
+          id: "",
+          description: i.task,
+          subagentId
+        });
+        const result = await Promise.race([
+          director.awaitTasks([taskId]).then((r) => r[0]),
+          new Promise(
+            (resolve4) => setTimeout(() => resolve4({ __timeout: true }), timeoutMs)
+          )
+        ]);
+        if ("__timeout" in result) {
+          const partial2 = await readSubagentPartial(opts, subagentId);
+          return {
+            ok: false,
+            stopReason: "host_timeout",
+            error: `Subagent did not finish within ${timeoutMs}ms.`,
+            hint: "Reduce scope of the next delegate, raise timeoutMs, or use spawn_subagent + await_tasks for long-running work.",
+            subagentId,
+            taskId,
+            partial: partial2
+          };
+        }
+        const baseStopReason = result.status === "success" ? "end_turn" : result.status === "timeout" ? "subagent_timeout" : result.status === "stopped" ? "aborted" : "budget_exhausted";
+        const partial = result.status === "success" ? void 0 : await readSubagentPartial(opts, subagentId);
+        const errorKind = result.error?.kind;
+        const retryable = result.error?.retryable;
+        const backoffMs = result.error?.backoffMs;
+        return {
+          ok: result.status === "success",
+          status: result.status,
+          stopReason: baseStopReason,
+          errorKind,
+          retryable,
+          backoffMs,
+          subagentId: result.subagentId,
+          taskId: result.taskId,
+          result: result.result,
+          error: result.error,
+          iterations: result.iterations,
+          toolCalls: result.toolCalls,
+          durationMs: result.durationMs,
+          ...partial ? { partial } : {},
+          ...hintForKind(errorKind, retryable, backoffMs) ? { hint: hintForKind(errorKind, retryable, backoffMs) } : {}
+        };
+      } catch (err) {
+        return {
+          ok: false,
+          stopReason: "error",
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+  };
+}
+function hintForKind(kind, retryable, backoffMs) {
+  if (!kind) return void 0;
+  switch (kind) {
+    case "provider_rate_limit":
+      return `Provider rate-limited. Retry safe after ${backoffMs ?? 5e3}ms backoff. Consider a smaller model or fewer parallel delegates.`;
+    case "provider_5xx":
+      return `Provider server error. Retry safe after ${backoffMs ?? 3e3}ms backoff \u2014 usually transient.`;
+    case "provider_timeout":
+      return "Provider network timeout. Retry safe; reduce input size if it persists.";
+    case "provider_auth":
+      return "Provider rejected credentials. Cannot retry \u2014 fix the API key / config and re-invoke.";
+    case "context_overflow":
+      return "Subagent context exceeded the model limit. Narrow the task, use a larger-context model, or split into multiple delegates.";
+    case "budget_iterations":
+    case "budget_tool_calls":
+    case "budget_tokens":
+    case "budget_cost":
+      return "Subagent exhausted its budget. Raise the matching `max*` field on the next delegate or narrow task scope.";
+    case "budget_timeout":
+      return "Subagent hit its wall-clock budget. Raise `timeoutMs` on the next delegate or split the task.";
+    case "aborted_by_parent":
+      return "Subagent was aborted (user Ctrl+C, parent unwound, or sibling failure cascade). Not retryable until the abort condition is resolved.";
+    case "empty_response":
+      return "Subagent ended its turn with no text and no tool calls. Almost always a prompt / config issue \u2014 clarify the task or check the model.";
+    case "tool_failed":
+      return "A tool inside the subagent returned ok:false. Inspect `partial.lastAssistantText` for the agent reasoning, then retry with corrected inputs.";
+    case "bridge_failed":
+      return "Parent-child bridge transport failed. This is rare \u2014 restart the session and retry.";
+    default:
+      return retryable ? "Failure classified as retryable. Try again with the same input." : void 0;
+  }
+}
+async function readSubagentPartial(opts, subagentId) {
+  if (!opts.sessionsRoot) return void 0;
+  const candidates = [];
+  if (opts.directorRunId) {
+    candidates.push(path6.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
+  } else {
+    try {
+      const runDirs = await fsp2.readdir(opts.sessionsRoot);
+      for (const r of runDirs) {
+        candidates.push(path6.join(opts.sessionsRoot, r, `${subagentId}.jsonl`));
+      }
+    } catch {
+      return void 0;
+    }
+  }
+  for (const file of candidates) {
+    let raw;
+    try {
+      raw = await fsp2.readFile(file, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = raw.split("\n").filter((l) => l.trim());
+    let lastAssistantText;
+    let lastStopReason;
+    let toolUses = 0;
+    for (const line of lines) {
+      try {
+        const ev = JSON.parse(line);
+        if (ev.type === "tool_use") toolUses += 1;
+        if (ev.type === "llm_response") {
+          if (typeof ev.stopReason === "string") lastStopReason = ev.stopReason;
+          if (Array.isArray(ev.content)) {
+            const txt = ev.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n").trim();
+            if (txt) lastAssistantText = txt;
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      lastAssistantText,
+      lastStopReason,
+      toolUsesObserved: toolUses,
+      events: lines.length
+    };
+  }
+  return void 0;
+}
 
 // src/coordination/agent-subagent-runner.ts
 function makeAgentSubagentRunner(opts) {
   const format = opts.formatTaskInput ?? defaultFormatTaskInput;
   return async (task, ctx) => {
-    const { agent, events } = await opts.factory(ctx.config);
+    const factoryResult = await opts.factory(ctx.config);
+    const { agent, events } = factoryResult;
+    const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     let budgetError = null;
     const onBudgetError = (err) => {
@@ -6658,13 +7919,19 @@ function makeAgentSubagentRunner(opts) {
         budgetError.message += ` (caused by: ${err.message})`;
       }
     };
+    let lastToolFailed = null;
     const unsub = [];
     unsub.push(
-      events.on("tool.started", () => {
+      events.on("tool.executed", (e) => {
         try {
           ctx.budget.recordToolCall();
-        } catch (e) {
-          onBudgetError(e);
+        } catch (eb) {
+          onBudgetError(eb);
+        }
+        if (e.ok === false) {
+          lastToolFailed = e.name;
+        } else if (e.ok === true) {
+          lastToolFailed = null;
         }
       }),
       events.on("provider.response", (e) => {
@@ -6681,6 +7948,26 @@ function makeAgentSubagentRunner(opts) {
         } catch (e) {
           onBudgetError(e);
         }
+      }),
+      // D3: cooperative timeout enforcement DURING a long tool call.
+      // The iteration-loop checkTimeout() only fires between agent
+      // iterations — a single `bash sleep 3600` call would otherwise
+      // park inside one tool execution while the timeout silently
+      // passes, relying solely on the coordinator's hard Promise.race
+      // to interrupt. Tools that emit `tool.progress` (bash chunks,
+      // fetch byte progress, spawn-stream stdout) give us a heartbeat
+      // we can hang the check on. When the budget trips here:
+      //   1. onBudgetError sets budgetError + aborter.abort()
+      //   2. aborter signal propagates to agent.run → tool executor
+      //   3. tool's own signal listener kills the child process
+      // Cheap: O(1) per progress event, and the budget short-circuits
+      // when timeoutMs is unset (most subagents have one set anyway).
+      events.on("tool.progress", () => {
+        try {
+          ctx.budget.checkTimeout();
+        } catch (e) {
+          onBudgetError(e);
+        }
       })
     );
     const onParentAbort = () => aborter.abort();
@@ -6689,8 +7976,15 @@ function makeAgentSubagentRunner(opts) {
     try {
       result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
     } finally {
+      detachFleet?.();
       ctx.signal.removeEventListener("abort", onParentAbort);
       for (const u of unsub) u();
+      if (factoryResult.dispose) {
+        try {
+          await factoryResult.dispose();
+        } catch {
+        }
+      }
     }
     if (budgetError) throw budgetError;
     if (result.status === "failed") {
@@ -6703,6 +7997,13 @@ function makeAgentSubagentRunner(opts) {
       throw new Error("agent exhausted iteration limit");
     }
     const usage = ctx.budget.usage();
+    const finalText = (result.finalText ?? "").trim();
+    if (finalText.length === 0 && usage.toolCalls === 0) {
+      throw new Error("empty response");
+    }
+    if (finalText.length === 0 && lastToolFailed !== null) {
+      throw new Error(`tool failed: ${lastToolFailed}`);
+    }
     return {
       result: result.finalText,
       iterations: result.iterations,
@@ -6768,10 +8069,12 @@ Working rules:
 - Never fabricate numbers \u2014 read the actual logs first
 - Always include file:line references for errors
 - If sessionPath is missing, ask the director to provide it
-- Report confidence level: high (>90% accuracy), medium, low`,
-  maxIterations: 50,
-  maxToolCalls: 200,
-  timeoutMs: 12e4
+- Report confidence level: high (>90% accuracy), medium, low`
+  // No hardcoded budgets — the orchestrator (delegate tool or
+  // spawn_subagent) decides per-task how much room a subagent gets.
+  // A monorepo audit needs hours; a single-file lint check needs
+  // seconds. Pinning a number here forces the orchestrator to fight
+  // the role's default instead of just asking for what it needs.
 };
 var BUG_HUNTER_AGENT = {
   id: "bug-hunter",
@@ -6811,10 +8114,8 @@ Working rules:
 - Never scan node_modules \u2014 it's noise
 - Always include file:line for every finding
 - If >30% of findings are false positives, note the confidence level
-- Ask director for clarification if paths are ambiguous`,
-  maxIterations: 80,
-  maxToolCalls: 300,
-  timeoutMs: 18e4
+- Ask director for clarification if paths are ambiguous`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
 var REFACTOR_PLANNER_AGENT = {
   id: "refactor-planner",
@@ -6854,10 +8155,8 @@ Working rules:
 - Always include rollback strategy \u2014 every refactor can fail
 - Merge tasks that take <1h into a single phase
 - Respect team constraints (reviewer availability, parallelization)
-- Never plan without analyzing the actual code first`,
-  maxIterations: 60,
-  maxToolCalls: 250,
-  timeoutMs: 15e4
+- Never plan without analyzing the actual code first`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
 var SECURITY_SCANNER_AGENT = {
   id: "security-scanner",
@@ -6905,10 +8204,8 @@ Working rules:
 - Never scan node_modules \u2014 use npm audit instead
 - Always provide remediation steps, not just findings
 - Verify regex-based secrets before flagging (false positive risk)
-- When in doubt, flag as medium rather than ignoring potential issues`,
-  maxIterations: 70,
-  maxToolCalls: 280,
-  timeoutMs: 16e4
+- When in doubt, flag as medium rather than ignoring potential issues`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
 var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
@@ -8177,7 +9474,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path17 = opts.path ?? "/metrics";
+  const path18 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -8187,7 +9484,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path17) {
+    if (url === path18) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -8251,7 +9548,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path17}`,
+    url: `${protocol}://${host}:${boundPort}${path18}`,
     close: () => new Promise((resolve4, reject) => {
       server.close((err) => err ? reject(err) : resolve4());
     })
@@ -8797,336 +10094,248 @@ var allServers = () => ({
   sentinel: { ...sentinelServer(), enabled: false }
 });
 
-// src/core/iteration-limit.ts
-function requestLimitExtension(opts) {
-  const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
-  return new Promise((resolve4) => {
-    let resolved = false;
-    const timer = setTimeout(() => {
-      if (!resolved) {
-        resolved = true;
-        resolve4(0);
-      }
-    }, timeoutMs);
-    const deny = () => {
-      if (!resolved) {
-        resolved = true;
-        clearTimeout(timer);
-        resolve4(0);
-      }
+// src/extension/registry.ts
+var ExtensionRegistry = class {
+  extensions = [];
+  promptContributors = [];
+  log;
+  setLogger(log) {
+    this.log = log;
+  }
+  /**
+   * Register a system prompt contributor. Returns an unregister function.
+   * Contributors are called on every system prompt build in registration
+   * order. Their output blocks are inserted after the core environment
+   * block, before the mode and plan blocks.
+   */
+  registerSystemPromptContributor(c) {
+    this.promptContributors.push(c);
+    return () => {
+      const idx = this.promptContributors.indexOf(c);
+      if (idx >= 0) this.promptContributors.splice(idx, 1);
     };
-    const grant = (extra) => {
-      if (!resolved) {
-        resolved = true;
-        clearTimeout(timer);
-        resolve4(Math.max(0, extra));
+  }
+  /**
+   * Build all registered system prompt contributions.
+   * Failures are caught and logged — one bad contributor doesn't
+   * break the prompt assembly.
+   */
+  async buildSystemPromptContributions(ctx) {
+    const blocks = [];
+    for (const c of this.promptContributors) {
+      try {
+        const contributed = await c(ctx);
+        blocks.push(...contributed);
+      } catch (err) {
+        this.log?.error("SystemPromptContributor failed", err);
       }
-    };
-    events.emit("iteration.limit_reached", {
-      currentIterations,
-      currentLimit,
-      grant,
-      deny
-    });
-    if (autoExtend) {
-      setImmediate(() => {
-        if (!resolved) {
-          resolved = true;
-          clearTimeout(timer);
-          resolve4(100);
-        }
+    }
+    return blocks;
+  }
+  /**
+   * Returns the live array of contributors (readonly snapshot for
+   * passing to DefaultSystemPromptBuilder at build time).
+   */
+  listSystemPromptContributors() {
+    return this.promptContributors;
+  }
+  /**
+   * Register an extension. Duplicate names are rejected.
+   * Returns an unregister function.
+   */
+  register(ext) {
+    if (this.extensions.some((e) => e.name === ext.name)) {
+      throw new WrongStackError({
+        message: `Extension "${ext.name}" already registered`,
+        code: "REGISTRY_DUPLICATE",
+        subsystem: "container",
+        context: { extension: ext.name }
       });
     }
-  });
-}
-
-// src/core/streaming-response-builder.ts
-function buildResponse(state) {
-  const content = [];
-  for (const b of state.blockOrder) {
-    if (b.kind === "text") {
-      const txt = state.textBuffers[b.idx] ?? "";
-      if (txt) content.push({ type: "text", text: txt });
-    } else if (b.kind === "thinking") {
-      const t2 = state.thinking[b.idx];
-      if (!t2) continue;
-      if (!t2.textBuf && !t2.signature) continue;
-      const block = { type: "thinking", thinking: t2.textBuf };
-      if (t2.signature) block.signature = t2.signature;
-      if (t2.providerMeta && Object.keys(t2.providerMeta).length > 0) {
-        block.providerMeta = t2.providerMeta;
-      }
-      content.push(block);
-    } else {
-      const tb = state.tools.get(b.id);
-      if (tb) {
-        const block = {
-          type: "tool_use",
-          id: b.id,
-          name: tb.name,
-          input: tb.input ?? {}
-        };
-        if (tb.providerMeta && Object.keys(tb.providerMeta).length > 0) {
-          block.providerMeta = tb.providerMeta;
-        }
-        content.push(block);
+    this.extensions.push(ext);
+    return () => this.unregister(ext.name);
+  }
+  /**
+   * Register an extension, silently replacing any previous registration
+   * with the same name. Use this when overriding a default extension.
+   */
+  registerOrReplace(ext) {
+    const idx = this.extensions.findIndex((e) => e.name === ext.name);
+    if (idx >= 0) this.extensions.splice(idx, 1);
+    return this.register(ext);
+  }
+  /**
+   * Unregister an extension by name. Returns true if found.
+   */
+  unregister(name) {
+    const idx = this.extensions.findIndex((e) => e.name === name);
+    if (idx === -1) return false;
+    this.extensions.splice(idx, 1);
+    return true;
+  }
+  /**
+   * List registered extension names in order.
+   */
+  list() {
+    return this.extensions.map((e) => e.name);
+  }
+  /**
+   * Check if an extension with the given name is registered.
+   */
+  has(name) {
+    return this.extensions.some((e) => e.name === name);
+  }
+  /**
+   * Remove all registered extensions and contributors.
+   */
+  clear() {
+    this.extensions.length = 0;
+    this.promptContributors.length = 0;
+  }
+  // ── Hook runners ─────────────────────────────────────────────────
+  async runBeforeRun(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.beforeRun) continue;
+      try {
+        await ext.beforeRun(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeRun hook failed`, err);
       }
     }
   }
-  if (content.length === 0) content.push({ type: "text", text: "" });
-  return { content, stopReason: state.stopReason, usage: state.usage, model: state.model };
-}
-function createStreamingState(model) {
-  return {
-    model,
-    stopReason: "end_turn",
-    usage: { input: 0, output: 0 },
-    textBuffers: [],
-    currentTextIndex: -1,
-    tools: /* @__PURE__ */ new Map(),
-    thinking: [],
-    currentThinkingIndex: -1,
-    blockOrder: []
-  };
-}
-function handleMessageStart(state, model) {
-  state.model = model;
-}
-function handleContentBlockStart(state, ev) {
-  const kind = ev.kind ?? "text";
-  if (kind === "text") {
-    state.currentTextIndex = state.textBuffers.length;
-    state.textBuffers.push("");
-    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
-  } else if (kind === "tool_use") {
-    const id = ev.id ?? crypto.randomUUID();
-    state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
-    state.blockOrder.push({ kind: "tool", id });
-    state.currentTextIndex = -1;
-  } else if (kind === "thinking") {
-    state.currentThinkingIndex = state.thinking.length;
-    state.thinking.push({
-      textBuf: "",
-      ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
-    });
-    state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
-    state.currentTextIndex = -1;
-  }
-}
-function handleContentBlockStop(state, ev) {
-}
-function handleTextDelta(state, text) {
-  if (state.currentTextIndex === -1) {
-    state.currentTextIndex = state.textBuffers.length;
-    state.textBuffers.push("");
-    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+  async runAfterRun(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.afterRun) continue;
+      try {
+        await ext.afterRun(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterRun hook failed`, err);
+      }
+    }
   }
-  state.textBuffers[state.currentTextIndex] = (state.textBuffers[state.currentTextIndex] ?? "") + text;
-}
-function handleToolUseStart(state, ev) {
-  state.currentTextIndex = -1;
-  state.tools.set(ev.id, { name: ev.name, partial: "" });
-  state.blockOrder.push({ kind: "tool", id: ev.id });
-}
-function handleToolUseInputDelta(state, ev) {
-  const t2 = state.tools.get(ev.id);
-  if (t2) t2.partial += ev.partial;
-}
-function safeJsonOrRaw(s) {
-  if (!s) return {};
-  try {
-    return JSON.parse(s);
-  } catch {
-    return { _raw: s };
+  async runBeforeIteration(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.beforeIteration) continue;
+      try {
+        await ext.beforeIteration(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeIteration hook failed`, err);
+      }
+    }
   }
-}
-function handleToolUseStop(state, ev) {
-  const t2 = state.tools.get(ev.id);
-  if (t2) {
-    t2.input = ev.input !== void 0 ? ev.input : safeJsonOrRaw(t2.partial);
-    if (ev.providerMeta) t2.providerMeta = ev.providerMeta;
+  async runAfterIteration(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.afterIteration) continue;
+      try {
+        await ext.afterIteration(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterIteration hook failed`, err);
+      }
+    }
   }
-  state.currentTextIndex = -1;
-}
-function handleThinkingStart(state, ev) {
-  state.currentThinkingIndex = state.thinking.length;
-  state.thinking.push({
-    textBuf: "",
-    ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
-  });
-  state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
-  state.currentTextIndex = -1;
-}
-function handleThinkingDelta(state, text) {
-  if (state.currentThinkingIndex === -1) {
-    handleThinkingStart(state, {});
+  /**
+   * Run onError hooks in order. The first hook that returns a non-void
+   * result wins; subsequent hooks are skipped.
+   */
+  async runOnError(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.onError) continue;
+      try {
+        const result = await ext.onError(...args);
+        if (result) return result;
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" onError hook failed`, err);
+      }
+    }
   }
-  const t2 = state.thinking[state.currentThinkingIndex];
-  if (t2) t2.textBuf += text;
-}
-function handleThinkingSignature(state, signature) {
-  if (state.currentThinkingIndex === -1) {
-    handleThinkingStart(state, {});
+  /**
+   * Build a composed provider runner. Extensions with `wrapProviderRunner`
+   * form a middleware-style chain: the innermost extension wraps the
+   * default runner, each subsequent wrapper wraps the previous.
+   */
+  wrapProviderRunner(inner) {
+    const wrappers = this.extensions.filter((e) => e.wrapProviderRunner).map((e) => ({ name: e.name, wrap: e.wrapProviderRunner }));
+    if (wrappers.length === 0) return inner;
+    let composed = inner;
+    for (let i = wrappers.length - 1; i >= 0; i--) {
+      const wrapper = wrappers[i];
+      const next = composed;
+      composed = async (ctx, req) => {
+        try {
+          return await wrapper.wrap(ctx, req, next);
+        } catch (err) {
+          this.log?.error(`Extension "${wrapper.name}" wrapProviderRunner failed`, err);
+          throw err;
+        }
+      };
+    }
+    return composed;
   }
-  const t2 = state.thinking[state.currentThinkingIndex];
-  if (t2) t2.signature = signature;
-}
-function handleThinkingStop(state) {
-  state.currentThinkingIndex = -1;
-}
-function handleMessageStop(state, ev) {
-  state.stopReason = ev.stopReason ?? "end_turn";
-  state.usage = ev.usage ?? { input: 0, output: 0 };
-}
-async function streamProviderToResponse(provider, req, signal, ctx, events) {
-  const state = createStreamingState(req.model);
-  const iter = provider.stream(req, { signal })[Symbol.asyncIterator]();
-  try {
-    for (; ; ) {
-      const next = await iter.next();
-      if (next.done) break;
-      const ev = next.value;
-      switch (ev.type) {
-        case "message_start":
-          handleMessageStart(state, ev.model);
-          break;
-        case "content_block_start":
-          handleContentBlockStart(state, ev);
-          break;
-        case "content_block_stop":
-          handleContentBlockStop(state, ev);
-          break;
-        case "text_delta":
-          handleTextDelta(state, ev.text);
-          events.emit("provider.text_delta", { ctx, text: ev.text });
-          break;
-        case "tool_use_start":
-          handleToolUseStart(state, ev);
-          events.emit("provider.tool_use_start", { ctx, id: ev.id, name: ev.name });
-          break;
-        case "tool_use_input_delta":
-          handleToolUseInputDelta(state, ev);
-          break;
-        case "tool_use_stop":
-          handleToolUseStop(state, ev);
-          events.emit("provider.tool_use_stop", { ctx, id: ev.id });
-          break;
-        case "thinking_start":
-          handleThinkingStart(state, ev);
-          break;
-        case "thinking_delta":
-          handleThinkingDelta(state, ev.text);
-          events.emit("provider.thinking_delta", { ctx, text: ev.text });
-          break;
-        case "thinking_signature":
-          handleThinkingSignature(state, ev.signature);
-          break;
-        case "thinking_stop":
-          handleThinkingStop(state);
-          break;
-        case "message_stop":
-          handleMessageStop(state, ev);
-          break;
+  async runBeforeToolExecution(...args) {
+    let toolUses = args[1];
+    for (const ext of this.extensions) {
+      if (!ext.beforeToolExecution) continue;
+      try {
+        toolUses = await ext.beforeToolExecution(args[0], toolUses);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeToolExecution hook failed`, err);
       }
     }
-  } catch (err) {
-    if (signal.aborted) {
-      state.stopReason = "end_turn";
-      return buildResponse(state);
-    }
-    throw err;
-  } finally {
-    try {
-      let drainTimer = null;
+    return toolUses;
+  }
+  async runAfterToolExecution(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.afterToolExecution) continue;
       try {
-        await Promise.race([
-          Promise.resolve(iter.return?.()),
-          new Promise((resolve4) => {
-            drainTimer = setTimeout(resolve4, 500);
-          })
-        ]);
-      } finally {
-        if (drainTimer) clearTimeout(drainTimer);
+        await ext.afterToolExecution(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterToolExecution hook failed`, err);
       }
-    } catch {
     }
   }
-  return buildResponse(state);
-}
+};
 
-// src/core/provider-runner.ts
-async function runProviderWithRetry(opts) {
-  const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
-  let attempt = 0;
-  for (; ; ) {
-    const span = tracer?.startSpan("provider.complete", {
-      "provider.id": provider.id,
-      "provider.model": request.model,
-      "provider.streaming": provider.capabilities.streaming,
-      "provider.attempt": attempt
-    });
-    try {
-      const res = provider.capabilities.streaming ? await streamProviderToResponse(provider, request, signal, ctx, events) : await provider.complete(request, { signal });
-      span?.setAttribute("provider.stopReason", res.stopReason);
-      span?.setAttribute("provider.usage_in", res.usage.input);
-      span?.setAttribute("provider.usage_out", res.usage.output);
-      span?.end();
-      return res;
-    } catch (err) {
-      if (err instanceof Error) span?.recordError(err);
-      span?.end();
-      if (signal.aborted) throw err;
-      const isProviderErr = err instanceof ProviderError;
-      const errAsErr = err instanceof Error ? err : new Error(String(err));
-      const canRetry = retry.shouldRetry(isProviderErr ? err : errAsErr, attempt);
-      const description = isProviderErr ? err.describe() : errAsErr.message;
-      if (!canRetry) {
-        if (isProviderErr) {
-          events.emit("provider.error", {
-            providerId: err.providerId,
-            status: err.status,
-            description,
-            retryable: false
-          });
-        }
-        throw err;
+// src/core/iteration-limit.ts
+function requestLimitExtension(opts) {
+  const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
+  return new Promise((resolve4) => {
+    let resolved = false;
+    const timer = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        resolve4(0);
       }
-      const delay = Math.round(retry.delayMs(attempt));
-      const attemptNum = attempt + 1;
-      logger.warn(`Provider retry ${attemptNum} in ${delay}ms \u2014 ${description}`);
-      if (isProviderErr) {
-        events.emit("provider.retry", {
-          providerId: err.providerId,
-          attempt: attemptNum,
-          delayMs: delay,
-          status: err.status,
-          description
-        });
+    }, timeoutMs);
+    const deny = () => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve4(0);
       }
-      await new Promise((resolve4, reject) => {
-        let settled = false;
-        const onAbort = () => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(t2);
-          reject(new Error("aborted"));
-        };
-        const t2 = setTimeout(() => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(t2);
-          signal.removeEventListener("abort", onAbort);
-          resolve4();
-        }, delay);
-        if (signal.aborted) {
-          onAbort();
-          return;
+    };
+    const grant = (extra) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve4(Math.max(0, extra));
+      }
+    };
+    events.emit("iteration.limit_reached", {
+      currentIterations,
+      currentLimit,
+      grant,
+      deny
+    });
+    if (autoExtend) {
+      setImmediate(() => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          resolve4(100);
         }
-        signal.addEventListener("abort", onAbort, { once: true });
       });
-      attempt++;
     }
-  }
+  });
 }
 
 // src/core/agent.ts
@@ -9163,6 +10372,7 @@ var Agent = class {
   toolExecutor;
   autoExtendLimit;
   tracer;
+  extensions;
   constructor(init) {
     this.container = init.container;
     this.tools = init.tools;
@@ -9176,8 +10386,10 @@ var Agent = class {
     this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
     this.autoExtendLimit = init.autoExtendLimit ?? true;
     this.tracer = init.tracer;
+    this.extensions = init.extensions ?? new ExtensionRegistry();
+    this.extensions.setLogger(this.container.resolve(TOKENS.Logger));
     this.toolExecutor = new ToolExecutor(this.tools, {
-      permissionPolicy: this.permission,
+      permissionPolicy: init.permissionPolicy ?? this.permission,
       secretScrubber: this.scrubber,
       renderer: this.renderer,
       events: this.events,
@@ -9221,33 +10433,66 @@ var Agent = class {
       "agent.model": opts.model ?? this.ctx.model,
       "agent.executionStrategy": opts.executionStrategy ?? this.executionStrategy
     });
+    const { blocks, text } = normalizeInput(userInput);
+    const inputPayload = { content: blocks, text, ctx: this.ctx };
+    await this.extensions.runBeforeRun(this.ctx, inputPayload);
     try {
-      const result = await this.runInner(userInput, opts, controller);
+      const result = await this.runInner(inputPayload, opts, controller);
       span?.setAttribute("agent.status", result.status);
       span?.setAttribute("agent.iterations", result.iterations);
+      await this.extensions.runAfterRun(this.ctx, result);
       return result;
     } catch (err) {
       const wse = err instanceof AgentError ? err : toWrongStackError(err);
       this.events.emit("error", { err: toError(err), phase: "agent" });
       if (err instanceof Error) span?.recordError(err);
       span?.setAttribute("agent.status", "failed");
-      return {
+      const result = {
         status: signal.aborted ? "aborted" : "failed",
         iterations: 0,
         error: wse
       };
+      await this.extensions.runAfterRun(this.ctx, result);
+      return result;
     } finally {
       span?.end();
       await controller.dispose();
     }
   }
-  async runInner(userInput, opts, controller) {
-    await this.normalizeAndEmitUserInput(userInput);
+  async runInner(inputPayload, opts, controller) {
+    await this.pipelines.userInput.run(inputPayload);
+    this.ctx.state.appendMessage({ role: "user", content: inputPayload.content });
+    await this.ctx.session.append({
+      type: "user_input",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      content: inputPayload.content
+    });
     let finalText = "";
     let iterations = 0;
     let effectiveLimit = opts.maxIterations ?? this.maxIterations;
     const hasHardLimit = effectiveLimit > 0 && Number.isFinite(effectiveLimit);
     let recoveryRetries = 0;
+    const diRunner = this.container.has(TOKENS.ProviderRunner) ? this.container.resolve(TOKENS.ProviderRunner) : null;
+    const baseRunner = diRunner ? (ctx, req) => diRunner.run({
+      provider: ctx.provider,
+      request: req,
+      signal: controller.signal,
+      ctx,
+      events: this.events,
+      retry: this.retry,
+      logger: this.logger,
+      tracer: this.tracer
+    }) : async (ctx, req) => runProviderWithRetry({
+      provider: ctx.provider,
+      request: req,
+      signal: controller.signal,
+      ctx,
+      events: this.events,
+      retry: this.retry,
+      logger: this.logger,
+      tracer: this.tracer
+    });
+    const customRunner = this.extensions.wrapProviderRunner(baseRunner);
     for (let i = 0; ; i++) {
       iterations = i + 1;
       if (controller.signal.aborted) {
@@ -9263,26 +10508,39 @@ var Agent = class {
       if (limitCheck.exit) {
         return { ...limitCheck.exit, finalText };
       }
+      await this.extensions.runBeforeIteration(this.ctx, i);
       this.events.emit("iteration.started", { ctx: this.ctx, index: i });
       const req = await this.buildAndRunRequestPipeline(opts);
       let res;
       try {
-        res = await runProviderWithRetry({
-          provider: this.ctx.provider,
-          request: req,
-          signal: controller.signal,
-          ctx: this.ctx,
-          events: this.events,
-          retry: this.retry,
-          logger: this.logger,
-          tracer: this.tracer
-        });
+        res = await customRunner(this.ctx, req);
         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 extDecision = await this.extensions.runOnError(this.ctx, err, "provider", i);
+        if (extDecision) {
+          if (extDecision.action === "fail") {
+            this.events.emit("error", { err: toError(err), phase: "provider" });
+            return { status: "failed", iterations, error: toWrongStackError(err) };
+          }
+          if (extDecision.action === "continue") {
+            await this.extensions.runAfterIteration(this.ctx, i);
+            continue;
+          }
+          if (extDecision.action === "retry") {
+            recoveryRetries++;
+            if (recoveryRetries > 2) {
+              this.events.emit("error", { err: toError(err), phase: "provider" });
+              return { status: "failed", iterations, error: toWrongStackError(err) };
+            }
+            if (extDecision.model) this.ctx.model = extDecision.model;
+            this.logger.info("Extension requested retry; retrying turn");
+            continue;
+          }
+        }
         const recovered = await this.errorHandler.recover(err, this.ctx);
         if (!recovered || recovered.action === "fail") {
           this.events.emit("error", { err: toError(err), phase: "provider" });
@@ -9321,21 +10579,9 @@ var Agent = class {
       await this.executeTools(toolUses);
       this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
       await this.compactContextIfNeeded();
+      await this.extensions.runAfterIteration(this.ctx, i);
     }
   }
-  /**
-   * Normalize user input and emit through userInput pipeline + session append.
-   */
-  async normalizeAndEmitUserInput(userInput) {
-    const { blocks, text } = normalizeInput(userInput);
-    await this.pipelines.userInput.run({ content: blocks, text, ctx: this.ctx });
-    this.ctx.state.appendMessage({ role: "user", content: blocks });
-    await this.ctx.session.append({
-      type: "user_input",
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      content: blocks
-    });
-  }
   /**
    * Check if iteration limit has been reached and request extension if needed.
    * Returns the new effective limit (possibly extended) and a RunResult if
@@ -9419,6 +10665,7 @@ var Agent = class {
    * single tool.
    */
   async executeTools(toolUses) {
+    toolUses = await this.extensions.runBeforeToolExecution(this.ctx, toolUses);
     const { outputs } = await this.toolExecutor.executeBatch(
       toolUses,
       this.ctx,
@@ -9504,6 +10751,7 @@ var Agent = class {
       role: "user",
       content: outputs.map((o) => o.result)
     });
+    await this.extensions.runAfterToolExecution(this.ctx, outputs);
   }
   waitForConfirm(info) {
     return new Promise((resolve4) => {
@@ -9931,6 +11179,7 @@ var DefaultSystemPromptBuilder = class {
     const layer3 = await this.buildEnvironment(ctx);
     const layer4 = await this.buildMemoryAndSkills();
     const layer5 = await this.buildMode();
+    const layer6 = ctx.subagent ? "" : await this.buildActivePlan();
     const blocks = [
       { type: "text", text: layer1 },
       { type: "text", text: layer2 },
@@ -9950,16 +11199,95 @@ var DefaultSystemPromptBuilder = class {
         cache_control: { type: "ephemeral" }
       });
     }
+    if (layer6.trim()) {
+      blocks.push({
+        type: "text",
+        text: layer6,
+        cache_control: { type: "ephemeral" }
+      });
+    }
+    if (this.opts.contributors && this.opts.contributors.length > 0) {
+      for (const c of this.opts.contributors) {
+        try {
+          const contributed = await c(ctx);
+          blocks.push(...contributed);
+        } catch {
+        }
+      }
+    }
     return blocks;
   }
+  /**
+   * Reads `<sessionId>.plan.json` (when configured) and produces a short
+   * "Active plan" block listing open items so the model is anchored to
+   * the strategic roadmap every turn. Reads on every `build()` so a
+   * plan edit (via `/plan` or the `plan` tool) reflects on the next
+   * turn without restarting the session.
+   */
+  async buildActivePlan() {
+    const planPath = typeof this.opts.planPath === "function" ? this.opts.planPath() : this.opts.planPath;
+    if (!planPath) return "";
+    let raw;
+    try {
+      raw = await fsp2.readFile(planPath, "utf8");
+    } catch {
+      return "";
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return "";
+    }
+    if (!Array.isArray(parsed.items) || parsed.items.length === 0) return "";
+    const open3 = parsed.items.filter((i) => i?.status !== "done");
+    if (open3.length === 0) return "";
+    const lines = ["## Active plan"];
+    if (parsed.title) lines.push(`*${parsed.title}*`, "");
+    parsed.items.forEach((it, idx) => {
+      const mark = it?.status === "done" ? "[x]" : it?.status === "in_progress" ? "[~]" : "[ ]";
+      lines.push(`${idx + 1}. ${mark} ${it?.title ?? "(untitled)"}`);
+    });
+    lines.push(
+      "",
+      "Use `/plan` (user) or the `plan` tool to update status as you progress. The roadmap survives session resume."
+    );
+    return lines.join("\n");
+  }
   buildToolUsage(tools) {
     if (tools.length === 0) return "## Tool usage\n\nNo tools registered.";
-    const lines = ["## Tool usage"];
+    const byCat = /* @__PURE__ */ new Map();
+    const uncategorized = [];
     for (const t2 of tools) {
-      const hint = t2.usageHint ?? t2.description;
+      if (t2.category) {
+        let group = byCat.get(t2.category);
+        if (!group) {
+          group = [];
+          byCat.set(t2.category, group);
+        }
+        group.push(t2);
+      } else {
+        uncategorized.push(t2);
+      }
+    }
+    const lines = ["## Tool usage"];
+    for (const [cat, catTools] of byCat) {
       lines.push(`
+### ${cat}`);
+      for (const t2 of catTools) {
+        const hint = t2.usageHint ?? t2.description;
+        const desc = hint.length > 80 ? `${hint.slice(0, 77)}...` : hint.trim();
+        lines.push(`- **${t2.name}** \u2014 ${desc}`);
+      }
+    }
+    if (uncategorized.length > 0) {
+      if (byCat.size > 0) lines.push("");
+      for (const t2 of uncategorized) {
+        const hint = t2.usageHint ?? t2.description;
+        lines.push(`
 ### ${t2.name}
 ${hint.trim()}`);
+      }
     }
     lines.push(`
 ## Common patterns
@@ -9971,6 +11299,78 @@ ${hint.trim()}`);
 - **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 hasDelegate = tools.some((t2) => t2.name === "delegate");
+    if (hasDelegate) {
+      const delegateTool = tools.find((t2) => t2.name === "delegate");
+      const enumValues = (() => {
+        const role = delegateTool?.inputSchema?.properties?.role?.enum;
+        return Array.isArray(role) ? role.filter((r) => typeof r === "string") : [];
+      })();
+      const roleList = enumValues.length > 0 ? enumValues.join(", ") : "(no roster configured)";
+      lines.push(`
+## Delegation
+
+You have a \`delegate\` tool that hands a discrete piece of work to a
+dedicated subagent (its own context, its own LLM call, its own budget
+cap) and waits for the result. Use it proactively when:
+
+- **The task fans out naturally** \u2014 e.g. "audit these 5 files for
+  security issues" splits cleanly into 5 parallel \`delegate\` calls,
+  one per file or per role. Fire them through the provider's
+  parallel-tool-call surface in the same turn.
+- **A specialized role exists** \u2014 the roster has tuned prompts and
+  budgets for: ${roleList}. Reach for a role when the description
+  matches your subtask; otherwise pass \`name\` + \`provider\` + \`model\`.
+- **A subtask would blow up your context** \u2014 long log analyses, large
+  diff reviews, multi-file refactor plans. The subagent absorbs the
+  reading cost and hands back a summary.
+- **You'd otherwise switch hats mid-turn** \u2014 instead of stopping a code
+  fix to do a security pass, delegate the security pass.
+
+### Scope it tight \u2014 narrow tasks succeed, broad tasks time out
+
+A subagent has a finite iteration / tool-call budget (typically 50\u201380
+iterations, 200\u2013300 tool calls). Tasks that mention "ALL files" or "the
+entire codebase" reliably exhaust that budget without producing a clean
+answer \u2014 the delegate returns with \`stopReason: budget_exhausted\` and
+no useful output.
+
+- \u274C BAD: \`"Analyze ALL .ts files in src/ for bugs"\`
+- \u274C BAD: \`"Audit the codebase for security issues"\`
+- \u274C BAD: \`"Plan a refactor of the whole project"\`
+- \u2705 GOOD: \`"Audit src/auth/session.ts for null-deref bugs in the login flow"\`
+- \u2705 GOOD: \`"Check packages/core/src/storage/*.ts for unhandled promise rejections (~6 files)"\`
+- \u2705 GOOD: \`"Plan a phased refactor of the InMemoryBridge transport (3 files in coordination/)"\`
+
+If you need fleet-wide coverage, **fan out**: list the target files
+yourself first (one quick \`glob\` call), then fire one \`delegate\` per
+chunk of \u22645\u201310 files in parallel.
+
+### Reading the result
+
+\`delegate\` returns a structured object. Look at \`stopReason\`:
+
+- \`end_turn\` \u2014 subagent finished cleanly, \`result\` has the answer.
+- \`budget_exhausted\` \u2014 task was too broad; \`partial.lastAssistantText\`
+  has whatever it managed. Narrow the next try.
+- \`subagent_timeout\` / \`host_timeout\` \u2014 likewise partial; raise
+  \`timeoutMs\` only if you have a reason to believe more time would help.
+- \`aborted\` \u2014 the user or another tool stopped this worker; don't retry
+  silently.
+- \`error\` \u2014 infrastructure problem; surface it.
+
+Stay in-process (no \`delegate\`) when:
+- The task is trivial or atomic.
+- The information needed is already in your context.
+- The user is mid-conversation and expects an immediate reply from you,
+  not a research detour through a subagent.
+
+\`delegate\` auto-promotes the host into director mode the first time
+it's called \u2014 you do not need to call any setup tool. For fine-grained
+control over a long-running fleet (spawn N workers, hand them tasks
+one by one, roll up results), use \`spawn_subagent\` + \`assign_task\` +
+\`await_tasks\` directly; \`delegate\` is the one-call shortcut.`);
+    }
     const hasContextManager = tools.some((t2) => t2.name === "context_manager");
     if (hasContextManager) {
       const maxCtx = this.opts.modelCapabilities?.maxContextTokens ?? 128e3;
@@ -10159,6 +11559,21 @@ var ToolRegistry = class {
     this.tools.set(tool.name, { tool, owner });
     return true;
   }
+  /**
+   * Bulk-register multiple tools at once. Each tool that conflicts with an
+   * existing registration is silently skipped — use `registerAllOrThrow`
+   * if you want it to throw on conflicts.
+   */
+  registerAll(tools, owner = "core") {
+    for (const tool of tools) this.tryRegister(tool, owner);
+  }
+  /**
+   * Bulk-register and throw on the first conflict. Use when you need
+   * strict registration (e.g. at boot time).
+   */
+  registerAllOrThrow(tools, owner = "core") {
+    for (const tool of tools) this.register(tool, owner);
+  }
   /**
    * Register a tool as a default. If the tool name is already registered,
    * this is a no-op — the existing registration (from core or another
@@ -10186,6 +11601,30 @@ var ToolRegistry = class {
     }
     this.tools.set(name, { tool, owner });
   }
+  /**
+   * Wrap (decorate) an existing tool. The wrapper receives the current
+   * tool and must return a new tool — typically the same tool with a
+   * wrapped `execute` or `executeStream`. Throws if the tool is not
+   * registered.
+   *
+   * Multiple wraps stack: each wrapper gets the output of the previous.
+   *
+   * @example
+   * registry.wrap('bash', (t) => ({ ...t, permission: 'confirm' }));
+   */
+  wrap(name, wrapper, owner = "core") {
+    const entry = this.tools.get(name);
+    if (!entry) {
+      throw new WrongStackError({
+        message: `Tool "${name}" not registered; cannot wrap`,
+        code: "REGISTRY_NOT_FOUND",
+        subsystem: "container",
+        context: { tool: name }
+      });
+    }
+    const wrapped = wrapper(entry.tool);
+    this.tools.set(name, { tool: wrapped, owner: `${entry.owner}+${owner}` });
+  }
   get(name) {
     return this.tools.get(name)?.tool;
   }
@@ -10195,6 +11634,24 @@ var ToolRegistry = class {
   list() {
     return Array.from(this.tools.values()).map((e) => e.tool);
   }
+  /**
+   * Group tools by their `category` field. Tools without a category
+   * are placed under the key `""` (empty string). Returns a Map of
+   * category → tools, sorted by registration order within each category.
+   */
+  listByCategory() {
+    const map = /* @__PURE__ */ new Map();
+    for (const { tool } of this.tools.values()) {
+      const cat = tool.category ?? "";
+      let group = map.get(cat);
+      if (!group) {
+        group = [];
+        map.set(cat, group);
+      }
+      group.push(tool);
+    }
+    return map;
+  }
   listWithOwner() {
     return Array.from(this.tools.values());
   }
@@ -10214,6 +11671,12 @@ var ProviderRegistry = class {
   register(f) {
     this.factories.set(f.type, f);
   }
+  /**
+   * Bulk-register multiple provider factories at once.
+   */
+  registerAll(factories) {
+    for (const f of factories) this.register(f);
+  }
   /**
    * Override an existing factory. Throws if no factory is registered
    * for the given type. Use this to safely replace a provider at runtime
@@ -10282,6 +11745,12 @@ var SlashCommandRegistry = class {
     }
     return this.cmds.delete(name);
   }
+  /**
+   * Bulk-register multiple slash commands at once.
+   */
+  registerAll(cmds, owner = "core") {
+    for (const cmd of cmds) this.register(cmd, owner);
+  }
   get(name) {
     return this.cmds.get(name)?.cmd;
   }
@@ -10354,15 +11823,23 @@ var DefaultPluginAPI = class {
   providers;
   mcp;
   slashCommands;
+  extensions;
+  session;
+  metrics;
   config;
   log;
+  configStore;
   pluginCleanupFns = [];
   constructor(init) {
     const owner = init.ownerName;
     this.container = init.container;
     this.events = init.events;
     this.config = init.config;
+    this.configStore = init.configStore;
     this.log = init.log.child({ plugin: owner });
+    this.extensions = init.extensions ?? new ExtensionRegistry();
+    this.session = init.sessionWriter ?? noopSession;
+    this.metrics = init.metricsSink ? scopedMetrics(init.metricsSink, owner) : noopMetrics;
     const pipelines = init.pipelines;
     const readonlyPipelines = {};
     for (const [key, pipeline] of Object.entries(pipelines)) {
@@ -10373,6 +11850,7 @@ var DefaultPluginAPI = class {
     this.tools = {
       register: (t2) => tr.register(t2, owner),
       unregister: (name) => tr.unregister(name),
+      wrap: (name, wrapper) => tr.wrap(name, wrapper, owner),
       get: (name) => tr.get(name),
       list: () => tr.list()
     };
@@ -10396,6 +11874,19 @@ var DefaultPluginAPI = class {
     this.pluginCleanupFns.push(off);
     return off;
   }
+  onPattern(pattern, handler) {
+    const off = this.events.onPattern(pattern, handler);
+    this.pluginCleanupFns.push(off);
+    return off;
+  }
+  emitCustom(event, payload) {
+    this.events.emit(event, payload);
+  }
+  onConfigChange(handler) {
+    if (!this.configStore) return () => {
+    };
+    return this.configStore.watch(handler);
+  }
   /** Called by the plugin loader when uninstalling the plugin. */
   drainCleanup() {
     for (const fn of this.pluginCleanupFns.splice(0)) {
@@ -10405,6 +11896,9 @@ var DefaultPluginAPI = class {
       }
     }
   }
+  registerSystemPromptContributor(c) {
+    return this.extensions.registerSystemPromptContributor(c);
+  }
 };
 var noopMcp = {
   start: async () => void 0,
@@ -10425,6 +11919,32 @@ var noopSlashCommands = {
     return [];
   }
 };
+var noopSession = {
+  append: async () => {
+  }
+};
+var noopMetrics = {
+  counter() {
+  },
+  histogram() {
+  },
+  gauge() {
+  }
+};
+function scopedMetrics(sink, pluginName) {
+  const prefix = `plugin.${pluginName}.`;
+  return {
+    counter(name, value, labels) {
+      sink.counter(`${prefix}${name}`, value, labels);
+    },
+    histogram(name, value, labels) {
+      sink.histogram(`${prefix}${name}`, value, labels);
+    },
+    gauge(name, value, labels) {
+      sink.gauge(`${prefix}${name}`, value, labels);
+    }
+  };
+}
 
 // src/plugin/loader.ts
 var KERNEL_API_VERSION = "0.1.10";
@@ -10450,6 +11970,16 @@ function satisfies(range, version) {
 function normalizeDep(d) {
   return typeof d === "string" ? { name: d } : d;
 }
+function shallowMerge(defaults, overrides) {
+  if (overrides === void 0 || overrides === null) return { ...defaults };
+  if (typeof overrides !== "object") return { ...defaults };
+  const ov = overrides;
+  const out = { ...defaults };
+  for (const key of Object.keys(ov)) {
+    out[key] = ov[key];
+  }
+  return out;
+}
 function topoSort(plugins) {
   const map = /* @__PURE__ */ new Map();
   for (const p of plugins) map.set(p.name, p);
@@ -10545,6 +12075,11 @@ async function loadPlugins(plugins, opts) {
       failed.push({ plugin, err });
       continue;
     }
+    if (plugin.defaultConfig && opts.pluginOptions) {
+      const userOpts = opts.pluginOptions[plugin.name];
+      const merged = shallowMerge(plugin.defaultConfig, userOpts);
+      opts.pluginOptions[plugin.name] = merged;
+    }
     if (plugin.configSchema && opts.pluginOptions) {
       const pluginOpts = opts.pluginOptions[plugin.name];
       if (pluginOpts !== void 0) {
@@ -10566,7 +12101,7 @@ async function loadPlugins(plugins, opts) {
     }
     try {
       const rawApi = opts.apiFactory(plugin);
-      const api = plugin.capabilities ? wrapApiForCapabilityCheck(plugin, rawApi, opts.log) : rawApi;
+      const api = plugin.capabilities ? wrapApiForCapabilityCheck(plugin, rawApi, opts.log, opts.enforceCapabilities) : rawApi;
       await plugin.setup(api);
       loaded.push(plugin);
       opts.log.info(`Plugin "${plugin.name}" loaded`);
@@ -10590,10 +12125,18 @@ async function unloadPlugins(loadedPlugins, opts) {
     }
   }
 }
-function wrapApiForCapabilityCheck(plugin, api, log) {
+function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   const caps = plugin.capabilities ?? {};
-  const warn = (subsystem, detail) => {
+  const violate = (subsystem, detail) => {
     const msg = `Plugin "${plugin.name}" used ${subsystem} without declaring capabilities.${subsystem} \u2014 ${detail}`;
+    if (enforce) {
+      throw new PluginError({
+        message: msg,
+        code: "PLUGIN_LOAD_FAILED",
+        pluginName: plugin.name,
+        context: { subsystem, detail }
+      });
+    }
     if (typeof log.warn === "function") log.warn(msg);
     else log.error(msg);
   };
@@ -10601,7 +12144,7 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
     get(target, prop, receiver) {
       if (prop === "register") {
         return (t2) => {
-          warn("tools", `register(${t2?.name ?? "<unknown>"})`);
+          violate("tools", `register(${t2?.name ?? "<unknown>"})`);
           return target.register(t2);
         };
       }
@@ -10612,7 +12155,7 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
     get(target, prop, receiver) {
       if (prop === "register") {
         return (f) => {
-          warn("providers", `register(${f?.type ?? "<unknown>"})`);
+          violate("providers", `register(${f?.type ?? "<unknown>"})`);
           return target.register(f);
         };
       }
@@ -10623,7 +12166,10 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
     get(target, prop, receiver) {
       if (prop === "register") {
         return (c) => {
-          warn("slashCommands", `register(${c?.name ?? "<unknown>"})`);
+          violate(
+            "slashCommands",
+            `register(${c?.name ?? "<unknown>"})`
+          );
           return target.register(c);
         };
       }
@@ -10634,7 +12180,7 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
     get(target, prop, receiver) {
       if (prop === "start") {
         return (cfg) => {
-          warn("mcp", `start(${cfg?.name ?? "<unknown>"})`);
+          violate("mcp", `start(${cfg?.name ?? "<unknown>"})`);
           return target.start(cfg);
         };
       }
@@ -10659,6 +12205,6 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
   });
 }
 
-export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoCompactionMiddleware, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, 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, DirectorBudgetError, DoneConditionChecker, EventBus, FLEET_ROSTER, 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, REFACTOR_PLANNER_AGENT, RecoveryLock, RunController, SECURITY_SCANNER_AGENT, SelectiveCompactor, SessionAnalyzer, SessionError, SlashCommandRegistry, SpecDrivenDev, SpecParser, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskTracker, ToolError, ToolExecutor, ToolRegistry, WrongStackError, allServers, asBlocks, asText, atomicWrite, awsServer, blockServer, braveSearchServer, buildChildEnv, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, color, compileGlob, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createContextManagerTool, createDefaultPipelines, createMessage, createToolOutputSerializer, decryptConfigSecrets, detectNewlineStyle, encryptConfigSecrets, ensureDir, estimateTextTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatTodosList, githubServer, googleMapsServer, isAgentError, isConfigError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, 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 };
+export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorBudgetError, DirectorStateCheckpoint, DoneConditionChecker, EventBus, ExtensionRegistry, FLEET_ROSTER, 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, REFACTOR_PLANNER_AGENT, RecoveryLock, RunController, SECURITY_SCANNER_AGENT, SelectiveCompactor, SessionAnalyzer, SessionError, SlashCommandRegistry, SpecDrivenDev, SpecParser, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskTracker, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMessage, createToolOutputSerializer, decryptConfigSecrets, detectNewlineStyle, emptyPlan, encryptConfigSecrets, ensureDir, estimateTextTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatPlan, formatTodosList, githubServer, googleMapsServer, isAgentError, isConfigError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, loadDirectorState, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, normalizeToLf, projectHash, removePlanItem, renderPrometheus, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map