@wrongstack/core 0.63.4 → 0.66.13

package/dist/index.js

@@ -3395,6 +3395,29 @@ function createToolOutputSerializer(opts = {}) {
   }
   return { serialize, enforceCap, capBytes };
 }
+function truncateForEvent(content, max = 400) {
+  if (!content) return "";
+  return content.length <= max ? content : `${content.slice(0, max - 1)}\u2026`;
+}
+function sizeSignals(toolName, content) {
+  if (!content || content.length === 0) {
+    return { outputBytes: 0, outputTokens: 0, outputLines: void 0 };
+  }
+  const outputBytes = Buffer.byteLength(content, "utf8");
+  const outputTokens = Math.max(1, Math.round(outputBytes / 3.5));
+  let outputLines;
+  if (toolName === "read") {
+    const lineRe = /^\s*\d+→/gm;
+    let count = 0;
+    while (lineRe.exec(content) !== null) count++;
+    if (count > 0) outputLines = count;
+  } else if (toolName === "bash" || toolName === "shell" || toolName === "grep" || toolName === "logs") {
+    let nl = 0;
+    for (let i = 0; i < content.length; i++) if (content.charCodeAt(i) === 10) nl++;
+    outputLines = nl + (content.endsWith("\n") ? 0 : 1);
+  }
+  return { outputBytes, outputTokens, outputLines };
+}
 
 // src/execution/tool-executor.ts
 var ToolExecutor = class {
@@ -7080,6 +7103,8 @@ var DefaultPermissionPolicy = class {
   trustFile;
   yolo;
   yoloDestructive;
+  /** When true, destructive ops still require confirmation even in YOLO mode. */
+  confirmDestructive;
   /**
    * Session-scoped "soft deny" map. When the user presses 'n' (block once),
    * the tool+pattern is added here. If the LLM retries in the same session,
@@ -7113,6 +7138,7 @@ var DefaultPermissionPolicy = class {
     this.trustFile = opts.trustFile;
     this.yolo = opts.yolo ?? false;
     this.yoloDestructive = opts.yoloDestructive ?? opts.forceAllYolo ?? false;
+    this.confirmDestructive = opts.confirmDestructive ?? false;
     this.promptDelegate = opts.promptDelegate;
   }
   /**
@@ -7140,6 +7166,14 @@ var DefaultPermissionPolicy = class {
   getYoloDestructive() {
     return this.yoloDestructive;
   }
+  /** Toggle destructive confirmation gate (only meaningful when yolo is active). */
+  setConfirmDestructive(enabled) {
+    this.confirmDestructive = enabled;
+  }
+  /** Check whether destructive confirmation gate is active. */
+  getConfirmDestructive() {
+    return this.confirmDestructive;
+  }
   /** @deprecated Use `setYoloDestructive`. */
   setForceAllYolo(enabled) {
     this.setYoloDestructive(enabled);
@@ -7193,30 +7227,28 @@ var DefaultPermissionPolicy = class {
       return { permission: "auto", source: "trust" };
     }
     if (this.yolo) {
-      const destructive = this.isDestructiveYoloCall(tool, input, ctx);
-      if (destructive && !this.yoloDestructive) {
-        if (this.promptDelegate) {
-          const decision = await this.promptDelegate(tool, input, subject ?? tool.name);
-          if (decision === "always") {
-            await this.trust({ tool: tool.name, pattern: subject ?? tool.name });
-            return {
-              permission: "auto",
-              source: "user",
-              reason: "destructive yolo always-allowed"
-            };
-          }
-          if (decision === "deny") {
-            await this.deny({ tool: tool.name, pattern: subject ?? tool.name });
-            return { permission: "deny", source: "user", reason: "user denied destructive yolo" };
+      if (this.confirmDestructive) {
+        const destructive = this.isDestructiveYoloCall(tool, input, ctx);
+        if (destructive) {
+          if (this.promptDelegate) {
+            const decision = await this.promptDelegate(tool, input, subject ?? tool.name);
+            if (decision === "always") {
+              await this.trust({ tool: tool.name, pattern: subject ?? tool.name });
+              return { permission: "auto", source: "user", reason: "destructive yolo always-allowed" };
+            }
+            if (decision === "deny") {
+              await this.deny({ tool: tool.name, pattern: subject ?? tool.name });
+              return { permission: "deny", source: "user", reason: "user denied destructive yolo" };
+            }
+            return { permission: decision === "yes" ? "auto" : "deny", source: "user" };
           }
-          return { permission: decision === "yes" ? "auto" : "deny", source: "user" };
+          return {
+            permission: "confirm",
+            source: "yolo_destructive",
+            riskTier: "destructive",
+            reason: "destructive tool needs explicit approval (confirmDestructive is on)"
+          };
         }
-        return {
-          permission: "confirm",
-          source: "yolo_destructive",
-          riskTier: "destructive",
-          reason: "destructive tool needs explicit approval even in yolo mode"
-        };
       }
       return { permission: "auto", source: "yolo" };
     }
@@ -9775,15 +9807,22 @@ var SubagentBudget = class _SubagentBudget {
     void this.checkLimits();
   }
   /**
-   * Wall-clock budget check. Unlike other limits, timeout is always a hard stop
-   * — wall-clock time cannot be "extended" by the coordinator, so it throws
-   * synchronously rather than entering the negotiation flow.
+   * Wall-clock / idle budget check. Delegates to `checkLimits(elapsed)`, so
+   * `timeout` and `idle_timeout` follow the SAME negotiation path as the other
+   * kinds — they are NOT a special-cased hard stop. This is deliberate: a
+   * heartbeat-aware policy (see `attachAutoExtend` and `CollabSession`) grants
+   * a timeout extension only while the agent is making progress and denies it
+   * once the agent is genuinely stuck, which is safer than an unconditional
+   * hard kill of a long-but-working agent. The runner translates the resulting
+   * `BudgetThresholdSignal` decision (`extend` → patch limits in place,
+   * `stop` → abort) just like every other kind.
    *
-   * Decision table:
-   * - no `onThreshold` handler         → throw `BudgetExceededError`
-   * - `mode === 'sync'`               → throw `BudgetExceededError`
-   * - `mode === 'auto'` + no listener  → throw `BudgetExceededError`
-   * - `mode === 'auto'` + listener     → throw `BudgetExceededError` (timeout is not extendable)
+   * Decision table (same as `checkLimits`):
+   * - no `onThreshold` handler        → throw `BudgetExceededError` (hard stop)
+   * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop)
+   * - `mode === 'auto'` + no listener → throw `BudgetExceededError` (no one to ask)
+   * - `mode === 'auto'` + listener    → throw `BudgetThresholdSignal` (negotiated;
+   *                                     a heartbeat-aware policy may extend the timeout)
    */
   checkTimeout() {
     if (this.startTime === null) return;
@@ -12649,7 +12688,10 @@ var NICKNAME_POOL = {
   "lavoisier": { name: "Lavoisier", domain: "chemistry" },
   "mendeleev": { name: "Mendeleev", domain: "chemistry" }
 };
-var ALL_NICKNAMES = Object.values(NICKNAME_POOL);
+var ALL_NICKNAMES = Object.entries(NICKNAME_POOL);
+var NAME_TO_KEY = Object.fromEntries(
+  ALL_NICKNAMES.map(([key, entry]) => [entry.name, key])
+);
 var DOMAIN_PREFERENCES = {
   "security": ["shannon", "turing", "lamarr", "stallman"],
   "bug-hunter": ["darwin", "curie", "feynman", "fermi"],
@@ -12682,17 +12724,23 @@ function assignNickname(role, used) {
   for (const key of preferences) {
     const entry = NICKNAME_POOL[key];
     if (entry && !used.has(key)) {
-      return `${entry.name} (${formatRole(role)})`;
+      return { key, display: `${entry.name} (${formatRole(role)})` };
     }
   }
-  for (const entry of ALL_NICKNAMES) {
-    const key = Object.entries(NICKNAME_POOL).find(([, v]) => v.name === entry.name)?.[0];
-    if (key && !used.has(key)) {
-      return `${entry.name} (${formatRole(role)})`;
+  for (const [key, entry] of ALL_NICKNAMES) {
+    if (!used.has(key)) {
+      return { key, display: `${entry.name} (${formatRole(role)})` };
     }
   }
   const counter = used.size + 1;
-  return `Scientist #${counter} (${formatRole(role)})`;
+  return { key: `scientist-${counter}`, display: `Scientist #${counter} (${formatRole(role)})` };
+}
+function nicknameKeyFromDisplay(display) {
+  const base = display.replace(/\s*\([^)]*\)\s*$/, "").trim();
+  const key = NAME_TO_KEY[base];
+  if (key) return key;
+  const synthesized = base.match(/^Scientist #(\d+)$/);
+  return synthesized ? `scientist-${synthesized[1]}` : void 0;
 }
 function formatRole(role) {
   return role.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
@@ -12779,11 +12827,10 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     const name = subagent.name?.trim() ?? "";
     const isPlaceholder = name === "" || name.toLowerCase() === role.toLowerCase() || name === "subagent" || name === "adhoc" || name === "generic" || /^slot-/.test(name);
     if (!isPlaceholder) return subagent;
-    const nickname = assignNickname(role, this.usedNicknames);
-    const baseKey = nickname.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
-    this.usedNicknames.add(baseKey);
-    this.subagentNicknames.set(subagentId, baseKey);
-    return { ...subagent, name: nickname };
+    const { key, display } = assignNickname(role, this.usedNicknames);
+    this.usedNicknames.add(key);
+    this.subagentNicknames.set(subagentId, key);
+    return { ...subagent, name: display };
   }
   async spawn(subagent) {
     const id = subagent.id || randomUUID();
@@ -13035,23 +13082,32 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
    */
   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 });
-    }
+    for (const t2 of dropped) this.emitPendingAborted(t2, message);
+  }
+  /**
+   * Emit a synthetic `stopped`/`aborted_by_parent` completion for a single
+   * PENDING task — one that was never counted in `inFlight`. This MUST bypass
+   * `recordCompletion`: that path does `inFlight--`, which for a pending task
+   * steals a decrement from a genuinely in-flight task and trips the underflow
+   * guard — suppressing that real task's `task.completed` and hanging its
+   * `awaitTasks()` caller. Pushes the result and fires the event directly.
+   */
+  emitPendingAborted(task, message) {
+    const synthetic = {
+      subagentId: task.subagentId ?? "unassigned",
+      taskId: task.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, result: synthetic });
   }
   async runDispatched(subagentId, task) {
     const subagent = this.subagents.get(subagentId);
@@ -13312,20 +13368,10 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     const orphaned = this.pendingTasks.filter((t2) => t2.subagentId === subagentId);
     this.pendingTasks = this.pendingTasks.filter((t2) => t2.subagentId !== subagentId);
     for (const t2 of orphaned) {
-      const synthetic = {
-        subagentId,
-        taskId: t2.id,
-        status: "stopped",
-        error: {
-          kind: "aborted_by_parent",
-          message: `Subagent "${subagentId}" was removed while task "${t2.id}" was pending`,
-          retryable: false
-        },
-        iterations: 0,
-        toolCalls: 0,
-        durationMs: 0
-      };
-      this.recordCompletion(synthetic);
+      this.emitPendingAborted(
+        t2,
+        `Subagent "${subagentId}" was removed while task "${t2.id}" was pending`
+      );
     }
     this.fleetBus?.emit({
       subagentId,
@@ -13703,6 +13749,7 @@ ${personaLine}Task: ${task}
     } catch {
       results = coordinator.results().slice(-taskIds.length);
     }
+    await Promise.allSettled(subagentIds.map((id) => coordinator.remove(id)));
     const allSuccessful = results.length > 0 && results.every((r) => r.status === "success");
     const goalComplete = results.some(
       (r) => r.status === "success" && typeof r.result === "string" && GOAL_COMPLETE_MARKER2.test(r.result)
@@ -14498,6 +14545,10 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     return lines.join("\n");
   }
   cleanup() {
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = void 0;
+    }
     for (const dispose of this.disposers) dispose();
     this.disposers.length = 0;
   }
@@ -15627,18 +15678,20 @@ var Director = class _Director {
       if (e.subagentId.startsWith("bug-hunter-") || e.subagentId.startsWith("refactor-planner-") || e.subagentId.startsWith("critic-")) {
         return;
       }
-      if (payload.kind === "timeout") {
+      if (payload.kind === "timeout" || payload.kind === "idle_timeout") {
+        const heartbeatKey = `${e.subagentId}:${payload.kind}`;
         const progress = progressBySubagent.get(e.subagentId) ?? 0;
-        const lastProgress = lastTimeoutProgress.get(e.subagentId) ?? -1;
+        const lastProgress = lastTimeoutProgress.get(heartbeatKey) ?? -1;
         if (progress <= lastProgress) {
           payload.deny();
           return;
         }
-        lastTimeoutProgress.set(e.subagentId, progress);
+        lastTimeoutProgress.set(heartbeatKey, progress);
+        const field = payload.kind === "timeout" ? "timeoutMs" : "idleTimeoutMs";
         setImmediate(() => {
           const newLimit = Math.min(Math.ceil(payload.limit * 2), 24 * 60 * 6e4);
-          this.recordExtension(e.subagentId, e.taskId, "timeout", newLimit);
-          payload.extend({ timeoutMs: newLimit });
+          this.recordExtension(e.subagentId, e.taskId, payload.kind, newLimit);
+          payload.extend({ [field]: newLimit });
         });
         return;
       }
@@ -15954,10 +16007,9 @@ var Director = class _Director {
       if (this.fleetManager) {
         this.fleetManager.assignNicknameAndRecord(config);
       } else {
-        config.name = assignNickname(role, this._usedNicknames);
-        this._usedNicknames.add(
-          config.name.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-")
-        );
+        const { key, display } = assignNickname(role, this._usedNicknames);
+        config.name = display;
+        this._usedNicknames.add(key);
       }
     }
     result = await this.coordinator.spawn(config);
@@ -16279,8 +16331,8 @@ var Director = class _Director {
     } else {
       const entry = this.manifestEntries.get(subagentId);
       if (entry?.name) {
-        const nicknameKey = entry.name.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
-        this._usedNicknames.delete(nicknameKey);
+        const nicknameKey = nicknameKeyFromDisplay(entry.name);
+        if (nicknameKey) this._usedNicknames.delete(nicknameKey);
       }
     }
     this.manifestEntries.delete(subagentId);
@@ -24414,11 +24466,10 @@ var FleetManager = class {
    */
   assignNicknameAndRecord(config) {
     const role = config.role ?? "subagent";
-    const nickname = assignNickname(role, this._usedNicknames);
-    const baseKey = nickname.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
-    this._usedNicknames.add(baseKey);
-    config.name = nickname;
-    return nickname;
+    const { key, display } = assignNickname(role, this._usedNicknames);
+    this._usedNicknames.add(key);
+    config.name = display;
+    return display;
   }
   /**
    * Returns the set of already-assigned nickname keys — useful for debugging
@@ -24603,8 +24654,8 @@ var FleetManager = class {
   removeSubagent(subagentId) {
     const entry = this.manifestEntries.get(subagentId);
     if (entry?.name) {
-      const nicknameKey = entry.name.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
-      this._usedNicknames.delete(nicknameKey);
+      const nicknameKey = nicknameKeyFromDisplay(entry.name);
+      if (nicknameKey) this._usedNicknames.delete(nicknameKey);
     }
     for (const [taskId, task] of this.pendingTasks) {
       if (task.subagentId === subagentId) {
@@ -25051,37 +25102,146 @@ var ExtensionRegistry = class {
   }
 };
 
-// src/core/btw.ts
-var META_KEY = "_btwNotes";
-function readQueue(ctx) {
-  const raw = ctx.meta[META_KEY];
-  return Array.isArray(raw) ? raw : [];
-}
-function setBtwNote(ctx, text) {
-  const trimmed = text.trim();
-  if (!trimmed) return readQueue(ctx).length;
-  const next = [...readQueue(ctx), trimmed].slice(-20);
-  ctx.meta[META_KEY] = next;
-  return next.length;
-}
-function pendingBtwCount(ctx) {
-  return readQueue(ctx).length;
-}
-function consumeBtwNotes(ctx) {
-  const notes = readQueue(ctx);
-  if (notes.length > 0) delete ctx.meta[META_KEY];
-  return notes;
-}
-function buildBtwBlock(notes) {
-  const body = notes.map((n) => `- ${n}`).join("\n");
-  return [
-    "[BY THE WAY \u2014 the user added this while you were working. Fold it into",
-    "your current task; do not restart from scratch unless it contradicts the",
-    "goal:",
-    "",
-    body,
-    "]"
-  ].join("\n");
+// src/core/agent-tools.ts
+function createAgentToolHandler(a) {
+  async function executeSingleWithDecision(tool, use) {
+    const start = Date.now();
+    try {
+      const result = await a.toolExecutor.executeTool(
+        tool,
+        use,
+        a.ctx,
+        a.perIterationOutputCapBytes
+      );
+      return { result, durationMs: Date.now() - start };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        result: {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Tool "${tool.name}" threw: ${msg}`,
+          is_error: true
+        },
+        durationMs: Date.now() - start
+      };
+    }
+  }
+  function waitForConfirm(info) {
+    return new Promise((resolve13) => {
+      a.events.emit("tool.confirm_needed", {
+        tool: info.tool,
+        input: info.input,
+        toolUseId: info.toolUseId,
+        suggestedPattern: info.suggestedPattern,
+        resolve: resolve13
+      });
+    });
+  }
+  function emitToolExecuted(toolUseId, toolName, durationMs, ok, input, content) {
+    const sig = sizeSignals(toolName, content);
+    a.events.emit("tool.executed", {
+      id: toolUseId,
+      name: toolName,
+      durationMs,
+      ok,
+      input,
+      output: truncateForEvent(content),
+      outputBytes: sig.outputBytes,
+      outputTokens: sig.outputTokens,
+      outputLines: sig.outputLines
+    });
+  }
+  async function executeTools(toolUses) {
+    const selectedToolUses = await a.extensions.runBeforeToolExecution(a.ctx, toolUses);
+    const { outputs } = await a.toolExecutor.executeBatch(
+      selectedToolUses,
+      a.ctx,
+      a.executionStrategy
+    );
+    const useById = new Map(selectedToolUses.map((u) => [u.id, u]));
+    const resultsForMessage = [];
+    for (const { result, tool, durationMs } of outputs) {
+      if (result.type === "tool_confirm_pending") {
+        const decision = await waitForConfirm({
+          tool,
+          input: result.input,
+          toolUseId: result.toolUseId,
+          suggestedPattern: result.suggestedPattern
+        });
+        if (decision === "always") {
+          try {
+            await a.permission.trust({ tool: tool.name, pattern: result.suggestedPattern });
+            a.events.emit("trust.persisted", { tool: tool.name, pattern: result.suggestedPattern, decision });
+          } catch {
+          }
+        } else if (decision === "deny") {
+          try {
+            await a.permission.deny({ tool: tool.name, pattern: result.suggestedPattern });
+            a.events.emit("trust.persisted", { tool: tool.name, pattern: result.suggestedPattern, decision });
+          } catch {
+          }
+        }
+        if (decision === "yes") {
+          const p = a.permission;
+          p.allowOnce?.({ tool: tool.name, pattern: result.suggestedPattern });
+        } else if (decision === "no") {
+          const p = a.permission;
+          p.denyOnce?.({ tool: tool.name, pattern: result.suggestedPattern });
+        }
+        const reRunResult = decision === "yes" || decision === "always" ? await executeSingleWithDecision(tool, {
+          id: result.toolUseId,
+          name: tool.name,
+          input: result.input
+        }) : {
+          result: {
+            type: "tool_result",
+            tool_use_id: result.toolUseId,
+            content: decision === "deny" ? `Tool "${tool.name}" denied and blocked for this pattern.` : `Tool "${tool.name}" denied by user.`,
+            is_error: true
+          },
+          durationMs: 0
+        };
+        const use2 = useById.get(reRunResult.result.tool_use_id);
+        if (use2) {
+          await a.pipelines.toolCall.run({ toolUse: use2, result: reRunResult.result, ctx: a.ctx, tool });
+          await a.ctx.session.append({
+            type: "tool_result",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            id: reRunResult.result.tool_use_id,
+            content: reRunResult.result.content,
+            isError: !!reRunResult.result.is_error
+          });
+          emitToolExecuted(
+            reRunResult.result.tool_use_id,
+            tool.name,
+            reRunResult.durationMs,
+            !reRunResult.result.is_error,
+            result.input,
+            reRunResult.result.content
+          );
+        }
+        resultsForMessage.push(reRunResult.result);
+        continue;
+      }
+      resultsForMessage.push(result);
+      const use = useById.get(result.tool_use_id);
+      if (!use) continue;
+      await a.pipelines.toolCall.run({ toolUse: use, result, ctx: a.ctx, tool: tool ?? void 0 });
+      await a.ctx.session.append({
+        type: "tool_result",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        id: result.tool_use_id,
+        content: result.content,
+        isError: !!result.is_error
+      });
+      emitToolExecuted(result.tool_use_id, use.name, durationMs, !result.is_error, use.input, result.content);
+    }
+    a.ctx.state.appendMessage({ role: "user", content: resultsForMessage });
+    await a.extensions.runAfterToolExecution(a.ctx, outputs);
+    return resultsForMessage;
+  }
+  return { executeTools, executeSingleWithDecision };
 }
 
 // src/core/continue-to-next-iteration.ts
@@ -25099,13 +25259,13 @@ function parseContinueDirective(text) {
   }
   return lastDirective;
 }
-var META_KEY2 = "_autonomousContinue";
+var META_KEY = "_autonomousContinue";
 function setAutonomousContinue(ctx) {
-  ctx.meta[META_KEY2] = true;
+  ctx.meta[META_KEY] = true;
 }
 function consumeAutonomousContinue(ctx) {
-  const val = ctx.meta[META_KEY2] === true;
-  delete ctx.meta[META_KEY2];
+  const val = ctx.meta[META_KEY] === true;
+  delete ctx.meta[META_KEY];
   return val;
 }
 function makeContinueToNextIterationTool() {
@@ -25128,254 +25288,249 @@ function makeContinueToNextIterationTool() {
   };
 }
 
-// src/core/iteration-limit.ts
-function requestLimitExtension(opts) {
-  const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
-  return new Promise((resolve13) => {
-    let resolved = false;
-    const timerFired = () => {
-      if (!resolved) {
-        resolved = true;
-        resolve13(0);
-      }
+// src/core/agent-response.ts
+function createAgentResponseHandler(a) {
+  async function buildAndRunRequestPipeline(opts) {
+    const repaired = repairToolUseAdjacency(a.ctx.messages);
+    if (repaired.report.changed) {
+      a.ctx.state.replaceMessages(repaired.messages);
+      a.events.emit("context.repaired", {
+        ctx: a.ctx,
+        ...repaired.report
+      });
+      a.logger.warn(
+        `Repaired context tool adjacency: removed ${repaired.report.removedToolUses.length} tool_use block(s), ${repaired.report.removedToolResults.length} tool_result block(s), ${repaired.report.removedMessages} empty message(s)`
+      );
+    }
+    const baseReq = {
+      model: opts.model ?? a.ctx.model,
+      system: a.ctx.systemPrompt,
+      messages: a.ctx.messages,
+      tools: a.tools.list(),
+      maxTokens: 8192
     };
-    const timer = setTimeout(timerFired, timeoutMs);
-    timer.unref();
-    const deny = () => {
-      if (!resolved) {
-        resolved = true;
-        clearTimeout(timer);
-        resolve13(0);
+    return a.pipelines.request.run(baseReq);
+  }
+  async function processResponse(raw, req) {
+    let res = raw;
+    res = await a.pipelines.response.run(res);
+    a.events.emit("provider.response", {
+      ctx: a.ctx,
+      usage: res.usage,
+      stopReason: res.stopReason
+    });
+    a.ctx.tokenCounter.account(res.usage, req.model);
+    a.ctx.state.appendMessage({ role: "assistant", content: res.content });
+    await a.ctx.session.append({
+      type: "llm_response",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      content: res.content,
+      stopReason: res.stopReason,
+      usage: res.usage
+    });
+    if (a.ctx.signal.aborted) {
+      let finalText2 = "";
+      for (const block of res.content) {
+        if (isTextBlock(block)) finalText2 += block.text;
       }
-    };
-    const grant = (extra) => {
-      if (!resolved) {
-        resolved = true;
-        clearTimeout(timer);
-        resolve13(Math.max(0, extra));
+      return { finalText: finalText2, aborted: true, done: false };
+    }
+    let finalText = "";
+    const streamed = a.ctx.provider.capabilities.streaming;
+    for (const block of res.content) {
+      if (isTextBlock(block)) {
+        const rendered = await a.pipelines.assistantOutput.run(block);
+        finalText += rendered.text;
+        if (!streamed) a.renderer?.write(rendered);
       }
-    };
-    events.emit("iteration.limit_reached", {
-      currentIterations,
-      currentLimit,
-      grant,
-      deny
-    });
-    if (autoExtend) {
-      setImmediate(() => {
-        if (!resolved) {
-          resolved = true;
-          clearTimeout(timer);
-          resolve13(100);
-        }
-      });
     }
-  });
+    let directive = "none";
+    if (finalText) {
+      directive = parseContinueDirective(finalText);
+    }
+    return { finalText, aborted: false, done: false, directive };
+  }
+  return { buildAndRunRequestPipeline, processResponse };
 }
 
-// src/core/agent.ts
-var DEFAULT_MAX_ITERATIONS = 100;
-function normalizeInput(input) {
-  if (typeof input === "string") {
-    return { blocks: [{ type: "text", text: input }], text: input };
-  }
-  const text = input.filter(isTextBlock).map((b) => b.text).join("");
-  return { blocks: input, text };
+// src/core/btw.ts
+var META_KEY2 = "_btwNotes";
+function readQueue(ctx) {
+  const raw = ctx.meta[META_KEY2];
+  return Array.isArray(raw) ? raw : [];
 }
-function createDefaultPipelines() {
-  return {
-    request: new Pipeline(),
-    response: new Pipeline(),
-    toolCall: new Pipeline(),
-    userInput: new Pipeline(),
-    assistantOutput: new Pipeline(),
-    contextWindow: new Pipeline()
-  };
+function setBtwNote(ctx, text) {
+  const trimmed = text.trim();
+  if (!trimmed) return readQueue(ctx).length;
+  const next = [...readQueue(ctx), trimmed].slice(-20);
+  ctx.meta[META_KEY2] = next;
+  return next.length;
 }
-var Agent = class {
-  container;
-  tools;
-  providers;
-  events;
-  pipelines;
-  ctx;
-  maxIterations;
-  executionStrategy;
-  perIterationOutputCapBytes;
-  plugins = [];
-  toolExecutor;
-  autoExtendLimit;
-  /** Enables autonomous continue: model can signal `[continue]` or call continue_to_next_iteration() to re-run. */
-  autonomousContinue;
-  tracer;
-  extensions;
-  constructor(init) {
-    this.container = init.container;
-    this.tools = init.tools;
-    this.providers = init.providers;
-    this.events = init.events;
-    this.pipelines = init.pipelines;
-    this.ctx = init.context;
-    this.maxIterations = init.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-    this.executionStrategy = init.executionStrategy ?? "smart";
-    this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
-    this.autoExtendLimit = init.autoExtendLimit ?? true;
-    this.autonomousContinue = init.autonomousContinue ?? false;
-    this.tracer = init.tracer;
-    this.extensions = init.extensions ?? new ExtensionRegistry();
-    this.extensions.setLogger(this.container.resolve(TOKENS.Logger));
-    this.toolExecutor = init.toolExecutor;
-  }
-  get logger() {
-    return this.container.resolve(TOKENS.Logger);
-  }
-  get retry() {
-    return this.container.resolve(TOKENS.RetryPolicy);
-  }
-  get errorHandler() {
-    return this.container.resolve(TOKENS.ErrorHandler);
-  }
-  get permission() {
-    return this.container.resolve(TOKENS.PermissionPolicy);
-  }
-  get renderer() {
-    return this.container.has(TOKENS.Renderer) ? this.container.resolve(TOKENS.Renderer) : void 0;
-  }
-  /**
-   * Switch from inline CLI prompts to event-driven confirmation.
-   * Clears both the ToolExecutor's confirmAwaiter (so it returns
-   * `ToolConfirmPendingResult`) and the permission policy's
-   * promptDelegate (so `evaluate()` returns `confirm`).
-   *
-   * Call this before entering TUI or any mode where stdin is owned
-   * by a UI framework (Ink, WebUI WS bridge). Without this, the
-   * inline prompt writes to stdout and blocks on stdin — both of
-   * which are owned by the framework — making the prompt invisible
-   * and the input deadlocked.
-   */
-  disableInteractiveConfirmation() {
-    this.toolExecutor.clearConfirmAwaiter();
-    const policy = this.permission;
-    if (typeof policy.setPromptDelegate === "function") {
-      policy.setPromptDelegate(void 0);
+function pendingBtwCount(ctx) {
+  return readQueue(ctx).length;
+}
+function consumeBtwNotes(ctx) {
+  const notes = readQueue(ctx);
+  if (notes.length > 0) delete ctx.meta[META_KEY2];
+  return notes;
+}
+function buildBtwBlock(notes) {
+  const body = notes.map((n) => `- ${n}`).join("\n");
+  return [
+    "[BY THE WAY \u2014 the user added this while you were working. Fold it into",
+    "your current task; do not restart from scratch unless it contradicts the",
+    "goal:",
+    "",
+    body,
+    "]"
+  ].join("\n");
+}
+
+// src/core/iteration-limit.ts
+function requestLimitExtension(opts) {
+  const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
+  return new Promise((resolve13) => {
+    let resolved = false;
+    const timerFired = () => {
+      if (!resolved) {
+        resolved = true;
+        resolve13(0);
+      }
+    };
+    const timer = setTimeout(timerFired, timeoutMs);
+    timer.unref();
+    const deny = () => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve13(0);
+      }
+    };
+    const grant = (extra) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve13(Math.max(0, extra));
+      }
+    };
+    events.emit("iteration.limit_reached", {
+      currentIterations,
+      currentLimit,
+      grant,
+      deny
+    });
+    if (autoExtend) {
+      setImmediate(() => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          resolve13(100);
+        }
+      });
     }
+  });
+}
+
+// src/core/agent-loop.ts
+function toError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function createAgentLoopHandler(a, handlers) {
+  async function compactContextIfNeeded() {
+    await a.pipelines.contextWindow.run(a.ctx);
   }
-  register(tool) {
-    this.tools.register(tool);
-  }
-  async use(plugin, api) {
-    await plugin.setup(api);
-    this.plugins.push({ plugin, api });
+  function emitContextPct() {
+    const maxContext = a.ctx.provider.capabilities.maxContext ?? 2e5;
+    const { total } = estimateRequestTokens(a.ctx.messages, a.ctx.systemPrompt, a.ctx.tools ?? []);
+    a.events.emit("ctx.pct", { load: total / maxContext, tokens: total, maxContext });
   }
-  /** Tear down all plugins in reverse order, calling their teardown hooks. */
-  async teardown() {
-    const errors = [];
-    for (const { plugin, api } of this.plugins.toReversed()) {
-      if (typeof plugin.teardown !== "function") continue;
-      try {
-        await plugin.teardown(api);
-      } catch (err) {
-        errors.push(err);
-      }
-    }
-    this.plugins.length = 0;
-    if (errors.length > 0) {
-      throw new Error(`Agent teardown failed: ${errors.map(String).join("; ")}`);
+  function injectPendingBtwNotes() {
+    const notes = consumeBtwNotes(a.ctx);
+    if (notes.length === 0) return;
+    const block = { type: "text", text: buildBtwBlock(notes) };
+    const messages = a.ctx.messages;
+    const last = messages[messages.length - 1];
+    if (last && last.role === "user") {
+      const content = typeof last.content === "string" ? [{ type: "text", text: last.content }, block] : [...last.content, block];
+      a.ctx.state.replaceMessages([...messages.slice(0, -1), { ...last, content }]);
+    } else {
+      a.ctx.state.appendMessage({ role: "user", content: [block] });
     }
   }
-  async run(userInput, opts = {}) {
-    const controller = new RunController({ parentSignal: opts.signal });
-    const signal = controller.signal;
-    this.ctx.signal = signal;
-    controller.onAbort(() => this.ctx.drainAbortHooks());
-    const span = this.tracer?.startSpan("agent.run", {
-      "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(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");
-      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 function checkIterationLimit(iterationIndex, limit, hasHardLimit, currentIterations, delegateSummaries) {
+    if (hasHardLimit && iterationIndex >= limit) {
+      const extendBy = await requestLimitExtension({
+        events: a.events,
+        currentIterations,
+        currentLimit: limit,
+        autoExtend: a.autoExtendLimit
+      });
+      if (extendBy > 0) {
+        const newLimit = limit + extendBy;
+        a.logger.info(`Iteration limit extended by ${extendBy} (new limit: ${newLimit})`);
+        return { limit: newLimit };
+      }
+      return { limit, exit: { status: "max_iterations", iterations: currentIterations, delegateSummaries } };
     }
+    return { limit };
   }
-  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({
+  async function runInner(inputPayload, opts, controller, autonomousContinue) {
+    await a.pipelines.userInput.run(inputPayload);
+    a.ctx.state.appendMessage({ role: "user", content: inputPayload.content });
+    await a.ctx.session.append({
       type: "user_input",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       content: inputPayload.content
     });
-    const promptIndex = this.ctx.messages.filter((m) => m.role === "user").length - 1;
+    const promptIndex = a.ctx.messages.filter((m) => m.role === "user").length - 1;
     const preview = inputPayload.text.slice(0, 80) + (inputPayload.text.length > 80 ? "\u2026" : "");
-    await this.ctx.session.writeCheckpoint(promptIndex, preview);
+    await a.ctx.session.writeCheckpoint(promptIndex, preview);
     let finalText = "";
     let iterations = 0;
     const delegateSummaries = [];
-    let effectiveLimit = opts.maxIterations ?? this.maxIterations;
+    let effectiveLimit = opts.maxIterations ?? a.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 offSubagentDone = a.events.on("subagent.done", onSubagentDone);
+    const diRunner = a.container.has(TOKENS.ProviderRunner) ? a.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
+      events: a.events,
+      retry: a.retry,
+      logger: a.logger,
+      tracer: a.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
+      events: a.events,
+      retry: a.retry,
+      logger: a.logger,
+      tracer: a.tracer
     });
-    const customRunner = this.extensions.wrapProviderRunner(baseRunner);
+    const customRunner = a.extensions.wrapProviderRunner(baseRunner);
     try {
       for (let i = 0; ; i++) {
         iterations = i + 1;
         if (controller.signal.aborted) {
           return { status: "aborted", iterations };
         }
-        await this.ctx.session.writeInFlightMarker(`iteration ${i} / max ${this.maxIterations}`).catch((err) => {
-          this.logger.debug?.(
+        await a.ctx.session.writeInFlightMarker(`iteration ${i} / max ${a.maxIterations}`).catch((err) => {
+          a.logger.debug?.(
             `in-flight marker write failed: ${err instanceof Error ? err.message : String(err)}`
           );
         });
         if (autonomousContinue) {
-          consumeAutonomousContinue(this.ctx);
+          consumeAutonomousContinue(a.ctx);
         }
-        const limitCheck = await this.checkIterationLimit(
+        const limitCheck = await checkIterationLimit(
           i,
           effectiveLimit,
           hasHardLimit,
@@ -25386,11 +25541,11 @@ 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 });
-        this.injectPendingBtwNotes();
-        const req = await this.buildAndRunRequestPipeline(opts);
-        await this.ctx.session.append({
+        await a.extensions.runBeforeIteration(a.ctx, i);
+        a.events.emit("iteration.started", { ctx: a.ctx, index: i });
+        injectPendingBtwNotes();
+        const req = await handlers.response.buildAndRunRequestPipeline(opts);
+        await a.ctx.session.append({
           type: "llm_request",
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           model: req.model,
@@ -25401,39 +25556,39 @@ var Agent = class {
         });
         let res;
         try {
-          res = await customRunner(this.ctx, req);
+          res = await customRunner(a.ctx, req);
           const calibratedEstimate = estimateRequestTokensCalibrated(req.messages, req.system, req.tools ?? []).total;
           recordActualUsage(res.usage.input, calibratedEstimate);
           recoveryRetries = 0;
         } catch (err) {
           if (controller.signal.aborted) {
-            this.events.emit("error", { err: toError(err), phase: "provider" });
+            a.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);
+          const extDecision = await a.extensions.runOnError(a.ctx, err, "provider", i);
           if (extDecision) {
             if (extDecision.action === "fail") {
-              this.events.emit("error", { err: toError(err), phase: "provider" });
+              a.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);
+              await a.extensions.runAfterIteration(a.ctx, i);
               continue;
             }
             if (extDecision.action === "retry") {
               recoveryRetries++;
               if (recoveryRetries > 2) {
-                this.events.emit("error", { err: toError(err), phase: "provider" });
+                a.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");
+              if (extDecision.model) a.ctx.model = extDecision.model;
+              a.logger.info("Extension requested retry; retrying turn");
               continue;
             }
           }
-          const recovered = await this.errorHandler.recover(err, this.ctx);
+          const recovered = await a.errorHandler.recover(err, a.ctx);
           if (!recovered || recovered.action === "fail") {
-            this.events.emit("error", { err: toError(err), phase: "provider" });
+            a.events.emit("error", { err: toError(err), phase: "provider" });
             return {
               status: "failed",
               iterations,
@@ -25444,17 +25599,17 @@ var Agent = class {
           if (recovered.action === "retry") {
             recoveryRetries++;
             if (recoveryRetries > 2) {
-              this.events.emit("error", { err: toError(err), phase: "provider" });
+              a.events.emit("error", { err: toError(err), phase: "provider" });
               return { status: "failed", iterations, error: toWrongStackError(err) };
             }
-            if (recovered.model) this.ctx.model = recovered.model;
-            this.logger.info(`Recovered provider error via ${recovered.reason}; retrying turn`);
+            if (recovered.model) a.ctx.model = recovered.model;
+            a.logger.info(`Recovered provider error via ${recovered.reason}; retrying turn`);
             continue;
           }
           recoveryRetries = 0;
           res = recovered.response;
         }
-        const responseResult = await this.processResponse(res, req);
+        const responseResult = await handlers.response.processResponse(res, req);
         if (responseResult.aborted) {
           return { status: "aborted", iterations, finalText: responseResult.finalText, delegateSummaries };
         }
@@ -25464,11 +25619,11 @@ var Agent = class {
         finalText = responseResult.finalText;
         const toolUses = res.content.filter(isToolUseBlock);
         if (toolUses.length === 0) {
-          this.emitContextPct();
-          this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
+          emitContextPct();
+          a.events.emit("iteration.completed", { ctx: a.ctx, index: i });
           if (autonomousContinue && responseResult.directive === "continue") {
-            await this.compactContextIfNeeded();
-            await this.extensions.runAfterIteration(this.ctx, i);
+            await compactContextIfNeeded();
+            await a.extensions.runAfterIteration(a.ctx, i);
             continue;
           }
           if (autonomousContinue && responseResult.directive === "stop") {
@@ -25476,18 +25631,18 @@ var Agent = class {
           }
           return { status: "done", iterations, finalText, delegateSummaries };
         }
-        await this.executeTools(toolUses);
-        if (autonomousContinue && consumeAutonomousContinue(this.ctx)) {
-          this.emitContextPct();
-          this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
-          await this.compactContextIfNeeded();
-          await this.extensions.runAfterIteration(this.ctx, i);
+        await handlers.tools.executeTools(toolUses);
+        if (autonomousContinue && consumeAutonomousContinue(a.ctx)) {
+          emitContextPct();
+          a.events.emit("iteration.completed", { ctx: a.ctx, index: i });
+          await compactContextIfNeeded();
+          await a.extensions.runAfterIteration(a.ctx, i);
           continue;
         }
-        this.emitContextPct();
-        this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
-        await this.compactContextIfNeeded();
-        await this.extensions.runAfterIteration(this.ctx, i);
+        emitContextPct();
+        a.events.emit("iteration.completed", { ctx: a.ctx, index: i });
+        await compactContextIfNeeded();
+        await a.extensions.runAfterIteration(a.ctx, i);
         if (autonomousContinue && responseResult.directive === "continue") {
           continue;
         }
@@ -25498,346 +25653,161 @@ var Agent = class {
     } finally {
       offSubagentDone();
       const reason = controller.signal.aborted ? "aborted" : "clean";
-      await this.ctx.session.clearInFlightMarker(reason).catch((err) => {
-        this.logger.debug?.(
+      await a.ctx.session.clearInFlightMarker(reason).catch((err) => {
+        a.logger.debug?.(
           `in-flight marker clear failed: ${err instanceof Error ? err.message : String(err)}`
         );
       });
     }
   }
-  /**
-   * Check if iteration limit has been reached and request extension if needed.
-   * Returns the new effective limit (possibly extended) and a RunResult if
-   * the loop should exit. Returns `{ limit }` with no result when the
-   * iteration may proceed.
-   */
-  async checkIterationLimit(iterationIndex, limit, hasHardLimit, currentIterations, delegateSummaries) {
-    if (hasHardLimit && iterationIndex >= limit) {
-      const extendBy = await requestLimitExtension({
-        events: this.events,
-        currentIterations,
-        currentLimit: limit,
-        autoExtend: this.autoExtendLimit
-      });
-      if (extendBy > 0) {
-        const newLimit = limit + extendBy;
-        this.logger.info(`Iteration limit extended by ${extendBy} (new limit: ${newLimit})`);
-        return { limit: newLimit };
-      }
-      return { limit, exit: { status: "max_iterations", iterations: currentIterations, delegateSummaries } };
-    }
-    return { limit };
-  }
-  /**
-   * Build request and run through request pipeline.
-   */
-  async buildAndRunRequestPipeline(opts) {
-    const repaired = repairToolUseAdjacency(this.ctx.messages);
-    if (repaired.report.changed) {
-      this.ctx.state.replaceMessages(repaired.messages);
-      this.events.emit("context.repaired", {
-        ctx: this.ctx,
-        ...repaired.report
-      });
-      this.logger.warn(
-        `Repaired context tool adjacency: removed ${repaired.report.removedToolUses.length} tool_use block(s), ${repaired.report.removedToolResults.length} tool_result block(s), ${repaired.report.removedMessages} empty message(s)`
-      );
-    }
-    const baseReq = {
-      model: opts.model ?? this.ctx.model,
-      system: this.ctx.systemPrompt,
-      messages: this.ctx.messages,
-      tools: this.tools.list(),
-      maxTokens: 8192
-    };
-    return this.pipelines.request.run(baseReq);
+  return { runInner };
+}
+
+// src/core/agent-types.ts
+var DEFAULT_MAX_ITERATIONS = 100;
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return { blocks: [{ type: "text", text: input }], text: input };
   }
-  /**
-   * Process the provider response: run response pipeline, emit events,
-   * update session, render text, handle abort.
-   */
-  async processResponse(raw, req) {
-    let res = raw;
-    res = await this.pipelines.response.run(res);
-    this.events.emit("provider.response", {
-      ctx: this.ctx,
-      usage: res.usage,
-      stopReason: res.stopReason
-    });
-    this.ctx.tokenCounter.account(res.usage, req.model);
-    this.ctx.state.appendMessage({ role: "assistant", content: res.content });
-    await this.ctx.session.append({
-      type: "llm_response",
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      content: res.content,
-      stopReason: res.stopReason,
-      usage: res.usage
+  const text = input.filter(isTextBlock).map((b) => b.text).join("");
+  return { blocks: input, text };
+}
+function createDefaultPipelines() {
+  return {
+    request: new Pipeline(),
+    response: new Pipeline(),
+    toolCall: new Pipeline(),
+    userInput: new Pipeline(),
+    assistantOutput: new Pipeline(),
+    contextWindow: new Pipeline()
+  };
+}
+
+// src/core/agent.ts
+var Agent = class {
+  container;
+  tools;
+  providers;
+  events;
+  pipelines;
+  ctx;
+  maxIterations;
+  executionStrategy;
+  perIterationOutputCapBytes;
+  plugins = [];
+  toolExecutor;
+  autoExtendLimit;
+  autonomousContinue;
+  tracer;
+  extensions;
+  _toolHandler;
+  _responseHandler;
+  _loopHandler;
+  constructor(init) {
+    this.container = init.container;
+    this.tools = init.tools;
+    this.providers = init.providers;
+    this.events = init.events;
+    this.pipelines = init.pipelines;
+    this.ctx = init.context;
+    this.maxIterations = init.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    this.executionStrategy = init.executionStrategy ?? "smart";
+    this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
+    this.autoExtendLimit = init.autoExtendLimit ?? true;
+    this.autonomousContinue = init.autonomousContinue ?? false;
+    this.tracer = init.tracer;
+    this.extensions = init.extensions ?? new ExtensionRegistry();
+    this.extensions.setLogger(this.container.resolve(TOKENS.Logger));
+    this.toolExecutor = init.toolExecutor;
+    this._toolHandler = createAgentToolHandler(this);
+    this._responseHandler = createAgentResponseHandler(this);
+    this._loopHandler = createAgentLoopHandler(this, {
+      tools: this._toolHandler,
+      response: this._responseHandler
     });
-    if (this.ctx.signal.aborted) {
-      let finalText2 = "";
-      for (const block of res.content) {
-        if (isTextBlock(block)) finalText2 += block.text;
-      }
-      return { finalText: finalText2, aborted: true, done: false };
-    }
-    let finalText = "";
-    const streamed = this.ctx.provider.capabilities.streaming;
-    for (const block of res.content) {
-      if (isTextBlock(block)) {
-        const rendered = await this.pipelines.assistantOutput.run(block);
-        finalText += rendered.text;
-        if (!streamed) this.renderer?.write(rendered);
-      }
-    }
-    let directive = "none";
-    if (finalText) {
-      directive = parseContinueDirective(finalText);
+  }
+  get logger() {
+    return this.container.resolve(TOKENS.Logger);
+  }
+  get retry() {
+    return this.container.resolve(TOKENS.RetryPolicy);
+  }
+  get errorHandler() {
+    return this.container.resolve(TOKENS.ErrorHandler);
+  }
+  get permission() {
+    return this.container.resolve(TOKENS.PermissionPolicy);
+  }
+  get renderer() {
+    return this.container.has(TOKENS.Renderer) ? this.container.resolve(TOKENS.Renderer) : void 0;
+  }
+  disableInteractiveConfirmation() {
+    this.toolExecutor.clearConfirmAwaiter();
+    const policy = this.permission;
+    if (typeof policy.setPromptDelegate === "function") {
+      policy.setPromptDelegate(void 0);
     }
-    return { finalText, aborted: false, done: false, directive };
   }
-  /**
-   * Execute tools and append tool results to context.
-   * When a tool returns `tool_confirm_pending` (no confirmAwaiter set),
-   * we pause and emit `tool.confirm_needed`. The run is blocked until
-   * the event listener resolves the confirmation, then we re-run the
-   * single tool.
-   */
-  async executeTools(toolUses) {
-    const selectedToolUses = await this.extensions.runBeforeToolExecution(this.ctx, toolUses);
-    const { outputs } = await this.toolExecutor.executeBatch(
-      selectedToolUses,
-      this.ctx,
-      this.executionStrategy
-    );
-    const useById = new Map(selectedToolUses.map((u) => [u.id, u]));
-    const resultsForMessage = [];
-    for (const { result, tool, durationMs } of outputs) {
-      if (result.type === "tool_confirm_pending") {
-        const decision = await this.waitForConfirm({
-          tool,
-          input: result.input,
-          toolUseId: result.toolUseId,
-          suggestedPattern: result.suggestedPattern
-        });
-        if (decision === "always") {
-          try {
-            await this.permission.trust({
-              tool: tool.name,
-              pattern: result.suggestedPattern
-            });
-            this.events.emit("trust.persisted", {
-              tool: tool.name,
-              pattern: result.suggestedPattern,
-              decision
-            });
-          } catch {
-          }
-        } else if (decision === "deny") {
-          try {
-            await this.permission.deny({
-              tool: tool.name,
-              pattern: result.suggestedPattern
-            });
-            this.events.emit("trust.persisted", {
-              tool: tool.name,
-              pattern: result.suggestedPattern,
-              decision
-            });
-          } catch {
-          }
-        }
-        if (decision === "yes") {
-          const p = this.permission;
-          p.allowOnce?.({ tool: tool.name, pattern: result.suggestedPattern });
-        } else if (decision === "no") {
-          const p = this.permission;
-          p.denyOnce?.({ tool: tool.name, pattern: result.suggestedPattern });
-        }
-        const reRunResult = decision === "yes" || decision === "always" ? await this.executeSingleWithDecision(
-          tool,
-          { id: result.toolUseId, name: tool.name, input: result.input }
-        ) : {
-          result: {
-            type: "tool_result",
-            tool_use_id: result.toolUseId,
-            content: decision === "deny" ? `Tool "${tool.name}" denied and blocked for this pattern.` : `Tool "${tool.name}" denied by user.`,
-            is_error: true
-          },
-          durationMs: 0
-        };
-        const use2 = useById.get(reRunResult.result.tool_use_id);
-        if (use2) {
-          await this.pipelines.toolCall.run({
-            toolUse: use2,
-            result: reRunResult.result,
-            ctx: this.ctx,
-            tool
-          });
-          await this.ctx.session.append({
-            type: "tool_result",
-            ts: (/* @__PURE__ */ new Date()).toISOString(),
-            id: reRunResult.result.tool_use_id,
-            content: reRunResult.result.content,
-            isError: !!reRunResult.result.is_error
-          });
-          {
-            const sig = sizeSignals(tool?.name, reRunResult.result.content);
-            this.events.emit("tool.executed", {
-              id: reRunResult.result.tool_use_id,
-              name: tool.name,
-              durationMs: reRunResult.durationMs,
-              ok: !reRunResult.result.is_error,
-              input: result.input,
-              output: truncateForEvent(reRunResult.result.content),
-              outputBytes: sig.outputBytes,
-              outputTokens: sig.outputTokens,
-              outputLines: sig.outputLines
-            });
-          }
-        }
-        resultsForMessage.push(reRunResult.result);
-        continue;
-      }
-      resultsForMessage.push(result);
-      const use = useById.get(result.tool_use_id);
-      if (!use) continue;
-      await this.pipelines.toolCall.run({
-        toolUse: use,
-        result,
-        ctx: this.ctx,
-        tool: tool ?? void 0
-      });
-      await this.ctx.session.append({
-        type: "tool_result",
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        id: result.tool_use_id,
-        content: result.content,
-        isError: !!result.is_error
-      });
-      {
-        const sig = sizeSignals(use.name, result.content);
-        this.events.emit("tool.executed", {
-          id: result.tool_use_id,
-          name: use.name,
-          durationMs,
-          ok: !result.is_error,
-          input: use.input,
-          output: truncateForEvent(result.content),
-          outputBytes: sig.outputBytes,
-          outputTokens: sig.outputTokens,
-          outputLines: sig.outputLines
-        });
+  register(tool) {
+    this.tools.register(tool);
+  }
+  async use(plugin, api) {
+    await plugin.setup(api);
+    this.plugins.push({ plugin, api });
+  }
+  async teardown() {
+    const errors = [];
+    for (const { plugin, api } of this.plugins.toReversed()) {
+      if (typeof plugin.teardown !== "function") continue;
+      try {
+        await plugin.teardown(api);
+      } catch (err) {
+        errors.push(err);
       }
     }
-    this.ctx.state.appendMessage({
-      role: "user",
-      content: resultsForMessage
-    });
-    await this.extensions.runAfterToolExecution(this.ctx, outputs);
-  }
-  /**
-   * Fold any pending `/btw` notes into the conversation. Called at the top of
-   * each iteration so a note set mid-run reaches the model on its next turn.
-   *
-   * To stay valid across all provider wire families we never create two
-   * consecutive user messages: if the last message is a user turn (e.g. the
-   * tool_result block from the previous iteration) we append the note as an
-   * extra text block on that turn; otherwise we add a fresh user message.
-   */
-  injectPendingBtwNotes() {
-    const notes = consumeBtwNotes(this.ctx);
-    if (notes.length === 0) return;
-    const block = { type: "text", text: buildBtwBlock(notes) };
-    const messages = this.ctx.messages;
-    const last = messages[messages.length - 1];
-    if (last && last.role === "user") {
-      const content = typeof last.content === "string" ? [{ type: "text", text: last.content }, block] : [...last.content, block];
-      this.ctx.state.replaceMessages([...messages.slice(0, -1), { ...last, content }]);
-    } else {
-      this.ctx.state.appendMessage({ role: "user", content: [block] });
+    this.plugins.length = 0;
+    if (errors.length > 0) {
+      throw new Error(`Agent teardown failed: ${errors.map(String).join("; ")}`);
     }
   }
-  waitForConfirm(info) {
-    return new Promise((resolve13) => {
-      this.events.emit("tool.confirm_needed", {
-        tool: info.tool,
-        input: info.input,
-        toolUseId: info.toolUseId,
-        suggestedPattern: info.suggestedPattern,
-        resolve: resolve13
-      });
+  async run(userInput, opts = {}) {
+    const controller = new RunController({ parentSignal: opts.signal });
+    const signal = controller.signal;
+    this.ctx.signal = signal;
+    controller.onAbort(() => this.ctx.drainAbortHooks());
+    const span = this.tracer?.startSpan("agent.run", {
+      "agent.model": opts.model ?? this.ctx.model,
+      "agent.executionStrategy": opts.executionStrategy ?? this.executionStrategy
     });
-  }
-  async executeSingleWithDecision(tool, use) {
-    const start = Date.now();
+    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.toolExecutor.executeTool(
-        tool,
-        use,
-        this.ctx,
-        this.perIterationOutputCapBytes
-      );
-      return { result, durationMs: Date.now() - start };
+      const autonomousContinue = opts.autonomousContinue ?? this.autonomousContinue;
+      const result = await this._loopHandler.runInner(inputPayload, opts, controller, autonomousContinue);
+      span?.setAttribute("agent.status", result.status);
+      span?.setAttribute("agent.iterations", result.iterations);
+      await this.extensions.runAfterRun(this.ctx, result);
+      return result;
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return {
-        result: {
-          type: "tool_result",
-          tool_use_id: use.id,
-          content: `Tool "${tool.name}" threw: ${msg}`,
-          is_error: true
-        },
-        durationMs: Date.now() - start
+      const wse = err instanceof AgentError ? err : toWrongStackError(err);
+      this.events.emit("error", { err: err instanceof Error ? err : new Error(String(err)), phase: "agent" });
+      if (err instanceof Error) span?.recordError(err);
+      span?.setAttribute("agent.status", "failed");
+      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();
     }
   }
-  /**
-   * Run context window pipeline. The pipeline may be empty, or it may contain
-   * middleware with its own injected dependencies.
-   */
-  async compactContextIfNeeded() {
-    await this.pipelines.contextWindow.run(this.ctx);
-  }
-  /**
-   * Emit the current context window load as a `ctx.pct` event so subscribers
-   * (FleetBus → TUI) can render a live fill bar per agent.
-   */
-  emitContextPct() {
-    const maxContext = this.ctx.provider.capabilities.maxContext ?? 2e5;
-    const { total } = estimateRequestTokens(
-      this.ctx.messages,
-      this.ctx.systemPrompt,
-      this.ctx.tools ?? []
-    );
-    this.events.emit("ctx.pct", { load: total / maxContext, tokens: total, maxContext });
-  }
+  // ── Tool + response execution handled by AgentToolHandler / AgentResponseHandler ──
 };
-function toError(err) {
-  return err instanceof Error ? err : new Error(String(err));
-}
-function truncateForEvent(content, max = 400) {
-  if (!content) return "";
-  return content.length <= max ? content : `${content.slice(0, max - 1)}\u2026`;
-}
-function sizeSignals(toolName, content) {
-  if (typeof content !== "string" || content.length === 0) {
-    return { outputBytes: 0, outputTokens: 0, outputLines: void 0 };
-  }
-  const outputBytes = Buffer.byteLength(content, "utf8");
-  const outputTokens = Math.max(1, Math.round(outputBytes / 3.5));
-  let outputLines;
-  if (toolName === "read") {
-    const lineRe = /^\s*\d+→/gm;
-    let count = 0;
-    while (lineRe.exec(content) !== null) count++;
-    if (count > 0) outputLines = count;
-  } else if (toolName === "bash" || toolName === "shell" || toolName === "grep" || toolName === "logs") {
-    let nl = 0;
-    for (let i = 0; i < content.length; i++) if (content.charCodeAt(i) === 10) nl++;
-    outputLines = nl + (content.endsWith("\n") ? 0 : 1);
-  }
-  return { outputBytes, outputTokens, outputLines };
-}
 
 // src/hooks/registry.ts
 var HookRegistry = class {