@wrongstack/core 0.6.5 → 0.6.7

package/dist/index.js

@@ -2558,10 +2558,8 @@ var InMemoryAgentBridge = class {
         this.pendingRequests.delete(correlationId);
         reject(new Error(`Request ${correlationId} timed out after ${timeout}ms`));
       }, timeout);
-      if (this.stopped) {
+      if (!this.inflightGuards.has(correlationId)) {
         clearTimeout(timer);
-        this.inflightGuards.delete(correlationId);
-        this.pendingRequests.delete(correlationId);
         reject(new Error("Bridge stopped"));
         return;
       }
@@ -5745,7 +5743,7 @@ var DirectorStateCheckpoint = class {
       this.timer = null;
     }
     await this.persist();
-    if (this.rewriteRequested) {
+    while (this.rewriteRequested) {
       this.rewriteRequested = false;
       await this.persist();
     }
@@ -7428,7 +7426,8 @@ 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"}`);
+  const stateLabel = goal.goalState ?? "active";
+  lines.push(`State: ${stateLabel}${goal.iterations > 0 ? ` (iteration #${goal.iterations})` : ""}`);
   lines.push(`Engine: ${goal.engineState}`);
   const usage = summarizeUsage(goal);
   if (usage.iterationsWithUsage > 0) {
@@ -7453,7 +7452,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 GOAL_COMPLETE_MARKER = /^\s*\[goal[_\s-]*complete\]\s*$/im;
+var GOAL_CLEAR_MARKER = /^\s*\[\/?goal\s*clear\]\s*$/im;
 var EternalAutonomyEngine = class {
   constructor(opts) {
     this.opts = opts;
@@ -7535,23 +7535,33 @@ var EternalAutonomyEngine = class {
    * `agent.run()` avoids race conditions on the shared Context.
    */
   async runOneIteration() {
+    const emit = (stage) => {
+      this.opts.onStage?.(stage);
+    };
     const goal = await loadGoal(this.goalPath);
     if (!goal) {
+      emit({ phase: "stopped" });
       this.stopRequested = true;
       return false;
     }
     const missionState = goal.goalState ?? "active";
     if (missionState !== "active") {
+      emit({ phase: missionState === "paused" ? "paused" : "stopped" });
       this.stopRequested = true;
       return false;
     }
+    emit({ phase: "decide", reason: "picking next task" });
     const action = await this.decide(goal);
     if (!action) {
       if (!this.stopRequested) {
+        emit({ phase: "sleep", ms: 5e3 });
         await sleep(5e3);
+      } else {
+        emit({ phase: "stopped" });
       }
       return false;
     }
+    emit({ phase: "execute", task: action.task });
     const ctrl = new AbortController();
     this.currentCtrl = ctrl;
     const timer = setTimeout(
@@ -7629,6 +7639,7 @@ var EternalAutonomyEngine = class {
       tokens,
       costUsd
     });
+    emit({ phase: "reflect", status, note });
     let iterationIndex = 0;
     try {
       const reloaded = await loadGoal(this.goalPath);
@@ -7650,6 +7661,7 @@ var EternalAutonomyEngine = class {
         this.consecutiveTransientRetries++;
         const delay = this.computeTransientBackoffMs();
         if (delay > 0) {
+          emit({ phase: "sleep", ms: delay });
           await this.sleepInterruptible(delay);
         }
         return false;
@@ -7663,8 +7675,16 @@ var EternalAutonomyEngine = class {
       return false;
     }
     this.consecutiveTransientRetries = 0;
+    const cycleGapMs = this.opts.cycleGapMs ?? 1e3;
+    emit({ phase: "sleep", ms: cycleGapMs });
+    await sleep(cycleGapMs);
     if (GOAL_COMPLETE_MARKER.test(finalText)) {
-      await this.markGoalCompleted(action, finalText);
+      await this.clearGoalManually(finalText);
+      this.stopRequested = true;
+      return true;
+    }
+    if (GOAL_CLEAR_MARKER.test(finalText)) {
+      await this.clearGoalManually(finalText);
       this.stopRequested = true;
       return true;
     }
@@ -7964,6 +7984,30 @@ ${recentJournal}` : "No prior iterations.",
     });
     await saveGoal(this.goalPath, withEntry);
   }
+  /**
+   * Manually clear the goal — equivalent to `/goal clear` typed by the user.
+   * Sets goalState to `abandoned`, removes the goal file, and fires
+   * `onEternalStop` so the REPL returns to normal mode.
+   */
+  async clearGoalManually(note) {
+    const current = await loadGoal(this.goalPath);
+    if (current) {
+      const abandoned = { ...current, goalState: "abandoned" };
+      await saveGoal(this.goalPath, abandoned);
+    }
+    try {
+      const { unlink: unlink10 } = await import('fs/promises');
+      await unlink10(this.goalPath);
+    } catch {
+    }
+    this.opts.onEternalStop?.();
+    void this.appendIterationEntry({
+      source: "manual",
+      task: "goal cleared",
+      status: "success",
+      note: note.slice(0, 240)
+    });
+  }
   async appendFailure(task, note) {
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
@@ -8031,10 +8075,10 @@ var SubagentBudget = class _SubagentBudget {
    * 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.
+   * Raised from 30s to 60s to give subagents more headroom before
+   * the threshold negotiation times out and triggers a hard stop.
    */
-  static DECISION_TIMEOUT_MS = 3e4;
+  static DECISION_TIMEOUT_MS = 6e4;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
@@ -8565,13 +8609,19 @@ var FLEET_ROSTER = {
   "security-scanner": SECURITY_SCANNER_AGENT
 };
 var FLEET_ROSTER_BUDGETS = {
-  "audit-log": { timeoutMs: 8 * 60 * 1e3, maxIterations: 150, maxToolCalls: 500 },
-  "bug-hunter": { timeoutMs: 15 * 60 * 1e3, maxIterations: 200, maxToolCalls: 600 },
-  "refactor-planner": { timeoutMs: 12 * 60 * 1e3, maxIterations: 180, maxToolCalls: 550 },
-  "security-scanner": { timeoutMs: 15 * 60 * 1e3, maxIterations: 200, maxToolCalls: 600 }
+  "audit-log": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 5e3, maxToolCalls: 15e3 },
+  "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
+  "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
+  "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 }
+};
+var GENERIC_SUBAGENT_BUDGET = {
+  timeoutMs: 3 * 60 * 60 * 1e3,
+  maxIterations: 5e3,
+  maxToolCalls: 15e3
 };
 function applyRosterBudget(cfg) {
-  const defaultBudget = FLEET_ROSTER_BUDGETS[cfg.role ?? ""];
+  const roleBudget = cfg.role ? FLEET_ROSTER_BUDGETS[cfg.role] : void 0;
+  const defaultBudget = roleBudget ?? (cfg.name ? GENERIC_SUBAGENT_BUDGET : void 0);
   if (!defaultBudget) return cfg;
   return {
     ...cfg,
@@ -8643,7 +8693,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       // hasParentBridge() — the type now reflects this.
       parentBridge: null,
       doneCondition: this.config.doneCondition,
-      maxConcurrent: this.config.maxConcurrent ?? 4
+      maxConcurrent: this.config.maxConcurrent ?? 16
     };
     this.subagents.set(id, {
       config: { ...subagent, id },
@@ -8770,7 +8820,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     }
   }
   canDispatch() {
-    const max = this.config.maxConcurrent ?? 4;
+    const max = this.config.maxConcurrent ?? 16;
     return this.inFlight < max && this.pendingTasks.length > 0;
   }
   takeNextDispatchableTask() {
@@ -8864,13 +8914,18 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     task.subagentId = subagentId;
     subagent.context.tasks.push(task);
     this.emit("task.assigned", { task, subagentId });
+    const rawMaxIterations = subagent.config.maxIterations;
+    const rawMaxToolCalls = subagent.config.maxToolCalls;
+    const rawMaxTokens = subagent.config.maxTokens;
+    const rawMaxCostUsd = subagent.config.maxCostUsd;
+    const rawTimeoutMs = subagent.config.timeoutMs;
     const configWithRosterDefaults = applyRosterBudget(subagent.config);
     const budget = new SubagentBudget({
-      maxIterations: configWithRosterDefaults.maxIterations ?? this.config.defaultBudget?.maxIterations,
-      maxToolCalls: task.maxToolCalls ?? configWithRosterDefaults.maxToolCalls ?? this.config.defaultBudget?.maxToolCalls,
-      maxTokens: configWithRosterDefaults.maxTokens ?? this.config.defaultBudget?.maxTokens,
-      maxCostUsd: configWithRosterDefaults.maxCostUsd ?? this.config.defaultBudget?.maxCostUsd,
-      timeoutMs: task.timeoutMs ?? configWithRosterDefaults.timeoutMs ?? this.config.defaultBudget?.timeoutMs
+      maxIterations: rawMaxIterations ?? this.config.defaultBudget?.maxIterations ?? configWithRosterDefaults.maxIterations,
+      maxToolCalls: rawMaxToolCalls ?? this.config.defaultBudget?.maxToolCalls ?? configWithRosterDefaults.maxToolCalls,
+      maxTokens: rawMaxTokens ?? this.config.defaultBudget?.maxTokens ?? configWithRosterDefaults.maxTokens,
+      maxCostUsd: rawMaxCostUsd ?? this.config.defaultBudget?.maxCostUsd ?? configWithRosterDefaults.maxCostUsd,
+      timeoutMs: rawTimeoutMs ?? this.config.defaultBudget?.timeoutMs ?? configWithRosterDefaults.timeoutMs
     });
     subagent.activeBudget = budget;
     if (!this.runner) {
@@ -8941,7 +8996,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
                   kind: "timeout",
                   used: elapsed,
                   limit,
-                  timeoutMs: 3e4,
+                  timeoutMs: 6e4,
                   extend: (extra) => resolveDecision({ extend: extra }),
                   deny: () => resolveDecision("stop")
                 });
@@ -10371,7 +10426,12 @@ var Director = class {
         }
       }
     }
-    const result = await this.coordinator.spawn(config);
+    let result;
+    try {
+      result = await this.coordinator.spawn(config);
+    } catch (err) {
+      throw err;
+    }
     if (this.fleetManager) {
       this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
     } else {
@@ -10819,7 +10879,7 @@ var Director = class {
   }
 };
 function createDelegateTool(opts) {
-  const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
+  const defaultTimeoutMs = opts.defaultTimeoutMs ?? 30 * 60 * 1e3;
   const rosterIds = opts.roster ? Object.keys(opts.roster) : [];
   const inputSchema = {
     type: "object",
@@ -10835,7 +10895,7 @@ function createDelegateTool(opts) {
       },
       name: {
         type: "string",
-        description: "Display name for the subagent when not using a roster role. Required when `role` is omitted."
+        description: "Display name for free-form subagents (not using a roster role). The subagent gets a large default budget (3h, 5000 iter, 15000 tool calls). Required when `role` is omitted."
       },
       provider: {
         type: "string",
@@ -10866,8 +10926,8 @@ function createDelegateTool(opts) {
   };
   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.",
+    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). For free-form coding tasks (not tied to a pre-defined role), pass `name` + `task` \u2014 the subagent runs as a general-purpose coding agent with a large default budget. 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 (audit-log, bug-hunter, refactor-planner, security-scanner) or pass `name` to run a free-form coding agent. For non-trivial work, also pass `timeoutMs`, `maxIterations`, and `maxToolCalls`. 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,
@@ -10915,6 +10975,7 @@ function createDelegateTool(opts) {
             model: i.model,
             systemPromptOverride: i.systemPromptOverride
           };
+          cfg = applyRosterBudget({ ...cfg, name: i.name });
         }
         if (typeof i.maxIterations === "number" && i.maxIterations > 0) {
           cfg.maxIterations = i.maxIterations;
@@ -10922,7 +10983,7 @@ function createDelegateTool(opts) {
         if (typeof i.maxToolCalls === "number" && i.maxToolCalls > 0) {
           cfg.maxToolCalls = i.maxToolCalls;
         }
-        const SUBAGENT_TIMEOUT_BUFFER_MS = opts.subagentTimeoutBufferMs ?? 3e4;
+        const SUBAGENT_TIMEOUT_BUFFER_MS = opts.subagentTimeoutBufferMs ?? 6e4;
         const desiredSubTimeout = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
         if (!cfg.timeoutMs || cfg.timeoutMs > desiredSubTimeout) {
           cfg.timeoutMs = desiredSubTimeout;
@@ -10959,6 +11020,7 @@ function createDelegateTool(opts) {
         const errorKind = result.error?.kind;
         const retryable = result.error?.retryable;
         const backoffMs = result.error?.backoffMs;
+        const summary = buildDelegateSummary(i.role, result);
         return {
           ok: result.status === "success",
           status: result.status,
@@ -10974,7 +11036,10 @@ function createDelegateTool(opts) {
           toolCalls: result.toolCalls,
           durationMs: result.durationMs,
           ...partial ? { partial } : {},
-          ...hintForKind(errorKind, retryable, backoffMs, partial) ? { hint: hintForKind(errorKind, retryable, backoffMs, partial) } : {}
+          ...hintForKind(errorKind, retryable, backoffMs, partial) ? { hint: hintForKind(errorKind, retryable, backoffMs, partial) } : {},
+          // Summary is included so callers (TUI, CLI renderer) can surface
+          // it as a chat history line — the LLM also sees it for continuity.
+          summary
         };
       } catch (err) {
         return {
@@ -10987,10 +11052,11 @@ function createDelegateTool(opts) {
   };
 }
 function instantiateRosterConfig2(role, base) {
+  const withBudget = applyRosterBudget({ ...base, role });
   return {
-    ...base,
-    // Roster entries are templates. Give each spawn a fresh id so
-    // parallel or repeated delegates can use the same role safely.
+    ...withBudget,
+    // Give each spawn a fresh id so parallel or repeated delegates
+    // can use the same role safely.
     id: `${role}-${randomUUID().slice(0, 8)}`
   };
 }
@@ -11050,6 +11116,18 @@ ${partial.lastAssistantText}`;
       return retryable ? "Failure classified as retryable. Try again with the same input." : void 0;
   }
 }
+function buildDelegateSummary(role, result) {
+  const roleLabel = role ?? "subagent";
+  const ms = result.durationMs;
+  const duration = ms < 6e4 ? `${Math.round(ms / 1e3)}s` : ms < 36e5 ? `${Math.round(ms / 6e4)}m` : `${(ms / 36e5).toFixed(1)}h`;
+  if (result.status === "success") {
+    const preview = typeof result.result === "string" ? result.result.trim().slice(0, 120).replace(/\n+/g, " ") : null;
+    const tail = preview ? ` \u2014 ${preview}` : "";
+    return `[${roleLabel}] done in ${duration} (${result.iterations} iter, ${result.toolCalls} tools)${tail}`;
+  }
+  const errLabel = result.error?.kind ?? result.status;
+  return `[${roleLabel}] ${result.status} after ${duration} (${result.iterations} iter, ${result.toolCalls} tools) \u2014 ${errLabel}`;
+}
 async function readSubagentPartial(opts, subagentId) {
   if (!opts.sessionsRoot) return void 0;
   const candidates = [];
@@ -11715,6 +11793,10 @@ var TaskTracker = class {
     node.updatedAt = now;
     if (status === "completed") {
       node.completedAt = now;
+      node.startedAt = node.startedAt ?? now;
+    }
+    if (status === "in_progress") {
+      node.startedAt = now;
     }
     this.transitions.push({ from, to: status, timestamp: now, reason });
     if (status === "completed") {
@@ -11726,6 +11808,23 @@ var TaskTracker = class {
     this.graph.updatedAt = now;
     this.persist();
   }
+  /**
+   * Update node fields (title, description, priority, estimateHours, tags).
+   * Does NOT change status. Use updateNodeStatus for status changes.
+   */
+  updateNode(id, patch) {
+    if (!this.graph) throw new Error("No graph loaded");
+    const node = this.graph.nodes.get(id);
+    if (!node) throw new Error(`Node ${id} not found`);
+    if (patch.title !== void 0) node.title = patch.title;
+    if (patch.description !== void 0) node.description = patch.description;
+    if (patch.priority !== void 0) node.priority = patch.priority;
+    if (patch.estimateHours !== void 0) node.estimateHours = patch.estimateHours;
+    if (patch.tags !== void 0) node.tags = patch.tags;
+    node.updatedAt = Date.now();
+    this.graph.updatedAt = node.updatedAt;
+    this.persist();
+  }
   getNode(id) {
     return this.graph?.nodes.get(id);
   }
@@ -17950,10 +18049,15 @@ var Agent = class {
     });
     let finalText = "";
     let iterations = 0;
+    const delegateSummaries = [];
     let effectiveLimit = opts.maxIterations ?? this.maxIterations;
     const hasHardLimit = effectiveLimit > 0 && Number.isFinite(effectiveLimit);
     let recoveryRetries = 0;
     const autonomousContinue = opts.autonomousContinue ?? this.autonomousContinue;
+    const onSubagentDone = ({ summary, ok }) => {
+      delegateSummaries.push({ summary, ok });
+    };
+    const offSubagentDone = this.events.on("subagent.done", onSubagentDone);
     const diRunner = this.container.has(TOKENS.ProviderRunner) ? this.container.resolve(TOKENS.ProviderRunner) : null;
     const baseRunner = diRunner ? (ctx, req) => diRunner.run({
       provider: ctx.provider,
@@ -17975,116 +18079,122 @@ var Agent = class {
       tracer: this.tracer
     });
     const customRunner = this.extensions.wrapProviderRunner(baseRunner);
-    for (let i = 0; ; i++) {
-      iterations = i + 1;
-      if (controller.signal.aborted) {
-        return { status: "aborted", iterations };
-      }
-      if (autonomousContinue) {
-        consumeAutonomousContinue(this.ctx);
-      }
-      const limitCheck = await this.checkIterationLimit(
-        i,
-        effectiveLimit,
-        hasHardLimit,
-        iterations
-      );
-      effectiveLimit = limitCheck.limit;
-      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 customRunner(this.ctx, req);
-        recoveryRetries = 0;
-      } catch (err) {
+    try {
+      for (let i = 0; ; i++) {
+        iterations = i + 1;
         if (controller.signal.aborted) {
-          this.events.emit("error", { err: toError(err), phase: "provider" });
-          return { status: "aborted", iterations, error: toWrongStackError(err, "AGENT_ABORTED") };
+          return { status: "aborted", iterations };
         }
-        const extDecision = await this.extensions.runOnError(this.ctx, err, "provider", i);
-        if (extDecision) {
-          if (extDecision.action === "fail") {
+        if (autonomousContinue) {
+          consumeAutonomousContinue(this.ctx);
+        }
+        const limitCheck = await this.checkIterationLimit(
+          i,
+          effectiveLimit,
+          hasHardLimit,
+          iterations,
+          delegateSummaries
+        );
+        effectiveLimit = limitCheck.limit;
+        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 customRunner(this.ctx, req);
+          recoveryRetries = 0;
+        } catch (err) {
+          if (controller.signal.aborted) {
             this.events.emit("error", { err: toError(err), phase: "provider" });
-            return { status: "failed", iterations, error: toWrongStackError(err) };
+            return { status: "aborted", iterations, error: toWrongStackError(err, "AGENT_ABORTED") };
           }
-          if (extDecision.action === "continue") {
-            await this.extensions.runAfterIteration(this.ctx, i);
-            continue;
+          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), delegateSummaries };
+            }
+            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), delegateSummaries };
+              }
+              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" });
+            return {
+              status: "failed",
+              iterations,
+              error: toWrongStackError(recovered?.error ?? err),
+              delegateSummaries
+            };
           }
-          if (extDecision.action === "retry") {
+          if (recovered.action === "retry") {
             recoveryRetries++;
             if (recoveryRetries > 2) {
               this.events.emit("error", { err: toError(err), phase: "provider" });
               return { status: "failed", iterations, error: toWrongStackError(err) };
             }
-            if (extDecision.model) this.ctx.model = extDecision.model;
-            this.logger.info("Extension requested retry; retrying turn");
+            if (recovered.model) this.ctx.model = recovered.model;
+            this.logger.info(`Recovered provider error via ${recovered.reason}; retrying turn`);
             continue;
           }
+          recoveryRetries = 0;
+          res = recovered.response;
         }
-        const recovered = await this.errorHandler.recover(err, this.ctx);
-        if (!recovered || recovered.action === "fail") {
-          this.events.emit("error", { err: toError(err), phase: "provider" });
-          return {
-            status: "failed",
-            iterations,
-            error: toWrongStackError(recovered?.error ?? err)
-          };
+        const responseResult = await this.processResponse(res, req);
+        if (responseResult.aborted) {
+          return { status: "aborted", iterations, finalText: responseResult.finalText, delegateSummaries };
         }
-        if (recovered.action === "retry") {
-          recoveryRetries++;
-          if (recoveryRetries > 2) {
-            this.events.emit("error", { err: toError(err), phase: "provider" });
-            return { status: "failed", iterations, error: toWrongStackError(err) };
+        if (responseResult.done) {
+          return { status: "done", iterations, finalText: responseResult.finalText, delegateSummaries };
+        }
+        finalText = responseResult.finalText;
+        const toolUses = res.content.filter(isToolUseBlock);
+        if (toolUses.length === 0) {
+          this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
+          if (autonomousContinue && responseResult.directive === "continue") {
+            await this.compactContextIfNeeded();
+            await this.extensions.runAfterIteration(this.ctx, i);
+            continue;
           }
-          if (recovered.model) this.ctx.model = recovered.model;
-          this.logger.info(`Recovered provider error via ${recovered.reason}; retrying turn`);
-          continue;
+          if (autonomousContinue && responseResult.directive === "stop") {
+            return { status: "done", iterations, finalText, delegateSummaries };
+          }
+          return { status: "done", iterations, finalText, delegateSummaries };
         }
-        recoveryRetries = 0;
-        res = recovered.response;
-      }
-      const responseResult = await this.processResponse(res, req);
-      if (responseResult.aborted) {
-        return { status: "aborted", iterations, finalText: responseResult.finalText };
-      }
-      if (responseResult.done) {
-        return { status: "done", iterations, finalText: responseResult.finalText };
-      }
-      finalText = responseResult.finalText;
-      const toolUses = res.content.filter(isToolUseBlock);
-      if (toolUses.length === 0) {
-        this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
-        if (autonomousContinue && responseResult.directive === "continue") {
+        await this.executeTools(toolUses);
+        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);
           continue;
         }
-        if (autonomousContinue && responseResult.directive === "stop") {
-          return { status: "done", iterations, finalText };
-        }
-        return { status: "done", iterations, finalText };
-      }
-      await this.executeTools(toolUses);
-      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);
-        continue;
-      }
-      this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
-      await this.compactContextIfNeeded();
-      await this.extensions.runAfterIteration(this.ctx, i);
-      if (autonomousContinue && responseResult.directive === "continue") {
-        continue;
-      }
-      if (autonomousContinue && responseResult.directive === "stop") {
-        return { status: "done", iterations, finalText };
+        if (autonomousContinue && responseResult.directive === "continue") {
+          continue;
+        }
+        if (autonomousContinue && responseResult.directive === "stop") {
+          return { status: "done", iterations, finalText, delegateSummaries };
+        }
       }
+    } finally {
+      offSubagentDone();
     }
   }
   /**
@@ -18093,7 +18203,7 @@ var Agent = class {
    * the loop should exit. Returns `{ limit }` with no result when the
    * iteration may proceed.
    */
-  async checkIterationLimit(iterationIndex, limit, hasHardLimit, currentIterations) {
+  async checkIterationLimit(iterationIndex, limit, hasHardLimit, currentIterations, delegateSummaries) {
     if (hasHardLimit && iterationIndex >= limit) {
       const extendBy = await requestLimitExtension({
         events: this.events,
@@ -18106,7 +18216,7 @@ var Agent = class {
         this.logger.info(`Iteration limit extended by ${extendBy} (new limit: ${newLimit})`);
         return { limit: newLimit };
       }
-      return { limit, exit: { status: "max_iterations", iterations: currentIterations } };
+      return { limit, exit: { status: "max_iterations", iterations: currentIterations, delegateSummaries } };
     }
     return { limit };
   }
@@ -18513,11 +18623,9 @@ var Context = class {
     return this._state;
   }
   /**
-   * Register a teardown hook tied to the current run's abort signal. The
-   * hook fires when the run aborts or ends normally — Agent.run wires this
-   * through a RunController. Hooks registered before a run starts are stored
-   * and fired when the next run ends; there is no "immediate fire" when no
-   * run is active.
+   * Register a teardown hook tied to the current run's abort signal.
+   * Hooks registered before a run starts are stored and fired when the
+   * next run ends; there is no immediate fire when no run is active.
    *
    * **Scope:** these hooks fire on the **whole agent run's** abort, not on
    * an individual tool call. For per-tool teardown of resources owned by
@@ -19096,7 +19204,7 @@ ${mem}`);
 };
 
 // src/registry/tool-registry.ts
-var ToolRegistry = class {
+var ToolRegistry = class _ToolRegistry {
   tools = /* @__PURE__ */ new Map();
   register(tool, owner = "core") {
     if (this.tools.has(tool.name)) {
@@ -19218,6 +19326,15 @@ var ToolRegistry = class {
   clear() {
     this.tools.clear();
   }
+  /**
+   * Return a new ToolRegistry with the same registered tools and owners.
+   * Useful for creating filtered copies in multi-agent scenarios.
+   */
+  clone() {
+    const copy = new _ToolRegistry();
+    for (const { tool, owner } of this.listWithOwner()) copy.register(tool, owner);
+    return copy;
+  }
 };
 
 // src/registry/provider-registry.ts
@@ -19282,9 +19399,7 @@ var SlashCommandRegistry = class {
       }
     }
     if (this.cmds.has(fullName)) {
-      if (!isPlugin) {
-        throw new Error(`Built-in slash command "${fullName}" is already registered.`);
-      }
+      if (!isPlugin) return;
       this.cmds.set(fullName, { cmd, owner });
       for (const a of cmd.aliases ?? []) {
         this.cmds.set(`${owner}:${a}`, { cmd, owner });
@@ -19679,7 +19794,12 @@ async function unloadPlugins(loadedPlugins, opts) {
   for (const plugin of ordered) {
     if (typeof plugin.teardown !== "function") continue;
     try {
-      const api = pluginApiMap.get(plugin) ?? opts.apiFactory(plugin);
+      const api = pluginApiMap.get(plugin);
+      if (!api) {
+        throw new Error(
+          `Plugin "${plugin.name}" API not found in pluginApiMap \u2014 was setup() called?`
+        );
+      }
       await plugin.teardown(api);
       pluginApiMap.delete(plugin);
       opts.log.info(`Plugin "${plugin.name}" torn down`);