@wrongstack/core 0.6.0 → 0.6.1

package/dist/index.js

@@ -2934,13 +2934,17 @@ var ToolExecutor = class {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
     const combined = AbortSignal.any([parentSignal, ctrl.signal]);
+    let cleanupCalled = false;
+    let caught = false;
     try {
       if (typeof tool.executeStream === "function") {
         return await this.runStreamedTool(tool, input, ctx, combined, toolUseId);
       }
       return await tool.execute(input, ctx, { signal: combined });
     } catch (err) {
+      caught = true;
       if (combined.aborted && typeof tool.cleanup === "function") {
+        cleanupCalled = true;
         try {
           await tool.cleanup(input, ctx);
         } catch {
@@ -2949,6 +2953,16 @@ var ToolExecutor = class {
       throw err;
     } finally {
       clearTimeout(timer);
+      if (combined.aborted && !caught) {
+        if (!cleanupCalled && typeof tool.cleanup === "function") {
+          try {
+            await tool.cleanup(input, ctx);
+          } catch {
+          }
+        }
+        const reason = combined.reason instanceof Error ? combined.reason : new Error(typeof combined.reason === "string" ? combined.reason : "aborted");
+        throw reason;
+      }
     }
   }
   async runStreamedTool(tool, input, ctx, signal, toolUseId) {
@@ -3006,7 +3020,8 @@ var ToolExecutor = class {
     if (subjectKey) {
       const v = obj[subjectKey];
       if (typeof v === "string") {
-        return subjectKey === "path" || subjectKey === "file" || subjectKey === "files" ? normalizePath(v) : escapeGlob(v);
+        const isPathKey = subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+        return isPathKey ? normalizePath(v) : escapeGlob(v);
       }
     }
     if (toolName === "bash" && typeof obj.command === "string") {
@@ -6277,17 +6292,23 @@ async function streamProviderToResponse(provider, req, signal, ctx, events) {
           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 });
+        case "tool_use_start": {
+          const idVal = ev.id;
+          const nameVal = ev.name;
+          handleToolUseStart(state, { id: idVal, name: nameVal });
+          const emittedPayload = { ctx, id: idVal ?? "unknown", name: nameVal ?? "unknown" };
+          events.emit("provider.tool_use_start", emittedPayload);
           break;
+        }
         case "tool_use_input_delta":
           handleToolUseInputDelta(state, ev);
           break;
-        case "tool_use_stop":
+        case "tool_use_stop": {
+          const stoppedName = state.tools.get(ev.id)?.name ?? "unknown";
           handleToolUseStop(state, ev);
-          events.emit("provider.tool_use_stop", { ctx, id: ev.id });
+          events.emit("provider.tool_use_stop", { ctx, id: ev.id, name: stoppedName });
           break;
+        }
         case "thinking_start":
           handleThinkingStart(state, ev);
           break;
@@ -7303,6 +7324,8 @@ function emptyGoal(goal) {
     lastActivityAt: now,
     iterations: 0,
     engineState: "idle",
+    goalState: "active",
+    todoAttempts: {},
     journal: []
   };
 }
@@ -7340,6 +7363,7 @@ function formatGoal(goal, journalLimit = 10) {
   lines.push(`Set: ${goal.setAt}`);
   lines.push(`Last activity: ${goal.lastActivityAt}`);
   lines.push(`Iterations: ${goal.iterations}`);
+  lines.push(`Mission: ${goal.goalState ?? "active"}`);
   lines.push(`Engine: ${goal.engineState}`);
   const usage = summarizeUsage(goal);
   if (usage.iterationsWithUsage > 0) {
@@ -7363,6 +7387,8 @@ function formatGoal(goal, journalLimit = 10) {
 
 // src/execution/eternal-autonomy.ts
 var execFileP = promisify(execFile);
+var BRAINSTORM_DONE = /* @__PURE__ */ Symbol("brainstorm-done");
+var GOAL_COMPLETE_MARKER = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var EternalAutonomyEngine = class {
   constructor(opts) {
     this.opts = opts;
@@ -7372,6 +7398,14 @@ var EternalAutonomyEngine = class {
   state = "idle";
   stopRequested = false;
   consecutiveFailures = 0;
+  consecutiveBrainstormDone = 0;
+  /**
+   * Count of consecutive transient (recoverable) provider failures. Drives
+   * the exponential backoff between iterations. Reset on the first
+   * successful iteration so a single bad afternoon doesn't permanently
+   * slow the loop down.
+   */
+  consecutiveTransientRetries = 0;
   currentCtrl = null;
   iterationsSinceCompact = 0;
   goalPath;
@@ -7441,9 +7475,16 @@ var EternalAutonomyEngine = class {
       this.stopRequested = true;
       return false;
     }
+    const missionState = goal.goalState ?? "active";
+    if (missionState !== "active") {
+      this.stopRequested = true;
+      return false;
+    }
     const action = await this.decide(goal);
     if (!action) {
-      await sleep(5e3);
+      if (!this.stopRequested) {
+        await sleep(5e3);
+      }
       return false;
     }
     const ctrl = new AbortController();
@@ -7454,13 +7495,29 @@ var EternalAutonomyEngine = class {
     );
     let status = "success";
     let note;
+    let finalText = "";
+    let isTransientFailure = false;
     const tc = this.opts.agent.ctx?.tokenCounter;
     const beforeUsage = tc?.total?.();
     const beforeCost = tc?.estimateCost?.().total;
     try {
       const result = await this.opts.agent.run(
         [{ type: "text", text: action.directive }],
-        { signal: ctrl.signal }
+        {
+          signal: ctrl.signal,
+          // Enable per-call autonomous continuation so the agent can chain
+          // multiple internal tool/response cycles end-to-end on one
+          // directive instead of returning to the engine after a single
+          // round-trip. The model uses `[continue]` / `[done]` markers
+          // (or the `continue_to_next_iteration` tool) to control the
+          // inner loop. Without this flag the engine produced shallow
+          // iterations and almost never let a real task finish.
+          autonomousContinue: true,
+          // Cap the inner loop so a runaway agent.run can't burn through
+          // the iteration timeout — the engine's own outer loop is the
+          // long-running thing, each tick should be bounded.
+          maxIterations: this.opts.iterationMaxAgentSteps ?? 50
+        }
       );
       if (result.status === "aborted") {
         status = "aborted";
@@ -7468,22 +7525,30 @@ var EternalAutonomyEngine = class {
       } else if (result.status === "failed") {
         status = "failure";
         note = result.error?.describe?.() ?? "agent run failed";
+        isTransientFailure = result.error?.recoverable === true;
       } else if (result.status === "max_iterations") {
         status = "failure";
         note = `max iterations (${result.iterations})`;
       } else {
         status = "success";
-        const tail = (result.finalText ?? "").slice(0, 240).replace(/\s+/g, " ").trim();
+        finalText = result.finalText ?? "";
+        const tail = finalText.slice(0, 240).replace(/\s+/g, " ").trim();
         if (tail) note = tail;
       }
     } catch (err) {
       const isAbort = err instanceof Error && (err.name === "AbortError" || err.message.includes("abort"));
       status = isAbort ? "aborted" : "failure";
       note = err instanceof Error ? err.message : String(err);
+      if (!isAbort && typeof err?.recoverable === "boolean") {
+        isTransientFailure = err.recoverable;
+      }
     } finally {
       clearTimeout(timer);
       this.currentCtrl = null;
     }
+    if (action.source === "todo" && action.todoId && status !== "success") {
+      await this.bumpTodoAttempt(action.todoId);
+    }
     const afterUsage = tc?.total?.();
     const afterCost = tc?.estimateCost?.().total;
     const tokens = beforeUsage && afterUsage ? {
@@ -7516,6 +7581,14 @@ var EternalAutonomyEngine = class {
       costUsd
     });
     if (status === "failure") {
+      if (isTransientFailure) {
+        this.consecutiveTransientRetries++;
+        const delay = this.computeTransientBackoffMs();
+        if (delay > 0) {
+          await this.sleepInterruptible(delay);
+        }
+        return false;
+      }
       this.consecutiveFailures++;
       return false;
     }
@@ -7524,6 +7597,12 @@ var EternalAutonomyEngine = class {
       this.consecutiveFailures++;
       return false;
     }
+    this.consecutiveTransientRetries = 0;
+    if (GOAL_COMPLETE_MARKER.test(finalText)) {
+      await this.markGoalCompleted(action, finalText);
+      this.stopRequested = true;
+      return true;
+    }
     this.iterationsSinceCompact++;
     await this.maybeCompact().catch((err) => {
       this.opts.onError?.(
@@ -7587,11 +7666,12 @@ var EternalAutonomyEngine = class {
   async decide(goal) {
     const forceBrainstorm = this.consecutiveFailures >= (this.opts.failureBudget ?? 3);
     if (!forceBrainstorm) {
-      const todo = this.pickPendingTodo();
+      const todo = this.pickPendingTodo(goal);
       if (todo) {
         return {
           source: "todo",
           task: todo.content,
+          todoId: todo.id,
           directive: this.buildDirective(goal, "todo", todo.content)
         };
       }
@@ -7605,17 +7685,38 @@ var EternalAutonomyEngine = class {
       }
     }
     const brainstormed = await this.brainstormTask(goal);
+    if (brainstormed === BRAINSTORM_DONE) {
+      this.consecutiveBrainstormDone++;
+      const threshold = this.opts.brainstormDoneStopThreshold ?? 3;
+      if (this.consecutiveBrainstormDone >= threshold) {
+        await this.markGoalCompleted(
+          { source: "brainstorm", task: "no further work", directive: "" },
+          `brainstorm returned DONE ${this.consecutiveBrainstormDone}x in a row`
+        );
+        this.stopRequested = true;
+      }
+      return null;
+    }
     if (!brainstormed) return null;
+    this.consecutiveBrainstormDone = 0;
     return {
       source: "brainstorm",
       task: brainstormed,
       directive: this.buildDirective(goal, "brainstorm", brainstormed)
     };
   }
-  pickPendingTodo() {
+  pickPendingTodo(goal) {
     const todos = this.opts.agent.ctx.todos;
     if (!Array.isArray(todos)) return null;
-    return todos.find((t2) => t2.status === "pending") ?? null;
+    const attempts = goal.todoAttempts ?? {};
+    const ceiling = this.opts.todoMaxAttempts ?? 3;
+    for (const t2 of todos) {
+      if (t2.status !== "pending") continue;
+      const used = attempts[t2.id] ?? 0;
+      if (used >= ceiling) continue;
+      return t2;
+    }
+    return null;
   }
   async pickGitTask() {
     let out;
@@ -7652,7 +7753,10 @@ ${lastFew}` : "No prior iterations yet.",
       "- One sentence, imperative form, under 200 chars.",
       "- No preamble, no explanation, no markdown \u2014 just the task line.",
       "- If recent iterations show repeated failures on the same target, pivot.",
-      "- If the goal appears fully accomplished, output exactly: DONE"
+      "- If the goal appears fully accomplished AND you can name a concrete",
+      "  artifact / test / output that proves it, output exactly: DONE",
+      "- Be conservative with DONE: if the recent journal contains failures",
+      "  or aborted entries, the goal is almost certainly NOT done."
     ].join("\n");
     try {
       const ctrl = new AbortController();
@@ -7664,9 +7768,11 @@ ${lastFew}` : "No prior iterations yet.",
         );
         if (result.status !== "done") return null;
         const text = (result.finalText ?? "").trim();
-        if (!text || text === "DONE") return null;
+        if (!text) return null;
+        if (/^DONE\.?$/i.test(text)) return BRAINSTORM_DONE;
         const firstLine = text.split("\n").find((l) => l.trim().length > 0)?.trim();
         if (!firstLine) return null;
+        if (/^DONE\.?$/i.test(firstLine)) return BRAINSTORM_DONE;
         return firstLine.slice(0, 240);
       } finally {
         clearTimeout(timer);
@@ -7676,19 +7782,82 @@ ${lastFew}` : "No prior iterations yet.",
     }
   }
   buildDirective(goal, source, task) {
+    const recentJournal = goal.journal.slice(-5).map((e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`).join("\n");
     return [
-      "[ETERNAL AUTONOMY \u2014 iteration directive]",
+      "\u2550\u2550\u2550 ETERNAL AUTONOMY \u2014 iteration directive \u2550\u2550\u2550",
       "",
-      `Goal: ${goal.goal}`,
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations + 1}`,
       `Source: ${source}`,
       `Task: ${task}`,
       "",
-      "Execute this task end-to-end using the tools available to you. Make the",
-      "changes, run tests if relevant, and commit / push as appropriate. Do not",
-      "ask for confirmation \u2014 YOLO mode is active. When the task is done, stop;",
-      "the loop will pick the next action."
+      recentJournal ? `Recent journal (last 5):
+${recentJournal}` : "No prior iterations.",
+      "",
+      "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+      "You are inside a long-running autonomous loop. Each iteration you",
+      "execute ONE concrete task that advances the Mission. No user is",
+      "available to clarify \u2014 make defensible decisions and move forward.",
+      "",
+      "1. EXECUTE END-TO-END",
+      "   \u2022 Use multiple tool calls freely. Emit `[continue]` on its own line",
+      "     to chain to the next internal step without returning.",
+      "   \u2022 When this iteration's Task is finished (real artifact / passing",
+      "     test / applied diff / clean output), emit `[done]` on its own line.",
+      "   \u2022 Do not stop on the first obstacle \u2014 try at least 3 distinct",
+      "     approaches before giving up. YOLO is active; no confirmations.",
+      "",
+      "2. UPDATE TODO STATE (when Source is `todo`)",
+      "   \u2022 Mark this todo `in_progress` via the todos tool before tool work.",
+      "   \u2022 Mark it `completed` on success, with a one-line outcome note.",
+      "   \u2022 If you cannot make progress after 2 distinct attempts, mark it",
+      "     `cancelled` with the obstacle. The loop will skip it next time.",
+      "",
+      "3. MISSION-COMPLETE PROTOCOL",
+      "   \u2022 If \u2014 and ONLY if \u2014 the OVERALL Mission (not just this Task) is",
+      "     verifiably accomplished, emit on its own line:",
+      "         [GOAL_COMPLETE]",
+      "     followed by a one-paragraph verification recipe (artifact path,",
+      "     test command, or 10-second reproduction). This halts the loop.",
+      "   \u2022 NEVER emit [GOAL_COMPLETE] on optimism, partial progress, or",
+      '     "looks fine". Required: a concrete artifact that proves it AND',
+      "     no recent journal failures contradicting completion.",
+      "   \u2022 If unsure, emit `[done]` instead and let the next iteration",
+      "     decide. The loop is patient; false completion is not.",
+      "",
+      "4. NO INTERACTIVITY",
+      "   \u2022 Do not ask questions, do not request confirmation, do not propose",
+      "     options. Pick the best path and execute. The user is asleep."
     ].join("\n");
   }
+  /**
+   * Exponential backoff for transient provider errors. `2^N * base`
+   * capped at `transientBackoffMaxMs`. Zero base disables backoff.
+   * Public-private to keep `runOneIteration` readable; the value is
+   * recomputed each call from the current retry count, so callers
+   * don't have to track state.
+   */
+  computeTransientBackoffMs() {
+    const base = this.opts.transientBackoffBaseMs ?? 2e3;
+    const cap = this.opts.transientBackoffMaxMs ?? 6e4;
+    if (base <= 0) return 0;
+    const exponent = Math.max(0, this.consecutiveTransientRetries - 1);
+    return Math.min(cap, base * Math.pow(2, exponent));
+  }
+  /**
+   * Sleep that wakes early if `stopRequested` flips. Polls every 250 ms
+   * so SIGINT / `/autonomy stop` can land in the middle of a long
+   * backoff instead of waiting up to a minute for the timer.
+   */
+  async sleepInterruptible(totalMs) {
+    const step = 250;
+    let remaining = totalMs;
+    while (remaining > 0 && !this.stopRequested) {
+      const chunk = Math.min(step, remaining);
+      await sleep(chunk);
+      remaining -= chunk;
+    }
+  }
   async appendIterationEntry(entry) {
     const current = await loadGoal(this.goalPath);
     if (!current) {
@@ -7697,6 +7866,39 @@ ${lastFew}` : "No prior iterations yet.",
     const updated = appendJournal(current, entry);
     await saveGoal(this.goalPath, updated);
   }
+  /**
+   * Persistent per-todo failure counter. Skipped silently when the goal
+   * file has been removed (graceful clear). Each non-success iteration
+   * against a todo source bumps the counter by 1; `pickPendingTodo` reads
+   * the counter to rotate past stuck todos once they cross `todoMaxAttempts`.
+   */
+  async bumpTodoAttempt(todoId) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    const attempts = { ...current.todoAttempts ?? {} };
+    attempts[todoId] = (attempts[todoId] ?? 0) + 1;
+    await saveGoal(this.goalPath, { ...current, todoAttempts: attempts });
+  }
+  /**
+   * Flip the mission to `completed` and journal it. Called from two
+   * paths: (a) `[GOAL_COMPLETE]` marker in a successful iteration's
+   * finalText, (b) `brainstorm` returning DONE consecutively past the
+   * configured threshold. Idempotent — re-entry is a no-op once the
+   * goal is already `completed`.
+   */
+  async markGoalCompleted(action, note) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    if (current.goalState === "completed") return;
+    const withFlag = { ...current, goalState: "completed" };
+    const withEntry = appendJournal(withFlag, {
+      source: action.source,
+      task: `MISSION COMPLETE \u2014 ${action.task}`.slice(0, 240),
+      status: "success",
+      note: note.slice(0, 240)
+    });
+    await saveGoal(this.goalPath, withEntry);
+  }
   async appendFailure(task, note) {
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
@@ -7711,6 +7913,142 @@ function sleep(ms) {
   return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 
+// src/execution/autonomy-prompt-contributor.ts
+function makeAutonomyPromptContributor(opts) {
+  return async (ctx) => {
+    if (ctx.subagent) return [];
+    if (!opts.enabled()) return [];
+    let goal;
+    try {
+      goal = await loadGoal(opts.goalPath);
+    } catch {
+      return [];
+    }
+    if (!goal) return [];
+    const missionState = goal.goalState ?? "active";
+    if (missionState !== "active") return [];
+    const tailSize = opts.journalTailSize ?? 5;
+    const journalTail = goal.journal.slice(-tailSize).map((e) => {
+      const note = e.note ? ` \u2014 ${e.note.slice(0, 80)}` : "";
+      return `  #${e.iteration} [${e.status}] ${e.task}${note}`;
+    });
+    const text = [
+      "## ETERNAL AUTONOMY \u2014 active mission",
+      "",
+      "You are inside a long-running autonomous loop. The user is asleep",
+      "and is not available to confirm decisions. Each turn you receive a",
+      "directive describing one concrete sub-task that advances the mission.",
+      "",
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations}`,
+      journalTail.length > 0 ? `Recent journal (last ${journalTail.length}):
+${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first iteration)",
+      "",
+      "### Loop control markers",
+      "Emit these on their own line in your final text \u2014 case-insensitive,",
+      "whitespace-tolerant, but they must occupy the entire line:",
+      "- `[continue]` \u2014 chain to the next internal step without returning.",
+      "- `[done]` \u2014 the current sub-task is finished; return to the engine.",
+      "- `[GOAL_COMPLETE]` \u2014 emit ONLY when the OVERALL mission is",
+      "  verifiably done. Must be followed by a one-paragraph verification",
+      "  recipe (artifact path, test command, or 10-second reproduction).",
+      "  The engine halts on this marker \u2014 false positives waste real",
+      "  human time. If unsure, emit `[done]` and let the next iteration",
+      "  decide.",
+      "",
+      "### Operating principles",
+      "- YOLO is active. Do NOT ask for confirmation, do NOT propose",
+      "  options. Pick the best path and execute it.",
+      "- Use tools freely; multiple calls per turn are normal and expected.",
+      "- When working on a todo, mark it `in_progress` via the todos tool",
+      "  before tool work and `completed` (or `cancelled` with a reason)",
+      "  when done. The loop reads todo state between iterations.",
+      "- If an approach fails twice in a row, pivot. Don't grind on the",
+      "  same wall \u2014 try a different angle, file a cancel on the todo, or",
+      "  surface the obstacle via `[done]` and let the next iteration",
+      "  re-plan."
+    ].join("\n");
+    return [
+      {
+        type: "text",
+        text,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+  };
+}
+
+// src/execution/goal-preamble.ts
+function buildGoalPreamble(goal) {
+  return [
+    "[GOAL \u2014 LOCKED IN. You will work on this until it is verifiably done.",
+    "The user granted you full autonomy. Read these constraints once, then act.",
+    "",
+    "YOUR GOAL:",
+    "---",
+    goal,
+    "---",
+    "",
+    "AUTHORITY YOU HAVE:",
+    "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
+    "  Parallel + recursive fan-out are both fine. There is no spawn budget.",
+    "- Use any provider/model per subagent \u2014 pick the right tool for each",
+    "  piece of work. Heavy reasoning model for planning, fast model for",
+    "  batch work, specialist model for domain code.",
+    "- Run unlimited tool calls and iterations. There is NO hidden budget.",
+    "  The Agent loop auto-extends every 100 iterations forever.",
+    "- Retry failed tools with different inputs, alternative paths, fresh",
+    "  subagents. Switch providers mid-run if one is rate-limited.",
+    "- Re-plan freely when an approach hits a dead end. You are not obliged",
+    "  to stick with the first plan you proposed.",
+    "",
+    'WHAT "DONE" MEANS \u2014 non-negotiable:',
+    "- You can name a concrete artifact (a passing test, a written file at",
+    "  a specific path, a fixed bug verified by re-running the failing case,",
+    "  a clean grep that previously had matches).",
+    "- You can tell the user HOW to verify it themselves in 10 seconds.",
+    '- You have NOT hedged. None of: "looks like it should work", "I',
+    '  believe this fixes it", "the changes appear correct".',
+    "",
+    "WHAT IS NOT DONE \u2014 never report any of these as completion:",
+    "- An error message you didn't recover from.",
+    '- An empty result, a 0-line file, a "no matches found" you accepted',
+    "  without questioning the search.",
+    '- "Should I continue?" / "Want me to also...?" / "Let me know if you',
+    '  want X." Those are hedges. The user already told you to finish the',
+    "  goal \u2014 just do it.",
+    "- Partial progress dressed up as success. Fixed 3 of 5 bugs = 60%",
+    "  done, not done.",
+    "- A subagent's failed/timeout/stopped TaskResult that you didn't",
+    "  respond to with a fresh attempt (different role, different model,",
+    "  tighter prompt).",
+    "",
+    "PERSISTENCE PROTOCOL:",
+    "- If blocked, try at least 3 different angles before reporting the",
+    "  problem to the user. Different tool inputs, different subagent",
+    "  roles, different providers, different decomposition of the task.",
+    "- If a tool fails, read its error, alter the input, try again. Do",
+    "  not just report the failure back.",
+    "- If a subagent returns useless output, respawn with a tighter prompt",
+    '  or a different role. Do not accept "I could not determine\u2026" as the',
+    "  final answer.",
+    "- Use `ask_subagent` for one-shot questions when you don't need a",
+    "  full delegated task.",
+    "",
+    "REPORTING:",
+    "- Stream short progress notes between major actions so the user can",
+    "  monitor. Do not go silent for 50 tool calls then dump a wall of",
+    "  text \u2014 but also do not narrate every tool call.",
+    "- Use the shared scratchpad (if available) to leave breadcrumbs",
+    "  subagents can read.",
+    "- Final response must include: (a) what was accomplished, (b) how",
+    "  to verify, (c) any caveats (residual TODOs, things the user",
+    "  should know about).",
+    "",
+    "BEGIN.]"
+  ].join("\n");
+}
+
 // src/coordination/director.ts
 init_atomic_write();
 
@@ -8021,7 +8359,7 @@ var BudgetThresholdSignal = class extends Error {
     this.decision = decision;
   }
 };
-var SubagentBudget = class {
+var SubagentBudget = class _SubagentBudget {
   limits;
   iterations = 0;
   toolCalls = 0;
@@ -8030,6 +8368,26 @@ var SubagentBudget = class {
   costUsd = 0;
   startTime = null;
   _onThreshold;
+  /**
+   * Tracks which budget kinds currently have an extension request
+   * in flight. While a kind is here, further `checkLimit` calls for the
+   * same kind are no-ops — without this dedup, every `recordIteration`
+   * after the limit is reached spawns a fresh decision Promise (until
+   * the first one lands and patches limits), flooding the FleetBus
+   * with redundant threshold events. Cleared in `checkLimitAsync`'s
+   * `finally`.
+   */
+  pendingExtensions = /* @__PURE__ */ new Set();
+  /**
+   * Hard cap on how long `checkLimitAsync` waits for the coordinator to
+   * respond before defaulting to 'stop'. Without this fallback an absent
+   * or hung listener (Director not built / event filter detached mid-run)
+   * leaves the budget over-limit and never enforces anything, since
+   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
+   * Hardcoded for now — most fleets set their own per-task timeout that
+   * dwarfs this anyway. 30 s matches the existing event-emit timeoutMs.
+   */
+  static DECISION_TIMEOUT_MS = 3e4;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
@@ -8072,56 +8430,92 @@ var SubagentBudget = class {
     if (kind === "timeout" || !this._onThreshold) {
       throw new BudgetExceededError(kind, limit, used);
     }
-    void this.checkLimitAsync(kind, used, limit);
+    const bus = this._events;
+    if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+      throw new BudgetExceededError(kind, limit, used);
+    }
+    if (this.pendingExtensions.has(kind)) return;
+    this.pendingExtensions.add(kind);
+    const decision = this.negotiateExtension(kind, used, limit);
+    throw new BudgetThresholdSignal(kind, limit, used, decision);
   }
   /**
-   * Async threshold negotiation with the coordinator. Fire-and-forget —
-   * any error thrown here becomes an unhandled rejection in the test environment
-   * because the runner's catch only handles the synchronous throw from `checkLimit`.
+   * Drive the threshold handler to a decision. Resolves with `'stop'`
+   * (signal the runner to abort) or `{ extend: ... }` (limits already
+   * patched in-place; the runner should not abort). Always releases the
+   * `pendingExtensions` slot in `finally`.
+   *
+   * The 'continue' return from a sync handler is treated as
+   * `{ extend: {} }` — keep going without patching, next overrun will
+   * fire a fresh signal.
    */
-  async checkLimitAsync(kind, used, limit) {
-    const result = this._onThreshold({
-      kind,
-      used,
-      limit,
-      // Inject a requestDecision helper the handler can call to emit the
-      // budget.threshold_reached event and wait for the coordinator's verdict.
-      // The runner wires this by injecting its EventBus into ctx.budget._events.
-      requestDecision: () => {
-        return new Promise((resolve5) => {
-          this._events?.emit("budget.threshold_reached", {
-            kind,
-            used,
-            limit,
-            timeoutMs: 3e4,
-            extend: (extra) => resolve5({ extend: extra }),
-            deny: () => resolve5("stop")
+  async negotiateExtension(kind, used, limit) {
+    try {
+      const result = this._onThreshold({
+        kind,
+        used,
+        limit,
+        // Inject a requestDecision helper the handler can call to emit the
+        // budget.threshold_reached event and wait for the coordinator's verdict.
+        // A hard fallback timer guarantees the promise eventually resolves
+        // even if no listener responds — without it, an absent/detached
+        // Director would leave the budget permanently in "asking" state.
+        requestDecision: () => {
+          const bus = this._events;
+          if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+            return Promise.resolve("stop");
+          }
+          return new Promise((resolve5) => {
+            let resolved = false;
+            const respond = (d) => {
+              if (resolved) return;
+              resolved = true;
+              resolve5(d);
+            };
+            const fallback = setTimeout(
+              () => respond("stop"),
+              _SubagentBudget.DECISION_TIMEOUT_MS
+            );
+            bus.emit("budget.threshold_reached", {
+              kind,
+              used,
+              limit,
+              timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+              extend: (extra) => {
+                clearTimeout(fallback);
+                respond({ extend: extra });
+              },
+              deny: () => {
+                clearTimeout(fallback);
+                respond("stop");
+              }
+            });
           });
-        });
+        }
+      });
+      if (result === "throw") return "stop";
+      if (result === "continue") return { extend: {} };
+      const decision = await result;
+      if (decision === "stop") return "stop";
+      const ext = decision.extend;
+      if (ext.maxIterations !== void 0) {
+        this.limits.maxIterations = ext.maxIterations;
       }
-    });
-    if (result === "throw") {
-      throw new BudgetExceededError(kind, limit, used);
-    }
-    if (result === "continue") {
-      return;
-    }
-    const decision = await result;
-    if (decision === "stop") {
-      throw new BudgetExceededError(kind, limit, used);
-    }
-    const ext = decision.extend;
-    if (ext.maxIterations !== void 0) {
-      this.limits.maxIterations = ext.maxIterations;
-    }
-    if (ext.maxToolCalls !== void 0) {
-      this.limits.maxToolCalls = ext.maxToolCalls;
-    }
-    if (ext.maxTokens !== void 0) {
-      this.limits.maxTokens = ext.maxTokens;
-    }
-    if (ext.maxCostUsd !== void 0) {
-      this.limits.maxCostUsd = ext.maxCostUsd;
+      if (ext.maxToolCalls !== void 0) {
+        this.limits.maxToolCalls = ext.maxToolCalls;
+      }
+      if (ext.maxTokens !== void 0) {
+        this.limits.maxTokens = ext.maxTokens;
+      }
+      if (ext.maxCostUsd !== void 0) {
+        this.limits.maxCostUsd = ext.maxCostUsd;
+      }
+      if (ext.timeoutMs !== void 0) {
+        this.limits.timeoutMs = ext.timeoutMs;
+      }
+      return decision;
+    } finally {
+      this.pendingExtensions.delete(kind);
     }
   }
   recordIteration() {
@@ -8404,6 +8798,19 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   setRunner(runner) {
     this.runner = runner;
   }
+  /**
+   * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
+   * preempt running tasks — already-dispatched subagents finish their
+   * current task; only future dispatches respect the new cap. Raising
+   * immediately tries to fill the freed slots from the pending queue.
+   */
+  setMaxConcurrent(n) {
+    if (!Number.isFinite(n) || n < 1) {
+      throw new Error(`maxConcurrent must be a finite integer >= 1, got ${n}`);
+    }
+    this.config.maxConcurrent = Math.floor(n);
+    this.tryDispatchNext();
+  }
   async spawn(subagent) {
     const id = subagent.id || randomUUID();
     if (this.subagents.has(id)) {
@@ -8663,14 +9070,65 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.recordCompletion(result);
   }
   async executeWithTimeout(runner, task, ctx, budget) {
-    const timeoutMs = budget.limits.timeoutMs;
-    if (timeoutMs === void 0) return runner(task, ctx);
+    const initialTimeoutMs = budget.limits.timeoutMs;
+    if (initialTimeoutMs === void 0) return runner(task, ctx);
+    const start = Date.now();
     let timer = null;
     const timeoutPromise = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        this.subagents.get(ctx.subagentId)?.abortController.abort();
-        reject(new BudgetExceededError("timeout", timeoutMs, Date.now()));
-      }, timeoutMs);
+      const armFor = (ms) => {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(async () => {
+          const elapsed = Date.now() - start;
+          const limit = budget.limits.timeoutMs ?? initialTimeoutMs;
+          if (!budget.onThreshold) {
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(new BudgetExceededError("timeout", limit, elapsed));
+            return;
+          }
+          try {
+            const result = budget.onThreshold({
+              kind: "timeout",
+              used: elapsed,
+              limit,
+              requestDecision: () => new Promise((resolveDecision) => {
+                budget._events?.emit("budget.threshold_reached", {
+                  kind: "timeout",
+                  used: elapsed,
+                  limit,
+                  timeoutMs: 3e4,
+                  extend: (extra) => resolveDecision({ extend: extra }),
+                  deny: () => resolveDecision("stop")
+                });
+              })
+            });
+            const decision = typeof result === "string" ? result : await result;
+            if (decision === "continue") {
+              armFor(Math.max(1e3, limit));
+              return;
+            }
+            if (decision === "throw" || decision === "stop") {
+              this.subagents.get(ctx.subagentId)?.abortController.abort();
+              reject(new BudgetExceededError("timeout", limit, elapsed));
+              return;
+            }
+            if (decision.extend.timeoutMs !== void 0) {
+              budget.limits.timeoutMs = decision.extend.timeoutMs;
+              const newLimit = decision.extend.timeoutMs;
+              const remaining = Math.max(1e3, newLimit - elapsed);
+              armFor(remaining);
+              return;
+            }
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(new BudgetExceededError("timeout", limit, elapsed));
+          } catch (err) {
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(
+              err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
+            );
+          }
+        }, ms);
+      };
+      armFor(initialTimeoutMs);
     });
     try {
       return await Promise.race([runner(task, ctx), timeoutPromise]);
@@ -9281,7 +9739,7 @@ var Director = class {
         return;
       }
       extendCounts.set(guardKey, prior + 1);
-      setTimeout(() => {
+      setImmediate(() => {
         const extra = {};
         switch (payload.kind) {
           case "iterations":
@@ -9296,9 +9754,12 @@ var Director = class {
           case "cost":
             extra.maxCostUsd = Math.min(payload.limit * 1.5, 10);
             break;
+          case "timeout":
+            extra.timeoutMs = Math.min(Math.ceil(payload.limit * 1.5), 60 * 6e4);
+            break;
         }
         payload.extend(extra);
-      }, Math.min(payload.timeoutMs, 3e4));
+      });
     });
   }
   /** Best-effort session-writer append. Swallows failures — the director
@@ -10093,6 +10554,7 @@ function makeAgentSubagentRunner(opts) {
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
+    ctx.budget.onThreshold = ({ requestDecision }) => requestDecision();
     let budgetError = null;
     const onBudgetError = (err) => {
       if (err instanceof BudgetThresholdSignal) {
@@ -16118,16 +16580,16 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = parseInt(reportId, 10) - 1;
     if (!isNaN(index) && reports[index]) {
-      const { readFile: readFile29 } = await import('fs/promises');
-      const content = await readFile29(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile30 } = await import('fs/promises');
+      const content = await readFile30(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile29 } = await import('fs/promises');
-      const content = await readFile29(join(reportsDir, match), "utf-8");
+      const { readFile: readFile30 } = await import('fs/promises');
+      const content = await readFile30(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -16382,6 +16844,226 @@ var FleetManager = class {
     return { pending, live: [] };
   }
 };
+function createMcpControlTool(opts) {
+  const { getConfig, configPath, registry } = opts;
+  const inputSchema = {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["list", "search", "enable", "disable", "restart"],
+        description: "The management action to perform."
+      },
+      /** Filter for `search`. Matches server name or description case-insensitively. */
+      query: {
+        type: "string",
+        description: "Search term for `search` action. Matches server name or description."
+      },
+      /** Target server name for `enable`, `disable`, `restart`. */
+      server: {
+        type: "string",
+        description: 'Server name (e.g. "github", "filesystem", "brave-search").'
+      }
+    },
+    required: ["action"]
+  };
+  return {
+    name: "mcp_control",
+    description: "Manage MCP server lifecycle: list available servers, search by name or capability, enable or disable servers at runtime, restart running servers.",
+    category: "mcp",
+    permission: "auto",
+    mutating: false,
+    riskTier: "standard",
+    inputSchema,
+    async execute(raw, ctx) {
+      const input = raw;
+      return mcpControlDispatch(input, { getConfig, configPath, registry });
+    }
+  };
+}
+async function mcpControlDispatch(input, deps) {
+  const { action, query, server } = input;
+  switch (action) {
+    case "list":
+      return renderList(deps);
+    case "search":
+      return renderSearch(query ?? "", deps);
+    case "enable":
+      return runEnable(server, deps);
+    case "disable":
+      return runDisable(server, deps);
+    case "restart":
+      return runRestart(server, deps);
+    default:
+      return `Unknown action "${action}". Use one of: list, search, enable, disable, restart.`;
+  }
+}
+function renderList(deps) {
+  const configured = deps.getConfig().mcpServers ?? {};
+  const live = deps.registry.describe();
+  if (Object.keys(configured).length === 0) {
+    return [
+      "No MCP servers configured.",
+      '  Use `mcp_control({ action: "search" })` to see available presets,',
+      '  then `mcp_control({ action: "enable", server: "<name>" })` to add one.'
+    ].join("\n");
+  }
+  const lines = [];
+  const liveMap = new Map(live.map((s) => [s.name, s]));
+  for (const [name, cfg] of Object.entries(configured)) {
+    const liveInfo = liveMap.get(name);
+    const toolCount = liveInfo ? ` (${liveInfo.toolCount} tools)` : "";
+    const stateStr = liveInfo ? badge(liveInfo.state) : dim("\u25CB not loaded");
+    const enabled = cfg.enabled === false ? `${dim("disabled")}  ` : `${green("\u25CF enabled")}  `;
+    lines.push(`  ${bold(name)}  ${enabled}${stateStr}${toolCount}`);
+    if (cfg.description) lines.push(`    ${dim(cfg.description)}`);
+  }
+  lines.push("");
+  lines.push(dim('  Use `mcp_control({ action: "search", query: "<keyword>" })` to find servers.'));
+  lines.push(dim('  Use `mcp_control({ action: "enable", server: "<name>" })` to start a server.'));
+  return lines.join("\n");
+}
+function renderSearch(query, deps) {
+  const configured = deps.getConfig().mcpServers ?? {};
+  const all = allServers();
+  const q = query.toLowerCase();
+  const configuredNames = new Set(Object.keys(configured));
+  const configuredEntries = Object.entries(configured).filter(
+    ([name, cfg]) => name.toLowerCase().includes(q) || (cfg.description ?? "").toLowerCase().includes(q)
+  );
+  const unconfiguredEntries = Object.entries(all).filter(([name]) => !configuredNames.has(name)).filter(
+    ([name, cfg]) => name.toLowerCase().includes(q) || (cfg.description ?? "").toLowerCase().includes(q)
+  );
+  const lines = [];
+  if (configuredEntries.length > 0) {
+    lines.push(bold('Configured servers matching "') + query + '":');
+    for (const [name, cfg] of configuredEntries) {
+      lines.push(`  ${bold(name)}  ${cfg.description ?? cfg.transport}`);
+    }
+    lines.push("");
+  }
+  if (unconfiguredEntries.length > 0) {
+    lines.push(bold('Available presets matching "') + query + '":');
+    for (const [name, cfg] of unconfiguredEntries) {
+      const warn = cfg.permission === "deny" ? red(" \u26A0 confirm required") : "";
+      lines.push(`  ${bold(name)}  ${cfg.description ?? cfg.transport}${warn}`);
+    }
+    lines.push("");
+  }
+  if (configuredEntries.length === 0 && unconfiguredEntries.length === 0) {
+    return `No servers match "${query}". Try a shorter keyword or \`mcp_control({ action: "list" })\`.`;
+  }
+  const total = configuredEntries.length + unconfiguredEntries.length;
+  lines.push(dim(`  ${total} server${total !== 1 ? "s" : ""} shown. Run \`enable\` on one to activate it.`));
+  return lines.join("\n");
+}
+async function runEnable(name, deps) {
+  if (!name) return '`server` is required for enable. Example: { action: "enable", server: "github" }';
+  const all = allServers();
+  const configured = deps.getConfig().mcpServers ?? {};
+  const cfg = configured[name] ?? all[name];
+  if (!cfg) {
+    const known = Object.keys(all).join(", ");
+    return `Unknown server "${name}". Available presets: ${known}`;
+  }
+  const full = await readConfig(deps.configPath);
+  const mcpServers = {
+    ...full.mcpServers ?? {}
+  };
+  mcpServers[name] = { ...cfg, enabled: true };
+  full.mcpServers = mcpServers;
+  await writeConfig(deps.configPath, full);
+  try {
+    const live = deps.registry.describe().find((s) => s.name === name);
+    if (live && live.state === "connected") {
+      return `${green("\u25CF")} Server "${name}" is already running (${live.toolCount} tools registered).`;
+    }
+    await deps.registry.start({ ...cfg, enabled: true });
+    const updated = deps.registry.describe().find((s) => s.name === name);
+    return `${green("\u2713 Enabled and started")} "${name}"${updated ? ` (${updated.toolCount} tools registered).` : "."}`;
+  } catch (err) {
+    return `${red("\u2717 Failed to start")} "${name}": ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function runDisable(name, deps) {
+  if (!name) return '`server` is required for disable. Example: { action: "disable", server: "github" }';
+  const configured = deps.getConfig().mcpServers ?? {};
+  if (!configured[name]) {
+    return `Server "${name}" is not in config. Add it with \`mcp_control({ action: "enable", server: "${name}" })\`.`;
+  }
+  const full = await readConfig(deps.configPath);
+  const mcpServers = {
+    ...full.mcpServers ?? {}
+  };
+  const existing = mcpServers[name];
+  mcpServers[name] = { ...existing, enabled: false };
+  full.mcpServers = mcpServers;
+  await writeConfig(deps.configPath, full);
+  try {
+    await deps.registry.stop(name);
+    return `${yellow("\u25CB Disabled")} "${name}". It will not be started on next boot.`;
+  } catch {
+    return `${yellow("\u25CB Disabled")} "${name}" (it was not running). Config updated.`;
+  }
+}
+async function runRestart(name, deps) {
+  if (!name) return '`server` is required for restart. Example: { action: "restart", server: "github" }';
+  const configured = deps.getConfig().mcpServers ?? {};
+  if (!configured[name]) {
+    return `Server "${name}" is not configured. Use \`mcp_control({ action: "enable", server: "${name}" })\` first.`;
+  }
+  try {
+    await deps.registry.restart(name);
+    const updated = deps.registry.describe().find((s) => s.name === name);
+    return `${green("\u2713 Restarted")} "${name}"${updated ? ` (${updated.toolCount} tools registered).` : "."}`;
+  } catch (err) {
+    return `${red("\u2717 Restart failed")} for "${name}": ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function readConfig(p) {
+  try {
+    return JSON.parse(await fsp2.readFile(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(p, cfg) {
+  const raw = JSON.stringify(cfg, null, 2);
+  const tmp = p + ".tmp";
+  await fsp2.writeFile(tmp, raw, "utf8");
+  await fsp2.rename(tmp, p);
+}
+function bold(s) {
+  return `\x1B[1m${s}\x1B[0m`;
+}
+function dim(s) {
+  return `\x1B[2m${s}\x1B[0m`;
+}
+function green(s) {
+  return `\x1B[32m${s}\x1B[0m`;
+}
+function yellow(s) {
+  return `\x1B[33m${s}\x1B[0m`;
+}
+function red(s) {
+  return `\x1B[31m${s}\x1B[0m`;
+}
+function badge(state) {
+  switch (state) {
+    case "connected":
+      return green("\u25CF connected");
+    case "connecting":
+      return `\x1B[36m\u25D0 connecting\x1B[0m`;
+    case "reconnecting":
+      return `\x1B[36m\u25D1 reconnecting\x1B[0m`;
+    case "disconnected":
+      return dim("\u25CB disconnected");
+    case "failed":
+      return red("\u2717 failed");
+    default:
+      return dim(state);
+  }
+}
 
 // src/extension/registry.ts
 var ExtensionRegistry = class {
@@ -16844,6 +17526,7 @@ var Agent = class {
     let effectiveLimit = opts.maxIterations ?? this.maxIterations;
     const hasHardLimit = effectiveLimit > 0 && Number.isFinite(effectiveLimit);
     let recoveryRetries = 0;
+    const autonomousContinue = opts.autonomousContinue ?? this.autonomousContinue;
     const diRunner = this.container.has(TOKENS.ProviderRunner) ? this.container.resolve(TOKENS.ProviderRunner) : null;
     const baseRunner = diRunner ? (ctx, req) => diRunner.run({
       provider: ctx.provider,
@@ -16870,7 +17553,7 @@ var Agent = class {
       if (controller.signal.aborted) {
         return { status: "aborted", iterations };
       }
-      if (this.autonomousContinue) {
+      if (autonomousContinue) {
         consumeAutonomousContinue(this.ctx);
       }
       const limitCheck = await this.checkIterationLimit(
@@ -16949,18 +17632,18 @@ var Agent = class {
       const toolUses = res.content.filter(isToolUseBlock);
       if (toolUses.length === 0) {
         this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
-        if (this.autonomousContinue && responseResult.directive === "continue") {
+        if (autonomousContinue && responseResult.directive === "continue") {
           await this.compactContextIfNeeded();
           await this.extensions.runAfterIteration(this.ctx, i);
           continue;
         }
-        if (this.autonomousContinue && responseResult.directive === "stop") {
+        if (autonomousContinue && responseResult.directive === "stop") {
           return { status: "done", iterations, finalText };
         }
         return { status: "done", iterations, finalText };
       }
       await this.executeTools(toolUses);
-      if (this.autonomousContinue && consumeAutonomousContinue(this.ctx)) {
+      if (autonomousContinue && consumeAutonomousContinue(this.ctx)) {
         this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
         await this.compactContextIfNeeded();
         await this.extensions.runAfterIteration(this.ctx, i);
@@ -16969,10 +17652,10 @@ var Agent = class {
       this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
       await this.compactContextIfNeeded();
       await this.extensions.runAfterIteration(this.ctx, i);
-      if (this.autonomousContinue && responseResult.directive === "continue") {
+      if (autonomousContinue && responseResult.directive === "continue") {
         continue;
       }
-      if (this.autonomousContinue && responseResult.directive === "stop") {
+      if (autonomousContinue && responseResult.directive === "stop") {
         return { status: "done", iterations, finalText };
       }
     }
@@ -17062,7 +17745,7 @@ var Agent = class {
       }
     }
     let directive = "none";
-    if (this.autonomousContinue && finalText) {
+    if (finalText) {
       directive = parseContinueDirective(finalText);
     }
     return { finalText, aborted: false, done: false, directive };
@@ -18658,6 +19341,6 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   });
 }
 
-export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_WINDOW_MODE_ID, 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, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeContinueToNextIterationTool, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, securitySlashCommand, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_WINDOW_MODE_ID, 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, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMcpControlTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, securitySlashCommand, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map