@wrongstack/core 0.1.1 → 0.1.3

package/dist/defaults/index.js

@@ -1,9 +1,10 @@
-import * as fs4 from 'fs';
+import * as fs5 from 'fs';
 import * as path2 from 'path';
 import * as fsp from 'fs/promises';
+import * as crypto2 from 'crypto';
 import { randomBytes, createCipheriv, createDecipheriv, randomUUID } from 'crypto';
-import * as os from 'os';
 import { EventEmitter } from 'events';
+import * as os from 'os';
 
 // src/defaults/logger.ts
 
@@ -61,7 +62,7 @@ var DefaultLogger = class _DefaultLogger {
     this.pretty = opts.pretty ?? true;
     if (this.file) {
       try {
-        fs4.mkdirSync(path2.dirname(this.file), { recursive: true });
+        fs5.mkdirSync(path2.dirname(this.file), { recursive: true });
       } catch {
       }
     }
@@ -100,7 +101,7 @@ var DefaultLogger = class _DefaultLogger {
     }
     if (this.file) {
       try {
-        fs4.appendFileSync(this.file, `${JSON.stringify(entry)}
+        fs5.appendFileSync(this.file, `${JSON.stringify(entry)}
 `);
       } catch {
       }
@@ -148,7 +149,7 @@ var DefaultPathResolver = class {
     while (dir !== root) {
       for (const marker of PROJECT_MARKERS) {
         try {
-          fs4.accessSync(path2.join(dir, marker));
+          fs5.accessSync(path2.join(dir, marker));
           return dir;
         } catch {
         }
@@ -163,7 +164,7 @@ var DefaultPathResolver = class {
     const abs = path2.isAbsolute(input) ? input : path2.resolve(this.cwd, input);
     let real;
     try {
-      real = fs4.realpathSync(abs);
+      real = fs5.realpathSync(abs);
     } catch {
       real = path2.normalize(abs);
     }
@@ -187,248 +188,6 @@ var DefaultPathResolver = class {
   }
 };
 
-// src/defaults/secret-scrubber.ts
-var PATTERNS = [
-  // Anchored at the start where possible so partial matches inside larger
-  // strings don't trigger false positives.
-  { type: "anthropic_key", regex: /(?<![A-Za-z0-9])sk-ant-api\d+-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
-  { type: "openai_key", regex: /(?<![A-Za-z0-9])sk-(?:proj-)?[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
-  { type: "github_pat", regex: /(?<![A-Za-z0-9])ghp_[A-Za-z0-9]{36,}(?![A-Za-z0-9])/g },
-  { type: "github_pat_v2", regex: /(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{50,}(?![A-Za-z0-9])/g },
-  { type: "aws_access_key", regex: /(?<![A-Za-z0-9])AKIA[0-9A-Z]{16}(?![A-Za-z0-9])/g },
-  { type: "gcp_key", regex: /(?<![A-Za-z0-9])AIza[0-9A-Za-z_-]{35}(?![A-Za-z0-9])/g },
-  { type: "slack_token", regex: /(?<![A-Za-z0-9-])xox[abpos]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])/g },
-  { type: "stripe_key", regex: /(?<![A-Za-z0-9])sk_(?:live|test)_[A-Za-z0-9]{24,}(?![A-Za-z0-9])/g },
-  { type: "twilio_sid", regex: /(?<![A-Za-z0-9])AC[a-f0-9]{32}(?![A-Za-z0-9])/g },
-  {
-    type: "jwt",
-    // Anchored: look for literal "eyJ" which is unambiguous for JWT header
-    regex: /(?<![A-Za-z0-9/+=])eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}(?![A-Za-z0-9/+=])/g
-  },
-  {
-    type: "private_key",
-    // Anchored: start must be BEGIN, end must be END with no extra dashes after END
-    regex: /(?:^|\n)-----BEGIN (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----[\s\S]*?-----END[^-]*-----(?:\n|$)/g
-  },
-  { type: "mongodb_uri", regex: /mongodb(?:\+srv)?:\/\/[^\s"'`]+/g },
-  { type: "postgres_uri", regex: /postgres(?:ql)?:\/\/[^\s"'`]+/g },
-  { type: "mysql_uri", regex: /mysql:\/\/[^\s"'`]+/g },
-  { type: "redis_uri", regex: /redis:\/\/[^\s"'`]+/g },
-  { type: "bearer_token", regex: /(?<![A-Za-z0-9_.~+/-])Bearer\s+[A-Za-z0-9._~+/-]{20,}=*(?![A-Za-z0-9_.~+/-])/g },
-  {
-    type: "high_entropy_env",
-    // Value-side word boundary + length gate to avoid matching short random strings
-    regex: /\b([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,})['"]?(?!\s*[A-Za-z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))/g
-  }
-];
-var DefaultSecretScrubber = class {
-  scrub(text) {
-    if (!text) return text;
-    let out = text;
-    for (const p of PATTERNS) {
-      out = out.replace(p.regex, (_match, group1, group2) => {
-        if (p.type === "high_entropy_env" && group1 && group2) {
-          return `${group1}=[REDACTED:${p.type}]`;
-        }
-        return `[REDACTED:${p.type}]`;
-      });
-    }
-    return out;
-  }
-  scrubObject(obj) {
-    const seen = /* @__PURE__ */ new WeakSet();
-    const visit = (v) => {
-      if (typeof v === "string") return this.scrub(v);
-      if (v === null || typeof v !== "object") return v;
-      if (seen.has(v)) return v;
-      seen.add(v);
-      if (Array.isArray(v)) return v.map(visit);
-      const out = {};
-      for (const [k, val] of Object.entries(v)) {
-        out[k] = visit(val);
-      }
-      return out;
-    };
-    return visit(obj);
-  }
-};
-
-// src/types/provider.ts
-var ProviderError = class extends Error {
-  status;
-  retryable;
-  providerId;
-  body;
-  cause;
-  constructor(message, status, retryable, providerId, opts = {}) {
-    super(message);
-    this.name = "ProviderError";
-    this.status = status;
-    this.retryable = retryable;
-    this.providerId = providerId;
-    this.body = opts.body;
-    this.cause = opts.cause;
-  }
-  /**
-   * Render a one-line, user-facing description. Designed for the CLI/TUI
-   * status line and the agent's retry warning. Avoids dumping raw JSON
-   * (which is what users see today when a 529 lands and the log message
-   * includes the full `{"type":"error",...}` body).
-   *
-   * Examples:
-   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
-   *   "openai rate limited (429): Retry after 12s"
-   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
-   *   "groq HTTP 500 (server error)"
-   */
-  describe() {
-    const kind = describeStatus(this.status, this.body?.type);
-    const head = `${this.providerId} ${kind}`;
-    const detail = this.body?.message?.trim();
-    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
-    if (detail && detail.length > 0) {
-      return `${head}: ${truncate(detail, 240)}${reqId}`;
-    }
-    return `${head}${reqId}`;
-  }
-};
-function describeStatus(status, type) {
-  if (status === 0) return "network error";
-  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
-  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
-  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
-  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
-  if (type === "not_found_error" || status === 404) return `not found (${status})`;
-  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
-  if (status === 408) return `timeout (${status})`;
-  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
-  if (type) return `${type} (${status})`;
-  return `HTTP ${status}`;
-}
-function truncate(s, n) {
-  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
-}
-
-// src/defaults/retry-policy.ts
-var DefaultRetryPolicy = class {
-  shouldRetry(err, attempt) {
-    if (err instanceof ProviderError) {
-      if (!err.retryable) return false;
-      return attempt < this.maxAttempts(err);
-    }
-    const msg = err.message ?? "";
-    const isNetwork = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i.test(msg);
-    if (isNetwork) return attempt < 2;
-    return false;
-  }
-  maxAttempts(err) {
-    if (err instanceof ProviderError) {
-      if (err.status === 429) return 5;
-      if (err.status === 529) return 3;
-      if (err.status >= 500) return 3;
-      return 0;
-    }
-    return 2;
-  }
-  delayMs(attempt) {
-    const base = 1e3;
-    const exp = base * 2 ** attempt;
-    const jitter = Math.random() * base;
-    return Math.min(3e4, exp + jitter);
-  }
-};
-
-// src/defaults/error-handler.ts
-function buildRecoveryStrategies(opts) {
-  return [
-    {
-      label: "context_overflow_reduce",
-      compactor: opts?.compactor,
-      async attempt(err, ctx) {
-        if (err instanceof ProviderError && (err.status === 413 || /context|too long|tokens/i.test(err.message))) {
-          if (this.compactor) {
-            try {
-              const report = await this.compactor.compact(ctx, { aggressive: true });
-              if (report.after < report.before) {
-                return {
-                  content: [{ type: "text", text: "[context compacted automatically \u2014 please retry]" }],
-                  stopReason: "end_turn",
-                  usage: { input: 0, output: 0 },
-                  model: ctx.model
-                };
-              }
-            } catch {
-            }
-          }
-          return null;
-        }
-        return null;
-      }
-    },
-    {
-      label: "rate_limit_backoff",
-      async attempt(err, ctx) {
-        if (err instanceof ProviderError && err.status === 429) {
-          const delayMs = err.body?.retryAfterMs ?? 5e3;
-          const delay = Math.max(1e3, Math.min(delayMs, 6e4));
-          await new Promise((r) => setTimeout(r, delay));
-          return {
-            content: [{ type: "text", text: "[rate limit backoff applied \u2014 please retry]" }],
-            stopReason: "end_turn",
-            usage: { input: 0, output: 0 },
-            model: ctx.model
-          };
-        }
-        return null;
-      }
-    },
-    {
-      label: "downgrade_model",
-      async attempt(err, ctx) {
-        if (err instanceof ProviderError && (err.status === 429 || err.status === 529 || err.status >= 500)) {
-          return null;
-        }
-        return null;
-      }
-    }
-  ];
-}
-var DEFAULT_RECOVERY_STRATEGIES = buildRecoveryStrategies();
-var DefaultErrorHandler = class {
-  strategies;
-  constructor(strategies = DEFAULT_RECOVERY_STRATEGIES) {
-    this.strategies = strategies;
-  }
-  classify(err) {
-    if (err instanceof DOMException && err.name === "AbortError") {
-      return { kind: "abort", retryable: false };
-    }
-    if (err instanceof Error && err.name === "AbortError") {
-      return { kind: "abort", retryable: false };
-    }
-    if (err instanceof ProviderError) {
-      if (err.status === 429) return { kind: "rate_limit", retryable: true };
-      if (err.status === 529) return { kind: "overloaded", retryable: true };
-      if (err.status >= 500) return { kind: "server", retryable: true };
-      if (err.status === 413 || /context|too long|tokens/i.test(err.message)) {
-        return { kind: "context_overflow", retryable: false };
-      }
-      if (err.status >= 400) return { kind: "client", retryable: false };
-    }
-    if (err instanceof Error && /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i.test(err.message)) {
-      return { kind: "network", retryable: true };
-    }
-    return { kind: "unknown", retryable: false };
-  }
-  async recover(err, ctx) {
-    for (const strategy of this.strategies) {
-      const result = await strategy.attempt(err, ctx);
-      if (result !== null) return result;
-    }
-    return null;
-  }
-};
-
 // src/defaults/token-counter.ts
 var DefaultTokenCounter = class {
   input = 0;
@@ -547,8 +306,11 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     try {
       const fh = await fsp.open(tmp, "r+");
-      await fh.sync();
-      await fh.close();
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
     } catch {
     }
     let mode;
@@ -863,130 +625,7 @@ function userInputTitle(content) {
   const text = content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
   return (text || "(non-text input)").slice(0, 60);
 }
-var LOCK_FILE = "active.json";
-var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
-var RecoveryLock = class {
-  file;
-  pid;
-  hostname;
-  maxAgeMs;
-  sessionStore;
-  probe;
-  constructor(opts) {
-    this.file = path2.join(opts.dir, LOCK_FILE);
-    this.pid = opts.pid ?? process.pid;
-    this.hostname = opts.hostname ?? os.hostname();
-    this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
-    this.sessionStore = opts.sessionStore;
-    this.probe = opts.isPidAlive ?? defaultIsPidAlive;
-  }
-  /**
-   * Examine the lockfile and decide whether it represents an abandoned
-   * session. Returns `null` if the file is missing, points to a live
-   * instance, references a clean-closed session, is too old, or is
-   * malformed. Otherwise returns enough detail to prompt the user.
-   *
-   * Important: this is a read-only check. We never delete an active
-   * lock from here — if another wstack instance is alive, the caller
-   * should bail or run with a fresh session instead.
-   */
-  async checkAbandoned() {
-    const lock = await this.readLock();
-    if (!lock) return null;
-    const ageMs = Date.now() - new Date(lock.startedAt).getTime();
-    if (Number.isNaN(ageMs) || ageMs < 0) {
-      return null;
-    }
-    if (ageMs > this.maxAgeMs) return null;
-    if (lock.hostname === this.hostname && this.probe(lock.pid)) {
-      return null;
-    }
-    let messageCount = 0;
-    if (this.sessionStore) {
-      try {
-        const data = await this.sessionStore.load(lock.sessionId);
-        const closed = data.events.some((e) => e.type === "session_end");
-        if (closed) return null;
-        messageCount = data.messages.length;
-      } catch {
-        return null;
-      }
-    }
-    return {
-      sessionId: lock.sessionId,
-      pid: lock.pid,
-      startedAt: lock.startedAt,
-      ageMs,
-      messageCount
-    };
-  }
-  /**
-   * Claim the lock for the given session. Overwrites any existing lock
-   * — the caller should have already handled abandonment (via
-   * `checkAbandoned`) before calling this.
-   */
-  async write(sessionId) {
-    await ensureDir(path2.dirname(this.file));
-    const lock = {
-      v: 1,
-      sessionId,
-      pid: this.pid,
-      hostname: this.hostname,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const tmp = `${this.file}.tmp`;
-    await fsp.writeFile(tmp, JSON.stringify(lock), { mode: 384 });
-    await fsp.rename(tmp, this.file);
-  }
-  /**
-   * Release the lock. Idempotent — silently succeeds if the file is
-   * already gone (e.g. someone else cleared it, or the directory was
-   * wiped).
-   */
-  async clear() {
-    try {
-      await fsp.unlink(this.file);
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT") return;
-      throw err;
-    }
-  }
-  async readLock() {
-    let raw;
-    try {
-      raw = await fsp.readFile(this.file, "utf8");
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT") return null;
-      return null;
-    }
-    try {
-      const parsed = JSON.parse(raw);
-      if (!isLockFile(parsed)) return null;
-      return parsed;
-    } catch {
-      return null;
-    }
-  }
-};
-function isLockFile(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const o = v;
-  return o["v"] === 1 && typeof o["sessionId"] === "string" && typeof o["pid"] === "number" && typeof o["hostname"] === "string" && typeof o["startedAt"] === "string";
-}
-function defaultIsPidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    if (code === "EPERM") return true;
-    return false;
-  }
-}
-var QueueStore = class {
+var QueueStore = class {
   file;
   constructor(opts) {
     this.file = path2.join(opts.dir, "queue.json");
@@ -1148,92 +787,291 @@ function mergeAdjacentText(blocks) {
   }
   return out;
 }
-
-// src/types/secret-vault.ts
-var ENCRYPTED_PREFIX = "enc:v1:";
-
-// src/defaults/secret-vault.ts
-var KEY_BYTES = 32;
-var IV_BYTES = 12;
-var TAG_BYTES = 16;
-var ALGO = "aes-256-gcm";
-var DefaultSecretVault = class {
-  keyFile;
-  key;
+var MAX_BYTES_TOTAL = 32e3;
+var DefaultMemoryStore = class {
+  files;
   constructor(opts) {
-    this.keyFile = opts.keyFile;
-  }
-  isEncrypted(value) {
-    return typeof value === "string" && value.startsWith(ENCRYPTED_PREFIX);
+    this.files = {
+      "project-agents": opts.paths.inProjectAgentsFile,
+      "project-memory": opts.paths.projectMemory,
+      "user-memory": opts.paths.globalMemory
+    };
   }
-  encrypt(plaintext) {
-    if (this.isEncrypted(plaintext)) return plaintext;
-    const key = this.loadOrCreateKey();
-    const iv = randomBytes(IV_BYTES);
-    const cipher = createCipheriv(ALGO, key, iv);
-    const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-    const tag = cipher.getAuthTag();
-    return `${ENCRYPTED_PREFIX}${iv.toString("base64")}:${tag.toString("base64")}:${ct.toString("base64")}`;
+  async readAll() {
+    const parts = [];
+    for (const scope of ["project-agents", "project-memory", "user-memory"]) {
+      const body = await this.read(scope);
+      if (body.trim()) parts.push(`## ${labelOf(scope)}
+
+${body.trim()}`);
+    }
+    return parts.join("\n\n");
   }
-  decrypt(value) {
-    if (!this.isEncrypted(value)) return value;
-    const rest = value.slice(ENCRYPTED_PREFIX.length);
-    const parts = rest.split(":");
-    if (parts.length !== 3) {
-      throw new Error("SecretVault: malformed encrypted value");
+  async read(scope) {
+    try {
+      return await fsp.readFile(this.files[scope], "utf8");
+    } catch {
+      return "";
     }
-    const [ivB64, tagB64, ctB64] = parts;
-    const iv = Buffer.from(ivB64, "base64");
-    const tag = Buffer.from(tagB64, "base64");
-    const ct = Buffer.from(ctB64, "base64");
-    if (iv.length !== IV_BYTES) throw new Error("SecretVault: bad IV length");
-    if (tag.length !== TAG_BYTES) throw new Error("SecretVault: bad tag length");
-    const key = this.loadOrCreateKey();
-    const decipher = createDecipheriv(ALGO, key, iv);
-    decipher.setAuthTag(tag);
-    const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
-    return pt.toString("utf8");
   }
-  loadOrCreateKey() {
-    if (this.key) return this.key;
+  async remember(text, scope = "project-memory") {
+    const file = this.files[scope];
+    await ensureDir(path2.dirname(file));
+    let existing = "";
     try {
-      const buf = fs4.readFileSync(this.keyFile);
-      if (buf.length !== KEY_BYTES) {
-        throw new Error(`SecretVault: key file ${this.keyFile} has wrong size`);
-      }
-      this.key = buf;
-      return this.key;
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
+      existing = await fsp.readFile(file, "utf8");
+    } catch {
     }
-    fs4.mkdirSync(path2.dirname(this.keyFile), { recursive: true });
-    const key = randomBytes(KEY_BYTES);
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const id = `mem_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    const entry = `
+- [${ts}] ${id} ${text.replace(/\n/g, " ")}
+`;
+    const next = existing.trim() ? existing.replace(/\n+$/, "") + entry : `# WrongStack Memory
+${entry}`;
+    await atomicWrite(file, next);
+    const buf = Buffer.byteLength(next, "utf8");
+    if (buf > MAX_BYTES_TOTAL) {
+      await this.consolidate(scope);
+    }
+  }
+  async forget(query, scope = "project-memory") {
+    const file = this.files[scope];
+    let existing;
     try {
-      fs4.writeFileSync(this.keyFile, key, { mode: 384, flag: "wx" });
-    } catch (err) {
-      if (err.code !== "EEXIST") throw err;
-      const buf = fs4.readFileSync(this.keyFile);
-      if (buf.length !== KEY_BYTES) {
-        throw new Error(`SecretVault: key file ${this.keyFile} has wrong size`);
+      existing = await fsp.readFile(file, "utf8");
+    } catch {
+      return 0;
+    }
+    const needle = query.toLowerCase();
+    const idMatcher = /mem_\d+_\w+/;
+    let removed = 0;
+    const lines = existing.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("- ")) return true;
+      if (idMatcher.test(query)) {
+        const afterBracket = trimmed.indexOf("] ");
+        if (afterBracket !== -1) {
+          const afterTs = trimmed.slice(afterBracket + 2);
+          const entryIdMatch = /^mem_\d+_\w+/.exec(afterTs);
+          if (entryIdMatch && entryIdMatch[0] === query) {
+            removed++;
+            return false;
+          }
+        }
       }
-      this.key = buf;
-      return this.key;
+      if (trimmed.toLowerCase().includes(needle)) {
+        removed++;
+        return false;
+      }
+      return true;
+    });
+    if (removed > 0) {
+      await atomicWrite(file, lines.join("\n"));
     }
-    this.key = key;
-    return key;
+    return removed;
   }
-};
-function decryptConfigSecrets(cfg, vault) {
-  return walk(cfg, vault, (v) => vault.decrypt(v));
-}
-function encryptConfigSecrets(cfg, vault) {
-  return walk(cfg, vault, (v) => vault.encrypt(v));
-}
-function walk(node, vault, transform) {
-  if (node === null || node === void 0) return node;
-  if (typeof node !== "object") return node;
-  if (Array.isArray(node)) {
-    return node.map((item) => walk(item, vault, transform));
+  async consolidate(scope) {
+    const file = this.files[scope];
+    let existing;
+    try {
+      existing = await fsp.readFile(file, "utf8");
+    } catch {
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const lines = existing.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("- ")) return true;
+      const norm = trimmed.replace(/\[[^\]]+\]/, "").replace(/\bmem_\d+_\w+\s*/, "").trim().toLowerCase();
+      if (seen.has(norm)) return false;
+      seen.add(norm);
+      return true;
+    });
+    const next = lines.join("\n");
+    try {
+      await atomicWrite(file, next);
+    } catch {
+      return;
+    }
+    const backup = `${file}.bak.${Date.now()}`;
+    try {
+      await fsp.copyFile(file, backup);
+    } catch {
+    }
+  }
+  async clear(scope) {
+    if (scope) {
+      await atomicWrite(this.files[scope], "");
+    } else {
+      for (const s of ["project-agents", "project-memory", "user-memory"]) {
+        await atomicWrite(this.files[s], "");
+      }
+    }
+  }
+};
+function labelOf(scope) {
+  switch (scope) {
+    case "project-agents":
+      return "Project AGENTS.md";
+    case "project-memory":
+      return "Project memory";
+    case "user-memory":
+      return "User memory";
+  }
+}
+
+// src/defaults/secret-scrubber.ts
+var PATTERNS = [
+  // Anchored at the start where possible so partial matches inside larger
+  // strings don't trigger false positives.
+  { type: "anthropic_key", regex: /(?<![A-Za-z0-9])sk-ant-api\d+-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
+  { type: "openai_key", regex: /(?<![A-Za-z0-9])sk-(?:proj-)?[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
+  { type: "github_pat", regex: /(?<![A-Za-z0-9])ghp_[A-Za-z0-9]{36,}(?![A-Za-z0-9])/g },
+  { type: "github_pat_v2", regex: /(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{50,}(?![A-Za-z0-9])/g },
+  { type: "aws_access_key", regex: /(?<![A-Za-z0-9])AKIA[0-9A-Z]{16}(?![A-Za-z0-9])/g },
+  { type: "gcp_key", regex: /(?<![A-Za-z0-9])AIza[0-9A-Za-z_-]{35}(?![A-Za-z0-9])/g },
+  { type: "slack_token", regex: /(?<![A-Za-z0-9-])xox[abpos]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])/g },
+  { type: "stripe_key", regex: /(?<![A-Za-z0-9])sk_(?:live|test)_[A-Za-z0-9]{24,}(?![A-Za-z0-9])/g },
+  { type: "twilio_sid", regex: /(?<![A-Za-z0-9])AC[a-f0-9]{32}(?![A-Za-z0-9])/g },
+  {
+    type: "jwt",
+    // Anchored: look for literal "eyJ" which is unambiguous for JWT header
+    regex: /(?<![A-Za-z0-9/+=])eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}(?![A-Za-z0-9/+=])/g
+  },
+  {
+    type: "private_key",
+    // Anchored: start must be BEGIN, end must be END with no extra dashes after END
+    regex: /(?:^|\n)-----BEGIN (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----[\s\S]*?-----END[^-]*-----(?:\n|$)/g
+  },
+  { type: "mongodb_uri", regex: /mongodb(?:\+srv)?:\/\/[^\s"'`]+/g },
+  { type: "postgres_uri", regex: /postgres(?:ql)?:\/\/[^\s"'`]+/g },
+  { type: "mysql_uri", regex: /mysql:\/\/[^\s"'`]+/g },
+  { type: "redis_uri", regex: /redis:\/\/[^\s"'`]+/g },
+  { type: "bearer_token", regex: /(?<![A-Za-z0-9_.~+/-])Bearer\s+[A-Za-z0-9._~+/-]{20,}=*(?![A-Za-z0-9_.~+/-])/g },
+  {
+    type: "high_entropy_env",
+    // Value-side word boundary + length gate to avoid matching short random strings
+    regex: /\b([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,})['"]?(?!\s*[A-Za-z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))/g
+  }
+];
+var DefaultSecretScrubber = class {
+  scrub(text) {
+    if (!text) return text;
+    let out = text;
+    for (const p of PATTERNS) {
+      out = out.replace(p.regex, (_match, group1, group2) => {
+        if (p.type === "high_entropy_env" && group1 && group2) {
+          return `${group1}=[REDACTED:${p.type}]`;
+        }
+        return `[REDACTED:${p.type}]`;
+      });
+    }
+    return out;
+  }
+  scrubObject(obj) {
+    const seen = /* @__PURE__ */ new WeakSet();
+    const visit = (v) => {
+      if (typeof v === "string") return this.scrub(v);
+      if (v === null || typeof v !== "object") return v;
+      if (seen.has(v)) return v;
+      seen.add(v);
+      if (Array.isArray(v)) return v.map(visit);
+      const out = {};
+      for (const [k, val] of Object.entries(v)) {
+        out[k] = visit(val);
+      }
+      return out;
+    };
+    return visit(obj);
+  }
+};
+
+// src/types/secret-vault.ts
+var ENCRYPTED_PREFIX = "enc:v1:";
+
+// src/defaults/secret-vault.ts
+var KEY_BYTES = 32;
+var IV_BYTES = 12;
+var TAG_BYTES = 16;
+var ALGO = "aes-256-gcm";
+var DefaultSecretVault = class {
+  keyFile;
+  key;
+  constructor(opts) {
+    this.keyFile = opts.keyFile;
+  }
+  isEncrypted(value) {
+    return typeof value === "string" && value.startsWith(ENCRYPTED_PREFIX);
+  }
+  encrypt(plaintext) {
+    if (this.isEncrypted(plaintext)) return plaintext;
+    const key = this.loadOrCreateKey();
+    const iv = randomBytes(IV_BYTES);
+    const cipher = createCipheriv(ALGO, key, iv);
+    const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return `${ENCRYPTED_PREFIX}${iv.toString("base64")}:${tag.toString("base64")}:${ct.toString("base64")}`;
+  }
+  decrypt(value) {
+    if (!this.isEncrypted(value)) return value;
+    const rest = value.slice(ENCRYPTED_PREFIX.length);
+    const parts = rest.split(":");
+    if (parts.length !== 3) {
+      throw new Error("SecretVault: malformed encrypted value");
+    }
+    const [ivB64, tagB64, ctB64] = parts;
+    const iv = Buffer.from(ivB64, "base64");
+    const tag = Buffer.from(tagB64, "base64");
+    const ct = Buffer.from(ctB64, "base64");
+    if (iv.length !== IV_BYTES) throw new Error("SecretVault: bad IV length");
+    if (tag.length !== TAG_BYTES) throw new Error("SecretVault: bad tag length");
+    const key = this.loadOrCreateKey();
+    const decipher = createDecipheriv(ALGO, key, iv);
+    decipher.setAuthTag(tag);
+    const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+    return pt.toString("utf8");
+  }
+  loadOrCreateKey() {
+    if (this.key) return this.key;
+    try {
+      const buf = fs5.readFileSync(this.keyFile);
+      if (buf.length !== KEY_BYTES) {
+        throw new Error(`SecretVault: key file ${this.keyFile} has wrong size`);
+      }
+      this.key = buf;
+      return this.key;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    fs5.mkdirSync(path2.dirname(this.keyFile), { recursive: true });
+    const key = randomBytes(KEY_BYTES);
+    try {
+      fs5.writeFileSync(this.keyFile, key, { mode: 384, flag: "wx" });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      const buf = fs5.readFileSync(this.keyFile);
+      if (buf.length !== KEY_BYTES) {
+        throw new Error(`SecretVault: key file ${this.keyFile} has wrong size`);
+      }
+      this.key = buf;
+      return this.key;
+    }
+    this.key = key;
+    return key;
+  }
+};
+function decryptConfigSecrets(cfg, vault) {
+  return walk(cfg, vault, (v) => vault.decrypt(v));
+}
+function encryptConfigSecrets(cfg, vault) {
+  return walk(cfg, vault, (v) => vault.encrypt(v));
+}
+function walk(node, vault, transform) {
+  if (node === null || node === void 0) return node;
+  if (typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    return node.map((item) => walk(item, vault, transform));
   }
   const out = {};
   for (const [k, v] of Object.entries(node)) {
@@ -1324,139 +1162,6 @@ function deepMerge(a, b) {
   }
   return out;
 }
-var MAX_BYTES_TOTAL = 32e3;
-var DefaultMemoryStore = class {
-  files;
-  constructor(opts) {
-    this.files = {
-      "project-agents": opts.paths.inProjectAgentsFile,
-      "project-memory": opts.paths.projectMemory,
-      "user-memory": opts.paths.globalMemory
-    };
-  }
-  async readAll() {
-    const parts = [];
-    for (const scope of ["project-agents", "project-memory", "user-memory"]) {
-      const body = await this.read(scope);
-      if (body.trim()) parts.push(`## ${labelOf(scope)}
-
-${body.trim()}`);
-    }
-    return parts.join("\n\n");
-  }
-  async read(scope) {
-    try {
-      return await fsp.readFile(this.files[scope], "utf8");
-    } catch {
-      return "";
-    }
-  }
-  async remember(text, scope = "project-memory") {
-    const file = this.files[scope];
-    await ensureDir(path2.dirname(file));
-    let existing = "";
-    try {
-      existing = await fsp.readFile(file, "utf8");
-    } catch {
-    }
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    const id = `mem_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-    const entry = `
-- [${ts}] ${id} ${text.replace(/\n/g, " ")}
-`;
-    const next = existing.trim() ? existing.replace(/\n+$/, "") + entry : `# WrongStack Memory
-${entry}`;
-    await atomicWrite(file, next);
-    const buf = Buffer.byteLength(next, "utf8");
-    if (buf > MAX_BYTES_TOTAL) {
-      await this.consolidate(scope);
-    }
-  }
-  async forget(query, scope = "project-memory") {
-    const file = this.files[scope];
-    let existing;
-    try {
-      existing = await fsp.readFile(file, "utf8");
-    } catch {
-      return 0;
-    }
-    const needle = query.toLowerCase();
-    const idMatcher = /mem_\d+_\w+/;
-    let removed = 0;
-    const lines = existing.split("\n").filter((line) => {
-      const trimmed = line.trim();
-      if (!trimmed.startsWith("- ")) return true;
-      if (idMatcher.test(query)) {
-        const afterBracket = trimmed.indexOf("] ");
-        if (afterBracket !== -1) {
-          const afterTs = trimmed.slice(afterBracket + 2);
-          const entryIdMatch = /^mem_\d+_\w+/.exec(afterTs);
-          if (entryIdMatch && entryIdMatch[0] === query) {
-            removed++;
-            return false;
-          }
-        }
-      }
-      if (trimmed.toLowerCase().includes(needle)) {
-        removed++;
-        return false;
-      }
-      return true;
-    });
-    if (removed > 0) {
-      await atomicWrite(file, lines.join("\n"));
-    }
-    return removed;
-  }
-  async consolidate(scope) {
-    const file = this.files[scope];
-    let existing;
-    try {
-      existing = await fsp.readFile(file, "utf8");
-    } catch {
-      return;
-    }
-    const seen = /* @__PURE__ */ new Set();
-    const lines = existing.split("\n").filter((line) => {
-      const trimmed = line.trim();
-      if (!trimmed.startsWith("- ")) return true;
-      const norm = trimmed.replace(/\[[^\]]+\]/, "").replace(/\bmem_\d+_\w+\s*/, "").trim().toLowerCase();
-      if (seen.has(norm)) return false;
-      seen.add(norm);
-      return true;
-    });
-    const next = lines.join("\n");
-    try {
-      await atomicWrite(file, next);
-    } catch {
-      return;
-    }
-    const backup = `${file}.bak.${Date.now()}`;
-    try {
-      await fsp.copyFile(file, backup);
-    } catch {
-    }
-  }
-  async clear(scope) {
-    if (scope) {
-      await atomicWrite(this.files[scope], "");
-    } else {
-      for (const s of ["project-agents", "project-memory", "user-memory"]) {
-        await atomicWrite(this.files[s], "");
-      }
-    }
-  }
-};
-function labelOf(scope) {
-  switch (scope) {
-    case "project-agents":
-      return "Project AGENTS.md";
-    case "project-memory":
-      return "Project memory";
-    case "user-memory":
-      return "User memory";
-  }
-}
 
 // src/utils/glob-match.ts
 function escapeRegex(s) {
@@ -1632,118 +1337,363 @@ var DefaultPermissionPolicy = class {
     return void 0;
   }
 };
-var DefaultSkillLoader = class {
-  dirs;
-  cache;
+
+// src/types/errors.ts
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
   constructor(opts) {
-    this.dirs = [
-      { dir: opts.paths.inProjectSkills, source: "project" },
-      { dir: opts.paths.globalSkills, source: "user" }
-    ];
-    if (opts.bundledDir) {
-      this.dirs.push({ dir: opts.bundledDir, source: "bundled" });
-    }
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
   }
-  async list() {
-    if (this.cache) return this.cache;
-    const found = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const { dir, source } of this.dirs) {
-      try {
-        const entries = await fsp.readdir(dir, { withFileTypes: true });
-        for (const e of entries) {
-          if (!e.isDirectory()) continue;
-          const skillFile = path2.join(dir, e.name, "SKILL.md");
-          try {
-            const raw = await fsp.readFile(skillFile, "utf8");
-            const meta = parseFrontmatter(raw);
-            if (!meta.name || !meta.description) continue;
-            if (seen.has(meta.name)) continue;
-            seen.add(meta.name);
-            found.push({
-              name: meta.name,
-              description: meta.description,
-              version: meta.version,
-              path: skillFile,
-              source
-            });
-          } catch {
-          }
-        }
-      } catch {
-      }
-    }
-    this.cache = found;
-    return found;
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
   }
-  async find(name) {
-    const all = await this.list();
-    return all.find((s) => s.name === name);
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var AgentError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "agent",
+      severity: opts.code === "AGENT_ABORTED" ? "warning" : "error",
+      recoverable: opts.recoverable ?? opts.code === "AGENT_ITERATION_LIMIT",
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "AgentError";
   }
-  async manifestText() {
-    const skills = await this.list();
-    if (skills.length === 0) return "";
-    const lines = ["## Available skills"];
-    for (const s of skills) {
-      lines.push(`- **${s.name}** \u2014 ${s.description.replace(/\n/g, " ").trim()}`);
-      lines.push(`  Path: ${s.path}`);
-    }
-    return lines.join("\n");
+};
+function toWrongStackError(err, code = "AGENT_RUN_FAILED") {
+  if (err instanceof WrongStackError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new AgentError({
+    message,
+    code: code === "UNKNOWN" ? "AGENT_RUN_FAILED" : code,
+    cause: err
+  });
+}
+
+// src/types/provider.ts
+var ProviderError = class extends WrongStackError {
+  status;
+  retryable;
+  providerId;
+  body;
+  constructor(message, status, retryable, providerId, opts = {}) {
+    super({
+      message,
+      code: providerStatusToCode(status, opts.body?.type),
+      subsystem: "provider",
+      severity: status >= 500 ? "error" : "warning",
+      recoverable: retryable,
+      context: { providerId, status },
+      cause: opts.cause
+    });
+    this.name = "ProviderError";
+    this.status = status;
+    this.retryable = retryable;
+    this.providerId = providerId;
+    this.body = opts.body;
   }
-  async readBody(name) {
-    const m = await this.find(name);
-    if (!m) throw new Error(`Skill "${name}" not found`);
-    return fsp.readFile(m.path, "utf8");
+  /**
+   * Render a one-line, user-facing description. Designed for the CLI/TUI
+   * status line and the agent's retry warning. Avoids dumping raw JSON
+   * (which is what users see today when a 529 lands and the log message
+   * includes the full `{"type":"error",...}` body).
+   *
+   * Examples:
+   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
+   *   "openai rate limited (429): Retry after 12s"
+   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
+   *   "groq HTTP 500 (server error)"
+   */
+  describe() {
+    const kind = describeStatus(this.status, this.body?.type);
+    const head = `${this.providerId} ${kind}`;
+    const detail = this.body?.message?.trim();
+    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
+    if (detail && detail.length > 0) {
+      return `${head}: ${truncate(detail, 240)}${reqId}`;
+    }
+    return `${head}${reqId}`;
   }
 };
-function parseFrontmatter(raw) {
-  if (!raw.startsWith("---")) return {};
-  const end = raw.indexOf("\n---", 4);
-  if (end === -1) return {};
-  const block = raw.slice(4, end);
-  const out = {};
-  let key = null;
-  let value = [];
-  const flush = () => {
-    if (key) {
-      out[key] = value.join("\n").trim();
+function describeStatus(status, type) {
+  if (status === 0) return "network error";
+  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
+  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
+  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
+  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
+  if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
+  if (status === 408) return `timeout (${status})`;
+  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
+  if (type) return `${type} (${status})`;
+  return `HTTP ${status}`;
+}
+function truncate(s, n) {
+  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
+}
+function providerStatusToCode(status, type) {
+  if (status === 0) return "PROVIDER_NETWORK_ERROR";
+  if (type === "rate_limit_error" || status === 429) return "PROVIDER_RATE_LIMITED";
+  if (type === "authentication_error" || status === 401) return "PROVIDER_AUTH_FAILED";
+  if (type === "overloaded_error" || status === 529) return "PROVIDER_OVERLOADED";
+  if (type === "invalid_request_error" || status === 400) return "PROVIDER_INVALID_REQUEST";
+  if (status === 408) return "PROVIDER_NETWORK_ERROR";
+  if (status >= 500) return "PROVIDER_SERVER_ERROR";
+  return "PROVIDER_INVALID_REQUEST";
+}
+
+// src/defaults/retry-policy.ts
+var DefaultRetryPolicy = class {
+  shouldRetry(err, attempt) {
+    if (err instanceof ProviderError) {
+      if (!err.retryable) return false;
+      return attempt < this.maxAttempts(err);
     }
-    key = null;
-    value = [];
-  };
-  for (const line of block.split("\n")) {
-    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
-    if (m) {
-      flush();
-      key = m[1] ?? "";
-      const pipe = m[2];
-      const rest = m[3] ?? "";
-      if (pipe === "|") {
-        value = [];
-      } else if (rest) {
-        value = [rest];
-      } else {
-        value = [];
-      }
-    } else if (key) {
-      value.push(line.replace(/^\s+/, ""));
+    const msg = err.message ?? "";
+    const isNetwork = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i.test(msg);
+    if (isNetwork) return attempt < 2;
+    return false;
+  }
+  maxAttempts(err) {
+    if (err instanceof ProviderError) {
+      if (err.status === 429) return 5;
+      if (err.status === 529) return 3;
+      if (err.status >= 500) return 3;
+      return 0;
     }
+    return 2;
   }
-  flush();
-  return out;
-}
-var BEHAVIOR_DEFAULTS = {
-  version: 1,
-  context: {
-    warnThreshold: 0.6,
-    softThreshold: 0.75,
-    hardThreshold: 0.9,
-    autoCompact: true,
-    preserveK: 10,
-    eliseThreshold: 2e3
-  },
-  tools: {
-    defaultExecutionStrategy: "smart",
+  delayMs(attempt) {
+    const base = 1e3;
+    const exp = base * 2 ** attempt;
+    const jitter = Math.random() * base;
+    return Math.min(3e4, exp + jitter);
+  }
+};
+
+// src/defaults/error-handler.ts
+function buildRecoveryStrategies(opts) {
+  return [
+    {
+      label: "context_overflow_reduce",
+      compactor: opts?.compactor,
+      async attempt(err, ctx) {
+        if (err instanceof ProviderError && (err.status === 413 || /context|too long|tokens/i.test(err.message))) {
+          if (this.compactor) {
+            try {
+              const report = await this.compactor.compact(ctx, { aggressive: true });
+              if (report.after < report.before) {
+                return {
+                  content: [{ type: "text", text: "[context compacted automatically \u2014 please retry]" }],
+                  stopReason: "end_turn",
+                  usage: { input: 0, output: 0 },
+                  model: ctx.model
+                };
+              }
+            } catch {
+            }
+          }
+          return null;
+        }
+        return null;
+      }
+    },
+    {
+      label: "rate_limit_backoff",
+      async attempt(err, ctx) {
+        if (err instanceof ProviderError && err.status === 429) {
+          const delayMs = err.body?.retryAfterMs ?? 5e3;
+          const delay = Math.max(1e3, Math.min(delayMs, 6e4));
+          await new Promise((r) => setTimeout(r, delay));
+          return {
+            content: [{ type: "text", text: "[rate limit backoff applied \u2014 please retry]" }],
+            stopReason: "end_turn",
+            usage: { input: 0, output: 0 },
+            model: ctx.model
+          };
+        }
+        return null;
+      }
+    },
+    {
+      label: "downgrade_model",
+      async attempt(err, ctx) {
+        if (err instanceof ProviderError && (err.status === 429 || err.status === 529 || err.status >= 500)) {
+          return null;
+        }
+        return null;
+      }
+    }
+  ];
+}
+var DEFAULT_RECOVERY_STRATEGIES = buildRecoveryStrategies();
+var DefaultErrorHandler = class {
+  strategies;
+  constructor(strategies = DEFAULT_RECOVERY_STRATEGIES) {
+    this.strategies = strategies;
+  }
+  classify(err) {
+    if (err instanceof DOMException && err.name === "AbortError") {
+      return { kind: "abort", retryable: false };
+    }
+    if (err instanceof Error && err.name === "AbortError") {
+      return { kind: "abort", retryable: false };
+    }
+    if (err instanceof ProviderError) {
+      if (err.status === 429) return { kind: "rate_limit", retryable: true };
+      if (err.status === 529) return { kind: "overloaded", retryable: true };
+      if (err.status >= 500) return { kind: "server", retryable: true };
+      if (err.status === 413 || /context|too long|tokens/i.test(err.message)) {
+        return { kind: "context_overflow", retryable: false };
+      }
+      if (err.status >= 400) return { kind: "client", retryable: false };
+    }
+    if (err instanceof Error && /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i.test(err.message)) {
+      return { kind: "network", retryable: true };
+    }
+    return { kind: "unknown", retryable: false };
+  }
+  async recover(err, ctx) {
+    for (const strategy of this.strategies) {
+      const result = await strategy.attempt(err, ctx);
+      if (result !== null) return result;
+    }
+    return null;
+  }
+};
+var DefaultSkillLoader = class {
+  dirs;
+  cache;
+  constructor(opts) {
+    this.dirs = [
+      { dir: opts.paths.inProjectSkills, source: "project" },
+      { dir: opts.paths.globalSkills, source: "user" }
+    ];
+    if (opts.bundledDir) {
+      this.dirs.push({ dir: opts.bundledDir, source: "bundled" });
+    }
+  }
+  async list() {
+    if (this.cache) return this.cache;
+    const found = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const { dir, source } of this.dirs) {
+      try {
+        const entries = await fsp.readdir(dir, { withFileTypes: true });
+        for (const e of entries) {
+          if (!e.isDirectory()) continue;
+          const skillFile = path2.join(dir, e.name, "SKILL.md");
+          try {
+            const raw = await fsp.readFile(skillFile, "utf8");
+            const meta = parseFrontmatter(raw);
+            if (!meta.name || !meta.description) continue;
+            if (seen.has(meta.name)) continue;
+            seen.add(meta.name);
+            found.push({
+              name: meta.name,
+              description: meta.description,
+              version: meta.version,
+              path: skillFile,
+              source
+            });
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    this.cache = found;
+    return found;
+  }
+  async find(name) {
+    const all = await this.list();
+    return all.find((s) => s.name === name);
+  }
+  async manifestText() {
+    const skills = await this.list();
+    if (skills.length === 0) return "";
+    const lines = ["## Available skills"];
+    for (const s of skills) {
+      lines.push(`- **${s.name}** \u2014 ${s.description.replace(/\n/g, " ").trim()}`);
+      lines.push(`  Path: ${s.path}`);
+    }
+    return lines.join("\n");
+  }
+  async readBody(name) {
+    const m = await this.find(name);
+    if (!m) throw new Error(`Skill "${name}" not found`);
+    return fsp.readFile(m.path, "utf8");
+  }
+};
+function parseFrontmatter(raw) {
+  if (!raw.startsWith("---")) return {};
+  const end = raw.indexOf("\n---", 4);
+  if (end === -1) return {};
+  const block = raw.slice(4, end);
+  const out = {};
+  let key = null;
+  let value = [];
+  const flush = () => {
+    if (key) {
+      out[key] = value.join("\n").trim();
+    }
+    key = null;
+    value = [];
+  };
+  for (const line of block.split("\n")) {
+    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
+    if (m) {
+      flush();
+      key = m[1] ?? "";
+      const pipe = m[2];
+      const rest = m[3] ?? "";
+      if (pipe === "|") {
+        value = [];
+      } else if (rest) {
+        value = [rest];
+      } else {
+        value = [];
+      }
+    } else if (key) {
+      value.push(line.replace(/^\s+/, ""));
+    }
+  }
+  flush();
+  return out;
+}
+var BEHAVIOR_DEFAULTS = {
+  version: 1,
+  context: {
+    warnThreshold: 0.6,
+    softThreshold: 0.75,
+    hardThreshold: 0.9,
+    autoCompact: true,
+    preserveK: 10,
+    eliseThreshold: 2e3
+  },
+  tools: {
+    defaultExecutionStrategy: "smart",
     maxIterations: 100,
     iterationTimeoutMs: 3e5,
     sessionTimeoutMs: 18e5,
@@ -1849,6 +1799,20 @@ var DefaultConfigLoader = class {
     if (this.vault) {
       cfg = decryptConfigSecrets(cfg, this.vault);
     }
+    if (cfg.providers) {
+      for (const pcfg of Object.values(cfg.providers)) {
+        if (!pcfg || typeof pcfg !== "object") continue;
+        const keys = pcfg.apiKeys;
+        if (!Array.isArray(keys) || keys.length === 0) continue;
+        const existing = pcfg.apiKey;
+        if (existing && existing.length > 0) continue;
+        const activeLabel = pcfg.activeKey;
+        const chosen = activeLabel ? keys.find((k) => k.label === activeLabel) ?? keys[0] : keys[0];
+        if (chosen?.apiKey) {
+          pcfg.apiKey = chosen.apiKey;
+        }
+      }
+    }
     this.validateBehavior(cfg);
     if (this.strict) this.validateIdentity(cfg);
     return Object.freeze(cfg);
@@ -1885,6 +1849,132 @@ var DefaultConfigLoader = class {
   }
 };
 
+// src/defaults/config-store.ts
+var DefaultConfigStore = class {
+  current;
+  watchers = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this.current = deepFreeze(structuredClone(initial));
+  }
+  get() {
+    return this.current;
+  }
+  getSection(key) {
+    return this.current[key];
+  }
+  getExtension(pluginName) {
+    const ext = this.current.extensions?.[pluginName];
+    return ext ? ext : FROZEN_EMPTY;
+  }
+  update(partial) {
+    const next = deepFreeze(
+      structuredClone({ ...this.current, ...partial })
+    );
+    if (next.version !== 1) {
+      throw new Error(`ConfigStore.update: version must remain 1, got ${String(next.version)}`);
+    }
+    const prev = this.current;
+    this.current = next;
+    for (const w of this.watchers) {
+      try {
+        w(next, prev);
+      } catch {
+      }
+    }
+    return next;
+  }
+  watch(cb) {
+    this.watchers.add(cb);
+    return () => this.watchers.delete(cb);
+  }
+};
+var FROZEN_EMPTY = Object.freeze({});
+function deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Object.isFrozen(obj)) return obj;
+  for (const key of Object.keys(obj)) {
+    const v = obj[key];
+    if (v !== null && typeof v === "object" && !Object.isFrozen(v)) {
+      deepFreeze(v);
+    }
+  }
+  return Object.freeze(obj);
+}
+
+// src/defaults/config-migration.ts
+var ConfigMigrationError = class extends Error {
+  fromVersion;
+  targetVersion;
+  missingStep;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "ConfigMigrationError";
+    this.fromVersion = opts.fromVersion;
+    this.targetVersion = opts.targetVersion;
+    this.missingStep = opts.missingStep;
+  }
+};
+function runConfigMigrations(input, targetVersion, migrations) {
+  const initial = typeof input["version"] === "number" ? input["version"] : 1;
+  let current = { ...input };
+  let currentVersion = initial;
+  const applied = [];
+  let shouldPersist = false;
+  let guard = 0;
+  while (currentVersion !== targetVersion) {
+    if (++guard > 100) {
+      throw new ConfigMigrationError({
+        message: `Config migration looped past 100 steps (from v${initial} toward v${targetVersion})`,
+        fromVersion: initial,
+        targetVersion,
+        missingStep: currentVersion
+      });
+    }
+    const step = migrations.find((m) => m.from === currentVersion);
+    if (!step) {
+      throw new ConfigMigrationError({
+        message: `No migration registered from config v${currentVersion} (target v${targetVersion}). Update the framework or revert the config file.`,
+        fromVersion: initial,
+        targetVersion,
+        missingStep: currentVersion
+      });
+    }
+    const ctx = { fromVersion: currentVersion, shouldPersist: false };
+    const next = step.migrate(current, ctx);
+    if (typeof next["version"] !== "number" || next["version"] !== step.to) {
+      next["version"] = step.to;
+    }
+    current = next;
+    currentVersion = step.to;
+    applied.push(`v${step.from}\u2192v${step.to}`);
+    shouldPersist = shouldPersist || ctx.shouldPersist || step.from < step.to;
+  }
+  return { config: current, applied, shouldPersist };
+}
+var DEFAULT_CONFIG_MIGRATIONS = [];
+
+// src/utils/token-estimate.ts
+var RoughTokenEstimate = (text) => Math.max(1, Math.ceil(text.length / 4));
+function estimateToolInputTokens(input) {
+  if (typeof input === "string") return RoughTokenEstimate(input);
+  if (input !== null && typeof input === "object" && "__tokenEstimate" in input) {
+    return input.__tokenEstimate;
+  }
+  const str = typeof input === "object" ? JSON.stringify(input) : String(input);
+  const estimate = RoughTokenEstimate(str);
+  if (input !== null && typeof input === "object" && !Array.isArray(input)) {
+    input.__tokenEstimate = estimate;
+  }
+  return estimate;
+}
+function estimateToolResultTokens(content) {
+  if (typeof content === "string") return RoughTokenEstimate(content);
+  return RoughTokenEstimate(JSON.stringify(content));
+}
+function estimateTextTokens(text) {
+  return RoughTokenEstimate(text);
+}
+
 // src/defaults/compactor.ts
 var HybridCompactor = class {
   preserveK;
@@ -1893,7 +1983,7 @@ var HybridCompactor = class {
   constructor(opts = {}) {
     this.preserveK = opts.preserveK ?? 10;
     this.eliseThreshold = opts.eliseThreshold ?? 2e3;
-    this.estimator = opts.estimator ?? roughTokenEstimate;
+    this.estimator = opts.estimator ?? estimateTextTokens;
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateMessages(ctx.messages);
@@ -1925,8 +2015,7 @@ var HybridCompactor = class {
       if (!msg || !Array.isArray(msg.content)) continue;
       const newContent = msg.content.map((b) => {
         if (b.type !== "tool_result") return b;
-        const text = typeof b.content === "string" ? b.content : JSON.stringify(b.content);
-        const tokens = this.estimator(text);
+        const tokens = estimateToolResultTokens(b.content);
         if (tokens < this.eliseThreshold) return b;
         saved += tokens;
         const elided = {
@@ -1964,23 +2053,20 @@ var HybridCompactor = class {
       },
       { role: "assistant", content: "Continuing from compacted context." }
     ];
-    ctx.messages.splice(0, boundary, ...summary);
+    const tail = ctx.messages.slice(boundary);
+    ctx.state.replaceMessages([...summary, ...tail]);
     return Math.max(0, removedTokens - this.estimateMessages(summary));
   }
   estimateMessages(messages) {
     let total = 0;
     for (const m of messages) {
       if (typeof m.content === "string") {
-        total += this.estimator(m.content);
+        total += estimateTextTokens(m.content);
       } else {
         for (const b of m.content) {
-          if (b.type === "text") total += this.estimator(b.text);
-          else if (b.type === "tool_use") total += this.estimator(JSON.stringify(b.input));
-          else if (b.type === "tool_result") {
-            total += this.estimator(
-              typeof b.content === "string" ? b.content : JSON.stringify(b.content)
-            );
-          }
+          if (b.type === "text") total += estimateTextTokens(b.text);
+          else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
+          else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
         }
       }
     }
@@ -1991,9 +2077,6 @@ function hasTextContent(m) {
   if (typeof m.content === "string") return m.content.trim().length > 0;
   return m.content.some((b) => b.type === "text" && b.text.trim().length > 0);
 }
-function roughTokenEstimate(text) {
-  return Math.max(1, Math.ceil(text.length / 4));
-}
 
 // src/types/blocks.ts
 function isTextBlock(b) {
@@ -2058,7 +2141,8 @@ var IntelligentCompactor = class {
       content: `[prior_turns_summary: ${summaryText}]`
     };
     const summaryTokens = this.estimateTokens([summaryMsg]);
-    ctx.messages.splice(0, boundary, summaryMsg);
+    const tail = ctx.messages.slice(boundary);
+    ctx.state.replaceMessages([summaryMsg, ...tail]);
     return Math.max(0, removedTokens - summaryTokens);
   }
   findSafeBoundary(messages, from, to) {
@@ -2139,8 +2223,7 @@ var IntelligentCompactor = class {
       if (!msg || !Array.isArray(msg.content)) continue;
       const newContent = msg.content.map((b) => {
         if (b.type !== "tool_result") return b;
-        const text = typeof b.content === "string" ? b.content : JSON.stringify(b.content);
-        const tokens = this.roughTokenEstimate(text);
+        const tokens = estimateToolResultTokens(b.content);
         if (tokens < this.eliseThreshold) return b;
         saved += tokens;
         return {
@@ -2162,24 +2245,17 @@ var IntelligentCompactor = class {
     let total = 0;
     for (const m of messages) {
       if (typeof m.content === "string") {
-        total += this.roughTokenEstimate(m.content);
+        total += estimateTextTokens(m.content);
       } else {
         for (const b of m.content) {
-          if (b.type === "text") total += this.roughTokenEstimate(b.text);
-          else if (b.type === "tool_use") total += this.roughTokenEstimate(JSON.stringify(b.input));
-          else if (b.type === "tool_result") {
-            total += this.roughTokenEstimate(
-              typeof b.content === "string" ? b.content : JSON.stringify(b.content)
-            );
-          }
+          if (b.type === "text") total += estimateTextTokens(b.text);
+          else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
+          else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
         }
       }
     }
     return total;
   }
-  roughTokenEstimate(text) {
-    return Math.max(1, Math.ceil(text.length / 4));
-  }
 };
 
 // src/defaults/llm-selector.ts
@@ -2402,8 +2478,8 @@ var SelectiveCompactor = class {
    * insert summaries where the selector provided them.
    */
   async executePlan(ctx, plan) {
-    const messages = ctx.messages;
-    if (messages.length === 0) return;
+    if (ctx.messages.length === 0) return;
+    const messages = [...ctx.messages];
     const sortedCollapsed = [...plan.collapsed].sort((a, b) => b.from - a.from);
     for (const range of sortedCollapsed) {
       if (range.from < 0 || range.to >= messages.length || range.from > range.to) continue;
@@ -2418,6 +2494,7 @@ var SelectiveCompactor = class {
       };
       messages.splice(range.from, range.to - range.from + 1, summaryMsg);
     }
+    ctx.state.replaceMessages(messages);
   }
   async summarizeRange(messages, ctx) {
     const systemText = `${this.summarizerPrompt}
@@ -2464,7 +2541,8 @@ Summarize the following message range:`;
       role: "system",
       content: `[${removed.length} earlier turns trimmed \u2014 see session log for details]`
     };
-    messages.splice(0, boundary, summaryMsg);
+    const tail = messages.slice(boundary);
+    ctx.state.replaceMessages([summaryMsg, ...tail]);
     return Math.max(0, removedTokens - this.estimateTokens([summaryMsg]));
   }
   computeTargetBudget(load, aggressive) {
@@ -2991,44 +3069,128 @@ async function loadUserModes(modesDir) {
   }
   return modes;
 }
+
+// src/defaults/subagent-budget.ts
+var BudgetExceededError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(kind, limit, observed) {
+    super(`Budget exceeded: ${kind} (limit=${limit}, observed=${observed})`);
+    this.name = "BudgetExceededError";
+    this.kind = kind;
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
+var SubagentBudget = class {
+  limits;
+  iterations = 0;
+  toolCalls = 0;
+  tokenInput = 0;
+  tokenOutput = 0;
+  costUsd = 0;
+  startTime = null;
+  constructor(limits = {}) {
+    this.limits = Object.freeze({ ...limits });
+  }
+  start() {
+    this.startTime = Date.now();
+  }
+  recordIteration() {
+    this.iterations++;
+    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
+      throw new BudgetExceededError("iterations", this.limits.maxIterations, this.iterations);
+    }
+  }
+  recordToolCall() {
+    this.toolCalls++;
+    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
+      throw new BudgetExceededError("tool_calls", this.limits.maxToolCalls, this.toolCalls);
+    }
+  }
+  recordUsage(usage, costUsd = 0) {
+    this.tokenInput += usage.input;
+    this.tokenOutput += usage.output;
+    this.costUsd += costUsd;
+    const totalTokens = this.tokenInput + this.tokenOutput;
+    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
+      throw new BudgetExceededError("tokens", this.limits.maxTokens, totalTokens);
+    }
+    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
+      throw new BudgetExceededError("cost", this.limits.maxCostUsd, this.costUsd);
+    }
+  }
+  /**
+   * Throws if the wall-clock budget is exhausted. Call this from the iteration
+   * loop so a hung tool can't keep a subagent running past its deadline.
+   */
+  checkTimeout() {
+    if (this.startTime === null || this.limits.timeoutMs === void 0) return;
+    const elapsed = Date.now() - this.startTime;
+    if (elapsed > this.limits.timeoutMs) {
+      throw new BudgetExceededError("timeout", this.limits.timeoutMs, elapsed);
+    }
+  }
+  /** Returns true if a timeout has occurred without throwing. Useful for races. */
+  isTimedOut() {
+    if (this.startTime === null || this.limits.timeoutMs === void 0) return false;
+    return Date.now() - this.startTime > this.limits.timeoutMs;
+  }
+  usage() {
+    return {
+      iterations: this.iterations,
+      toolCalls: this.toolCalls,
+      tokens: {
+        input: this.tokenInput,
+        output: this.tokenOutput,
+        total: this.tokenInput + this.tokenOutput
+      },
+      costUsd: this.costUsd,
+      elapsedMs: this.startTime === null ? 0 : Date.now() - this.startTime
+    };
+  }
+};
+
+// src/defaults/multi-agent-coordinator.ts
 var DefaultMultiAgentCoordinator = class extends EventEmitter {
   coordinatorId;
   config;
+  runner;
   subagents = /* @__PURE__ */ new Map();
   pendingTasks = [];
   completedResults = [];
   totalIterations = 0;
-  constructor(config) {
+  inFlight = 0;
+  constructor(config, options = {}) {
     super();
     this.coordinatorId = config.coordinatorId;
     this.config = config;
+    this.runner = options.runner;
   }
   async spawn(subagent) {
     const id = subagent.id || randomUUID();
     const context = {
       subagentId: id,
       tasks: [],
+      // parentBridge: wired by the caller via setSubagentBridge() once the
+      // bidirectional bridge is created. Reads gated by hasParentBridge().
       parentBridge: null,
       doneCondition: this.config.doneCondition,
       maxConcurrent: this.config.maxConcurrent ?? 4
     };
     this.subagents.set(id, {
-      config: subagent,
+      config: { ...subagent, id },
       context,
-      status: "idle"
+      status: "idle",
+      abortController: new AbortController()
     });
     this.emit("subagent.started", { subagent: { ...subagent, id } });
-    return {
-      subagentId: id,
-      agentId: id
-    };
+    return { subagentId: id, agentId: id };
   }
   async assign(task) {
     this.pendingTasks.push(task);
-    const available = this.getAvailableSubagent();
-    if (available) {
-      await this.dispatch(available, task);
-    }
+    this.tryDispatchNext();
   }
   async delegate(to, msg) {
     const subagent = this.subagents.get(to);
@@ -3039,8 +3201,8 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     await subagent.context.parentBridge.send(msg);
   }
   /**
-   * Wire up the communication bridge for a subagent. Call this after `spawn()`
-   * once the caller has created the bidirectional bridge connection.
+   * Wire up the communication bridge for a subagent. Call after spawn() once
+   * the caller has created the bidirectional connection.
    */
   setSubagentBridge(subagentId, bridge) {
     const subagent = this.subagents.get(subagentId);
@@ -3050,6 +3212,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   async stop(subagentId) {
     const subagent = this.subagents.get(subagentId);
     if (!subagent) return;
+    subagent.abortController.abort();
     subagent.status = "stopped";
     subagent.currentTask = void 0;
     subagent.context.parentBridge = null;
@@ -3075,71 +3238,234 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       done: this.isDone()
     };
   }
-  getAvailableSubagent() {
+  /** Expose snapshot of completed results — useful for callers awaiting all done. */
+  results() {
+    return this.completedResults;
+  }
+  /**
+   * Manual completion — for callers that drive subagents without a runner
+   * (e.g. external orchestrators). When a runner is configured the coordinator
+   * calls this itself.
+   */
+  completeTask(result) {
+    this.recordCompletion(result);
+  }
+  // --- internal dispatching ---------------------------------------------
+  tryDispatchNext() {
+    while (this.canDispatch()) {
+      const subagentId = this.findIdleSubagent();
+      if (!subagentId) return;
+      const task = this.pendingTasks.shift();
+      if (!task) return;
+      void this.runDispatched(subagentId, task);
+    }
+  }
+  canDispatch() {
+    const max = this.config.maxConcurrent ?? 4;
+    return this.inFlight < max && this.pendingTasks.length > 0;
+  }
+  findIdleSubagent() {
     for (const [id, s] of this.subagents) {
       if (s.status === "idle") return id;
     }
     return null;
   }
-  async dispatch(subagentId, task) {
+  async runDispatched(subagentId, task) {
     const subagent = this.subagents.get(subagentId);
     if (!subagent) return;
     subagent.status = "running";
     subagent.currentTask = task.id;
     task.subagentId = subagentId;
     subagent.context.tasks.push(task);
-    if (!subagent.context.parentBridge) {
-      this.emit("task.assigned", { task, subagentId });
+    this.inFlight++;
+    this.emit("task.assigned", { task, subagentId });
+    const budget = new SubagentBudget({
+      maxIterations: subagent.config.maxIterations ?? this.config.defaultBudget?.maxIterations,
+      maxToolCalls: task.maxToolCalls ?? subagent.config.maxToolCalls ?? this.config.defaultBudget?.maxToolCalls,
+      maxTokens: subagent.config.maxTokens ?? this.config.defaultBudget?.maxTokens,
+      maxCostUsd: subagent.config.maxCostUsd ?? this.config.defaultBudget?.maxCostUsd,
+      timeoutMs: task.timeoutMs ?? subagent.config.timeoutMs ?? this.config.defaultBudget?.timeoutMs
+    });
+    subagent.activeBudget = budget;
+    const startTime = Date.now();
+    const runCtx = {
+      subagentId,
+      config: subagent.config,
+      budget,
+      signal: subagent.abortController.signal,
+      bridge: subagent.context.parentBridge || null
+    };
+    let result;
+    if (!this.runner) {
       return;
     }
-    await subagent.context.parentBridge.send({
-      id: randomUUID(),
-      type: "task",
-      from: this.coordinatorId,
-      to: subagentId,
-      payload: task,
-      timestamp: Date.now()
-    });
-    this.emit("task.assigned", { task, subagentId });
-  }
-  isDone() {
-    if (this.config.doneCondition.type === "all_tasks_done") {
-      return this.pendingTasks.length === 0 && this.completedResults.every((r) => r.status === "success");
+    budget.start();
+    try {
+      const outcome = await this.executeWithTimeout(this.runner, task, runCtx, budget);
+      result = {
+        subagentId,
+        taskId: task.id,
+        status: "success",
+        result: outcome.result,
+        iterations: outcome.iterations,
+        toolCalls: outcome.toolCalls,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      const status = err instanceof BudgetExceededError && err.kind === "timeout" ? "timeout" : subagent.abortController.signal.aborted ? "stopped" : "failed";
+      result = {
+        subagentId,
+        taskId: task.id,
+        status,
+        error: err instanceof Error ? err.message : String(err),
+        iterations: budget.usage().iterations,
+        toolCalls: budget.usage().toolCalls,
+        durationMs: Date.now() - startTime
+      };
     }
-    if (this.config.doneCondition.maxIterations && this.totalIterations >= this.config.doneCondition.maxIterations) {
-      return true;
+    this.recordCompletion(result);
+  }
+  async executeWithTimeout(runner, task, ctx, budget) {
+    const timeoutMs = budget.limits.timeoutMs;
+    if (timeoutMs === void 0) return runner(task, ctx);
+    let timer = null;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        this.subagents.get(ctx.subagentId)?.abortController.abort();
+        reject(new BudgetExceededError("timeout", timeoutMs, Date.now()));
+      }, timeoutMs);
+    });
+    try {
+      return await Promise.race([runner(task, ctx), timeoutPromise]);
+    } finally {
+      if (timer) clearTimeout(timer);
     }
-    return false;
   }
-  completeTask(result) {
+  recordCompletion(result) {
     this.completedResults.push(result);
     this.totalIterations += result.iterations;
+    this.inFlight = Math.max(0, this.inFlight - 1);
     const subagent = this.subagents.get(result.subagentId);
-    if (subagent) {
-      subagent.status = "idle";
+    if (subagent && subagent.status !== "stopped") {
+      subagent.status = result.status === "failed" || result.status === "timeout" ? "error" : "idle";
       subagent.currentTask = void 0;
+      if (subagent.status === "error") {
+        queueMicrotask(() => {
+          if (subagent.status === "error") subagent.status = "idle";
+          this.tryDispatchNext();
+        });
+      }
     }
     this.emit("task.completed", {
-      task: this.pendingTasks.shift(),
+      task: subagent?.context.tasks.find((t) => t.id === result.taskId) ?? { id: result.taskId },
       result
     });
-    if (this.pendingTasks.length > 0) {
-      const available = this.getAvailableSubagent();
-      if (available) {
-        const nextTask = this.pendingTasks.shift();
-        this.dispatch(available, nextTask);
-      }
-    } else if (this.isDone()) {
+    this.tryDispatchNext();
+    if (this.isDone()) {
       this.emit("done", {
         results: this.completedResults,
         totalIterations: this.totalIterations
       });
     }
   }
+  isDone() {
+    if (this.config.doneCondition.type === "all_tasks_done") {
+      return this.pendingTasks.length === 0 && this.inFlight === 0;
+    }
+    if (this.config.doneCondition.maxIterations !== void 0 && this.totalIterations >= this.config.doneCondition.maxIterations) {
+      return true;
+    }
+    return false;
+  }
 };
+
+// src/defaults/agent-subagent-runner.ts
+function makeAgentSubagentRunner(opts) {
+  const format = opts.formatTaskInput ?? defaultFormatTaskInput;
+  return async (task, ctx) => {
+    const { agent, events } = await opts.factory(ctx.config);
+    const aborter = new AbortController();
+    const onBudgetError = (err) => {
+      if (err instanceof BudgetExceededError) {
+        aborter.abort();
+        budgetError = err;
+      } else {
+        throw err;
+      }
+    };
+    let budgetError = null;
+    const unsub = [];
+    unsub.push(
+      events.on("tool.started", () => {
+        try {
+          ctx.budget.recordToolCall();
+        } catch (e) {
+          onBudgetError(e);
+        }
+      }),
+      events.on("provider.response", (e) => {
+        try {
+          ctx.budget.recordUsage(e.usage);
+        } catch (e2) {
+          onBudgetError(e2);
+        }
+      }),
+      events.on("iteration.started", () => {
+        try {
+          ctx.budget.recordIteration();
+          ctx.budget.checkTimeout();
+        } catch (e) {
+          onBudgetError(e);
+        }
+      })
+    );
+    const onParentAbort = () => aborter.abort();
+    ctx.signal.addEventListener("abort", onParentAbort);
+    let result;
+    try {
+      result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
+    } finally {
+      ctx.signal.removeEventListener("abort", onParentAbort);
+      for (const u of unsub) u();
+    }
+    if (budgetError) throw budgetError;
+    if (result.status === "failed") {
+      throw result.error instanceof Error ? result.error : new Error(String(result.error ?? "agent failed"));
+    }
+    if (result.status === "aborted") {
+      throw new Error("agent aborted");
+    }
+    if (result.status === "max_iterations") {
+      throw new Error("agent exhausted iteration limit");
+    }
+    const usage = ctx.budget.usage();
+    return {
+      result: result.finalText,
+      iterations: result.iterations,
+      toolCalls: usage.toolCalls
+    };
+  };
+}
+function defaultFormatTaskInput(task) {
+  return task.description ?? "";
+}
+
+// src/defaults/transport/in-memory-transport.ts
 var InMemoryBridgeTransport = class {
   subs = /* @__PURE__ */ new Map();
   send(msg, to) {
+    if (to === "*") {
+      for (const [id, handlers2] of this.subs) {
+        if (id === msg.from) continue;
+        for (const h of handlers2) {
+          try {
+            h(msg);
+          } catch {
+          }
+        }
+      }
+      return Promise.resolve();
+    }
     const handlers = this.subs.get(to);
     if (handlers) {
       for (const h of handlers) {
@@ -3161,6 +3487,8 @@ var InMemoryBridgeTransport = class {
     return Promise.resolve();
   }
 };
+
+// src/defaults/agent-bridge.ts
 var InMemoryAgentBridge = class {
   agentId;
   coordinatorId;
@@ -3327,7 +3655,7 @@ var AutonomousRunner = class {
         if (e.message.includes("timeout")) {
           const timeoutResult = {
             status: "failed",
-            error: e,
+            error: toWrongStackError(e),
             iterations: this.iterations,
             toolCalls: this.toolCalls,
             reason: "iteration timeout"
@@ -4133,251 +4461,1354 @@ var TaskFlow = class {
     });
   }
 };
-var SpecDrivenDev = class {
-  store;
-  tracker;
-  events;
-  flows = /* @__PURE__ */ new Map();
-  constructor(opts) {
-    this.store = new DefaultTaskStore();
-    this.tracker = new TaskTracker({ store: this.store });
-    this.events = opts.events;
+var SpecDrivenDev = class {
+  store;
+  tracker;
+  events;
+  flows = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.store = new DefaultTaskStore();
+    this.tracker = new TaskTracker({ store: this.store });
+    this.events = opts.events;
+  }
+  async createFlow(specContent, options) {
+    const flow = new TaskFlow({
+      tracker: this.tracker,
+      events: this.events,
+      ...options
+    });
+    const graph = await flow.fromSpec(specContent);
+    this.flows.set(graph.id, flow);
+    return flow;
+  }
+  getTracker() {
+    return this.tracker;
+  }
+  getFlow(graphId) {
+    return this.flows.get(graphId);
+  }
+  listFlows() {
+    return Array.from(this.flows.entries()).map(([id, flow]) => ({
+      id,
+      title: flow.getGraph()?.title ?? "Untitled",
+      phase: flow.getPhase()
+    }));
+  }
+};
+var LOCK_FILE = "active.json";
+var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var RecoveryLock = class {
+  file;
+  pid;
+  hostname;
+  maxAgeMs;
+  sessionStore;
+  probe;
+  constructor(opts) {
+    this.file = path2.join(opts.dir, LOCK_FILE);
+    this.pid = opts.pid ?? process.pid;
+    this.hostname = opts.hostname ?? os.hostname();
+    this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+    this.sessionStore = opts.sessionStore;
+    this.probe = opts.isPidAlive ?? defaultIsPidAlive;
+  }
+  /**
+   * Examine the lockfile and decide whether it represents an abandoned
+   * session. Returns `null` if the file is missing, points to a live
+   * instance, references a clean-closed session, is too old, or is
+   * malformed. Otherwise returns enough detail to prompt the user.
+   *
+   * Important: this is a read-only check. We never delete an active
+   * lock from here — if another wstack instance is alive, the caller
+   * should bail or run with a fresh session instead.
+   */
+  async checkAbandoned() {
+    const lock = await this.readLock();
+    if (!lock) return null;
+    const ageMs = Date.now() - new Date(lock.startedAt).getTime();
+    if (Number.isNaN(ageMs) || ageMs < 0) {
+      return null;
+    }
+    if (ageMs > this.maxAgeMs) return null;
+    if (lock.hostname === this.hostname && this.probe(lock.pid)) {
+      return null;
+    }
+    let messageCount = 0;
+    if (this.sessionStore) {
+      try {
+        const data = await this.sessionStore.load(lock.sessionId);
+        const closed = data.events.some((e) => e.type === "session_end");
+        if (closed) return null;
+        messageCount = data.messages.length;
+      } catch {
+        return null;
+      }
+    }
+    return {
+      sessionId: lock.sessionId,
+      pid: lock.pid,
+      startedAt: lock.startedAt,
+      ageMs,
+      messageCount
+    };
+  }
+  /**
+   * Claim the lock for the given session. Overwrites any existing lock
+   * — the caller should have already handled abandonment (via
+   * `checkAbandoned`) before calling this.
+   */
+  async write(sessionId) {
+    await ensureDir(path2.dirname(this.file));
+    const lock = {
+      v: 1,
+      sessionId,
+      pid: this.pid,
+      hostname: this.hostname,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const tmp = `${this.file}.tmp`;
+    await fsp.writeFile(tmp, JSON.stringify(lock), { mode: 384 });
+    await fsp.rename(tmp, this.file);
+  }
+  /**
+   * Release the lock. Idempotent — silently succeeds if the file is
+   * already gone (e.g. someone else cleared it, or the directory was
+   * wiped).
+   */
+  async clear() {
+    try {
+      await fsp.unlink(this.file);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return;
+      throw err;
+    }
+  }
+  async readLock() {
+    let raw;
+    try {
+      raw = await fsp.readFile(this.file, "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return null;
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (!isLockFile(parsed)) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+};
+function isLockFile(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  return o["v"] === 1 && typeof o["sessionId"] === "string" && typeof o["pid"] === "number" && typeof o["hostname"] === "string" && typeof o["startedAt"] === "string";
+}
+function defaultIsPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+
+// src/utils/tool-output-serializer.ts
+function createToolOutputSerializer(opts = {}) {
+  const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
+  function serialize(value) {
+    if (typeof value === "string") return value;
+    if (value === null || value === void 0) return "";
+    if (typeof value === "object") {
+      if (Array.isArray(value)) return value.map(serialize).join("\n");
+      if ("text" in value) {
+        const t = value.text;
+        return typeof t === "string" ? t : JSON.stringify(value, null, 2);
+      }
+      try {
+        return JSON.stringify(value, null, 2);
+      } catch {
+        return String(value);
+      }
+    }
+    return String(value);
+  }
+  function enforceCap(text, remainingBudget) {
+    if (remainingBudget <= 0) {
+      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    }
+    const textBytes = Buffer.byteLength(text, "utf8");
+    if (textBytes <= remainingBudget) {
+      return { text, newBudget: remainingBudget - textBytes };
+    }
+    const marker = `
+\u2026[truncated ${textBytes - remainingBudget} bytes]\u2026
+`;
+    const markerBytes = Buffer.byteLength(marker, "utf8");
+    const available = remainingBudget - markerBytes;
+    if (available <= 0) {
+      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    }
+    const half = Math.floor(available / 2);
+    const first = text.slice(0, half);
+    Buffer.byteLength(first, "utf8");
+    const second = text.slice(text.length - half);
+    return { text: `${first}${marker}${second}`, newBudget: 0 };
+  }
+  return { serialize, enforceCap, capBytes };
+}
+
+// src/defaults/tool-executor.ts
+var ToolExecutor = class {
+  constructor(registry, opts) {
+    this.registry = registry;
+    this.opts = opts;
+    this.iterationTimeoutMs = opts.iterationTimeoutMs ?? 3e5;
+    this.serializer = createToolOutputSerializer({
+      perIterationOutputCapBytes: opts.perIterationOutputCapBytes ?? 1e5
+    });
+  }
+  registry;
+  opts;
+  serializer;
+  iterationTimeoutMs;
+  /**
+   * Execute a batch of tool uses using the configured strategy.
+   * Returns the execution results and the remaining output budget.
+   */
+  async executeBatch(toolUses, ctx, strategy) {
+    let budget = this.opts.perIterationOutputCapBytes ?? 1e5;
+    const runOne = async (use) => {
+      const start = Date.now();
+      const tool = this.registry.get(use.name);
+      if (!tool) {
+        const result = this.unknownToolResult(use, () => this.registry.list().map((t) => t.name));
+        budget = this.decrementBudget(result, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
+      const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
+      if (decision.permission === "deny") {
+        const result = this.deniedResult(use, decision.reason);
+        budget = this.decrementBudget(result, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
+      if (decision.permission === "confirm") {
+        if (this.opts.confirmAwaiter) {
+          const choice = await this.opts.confirmAwaiter(tool, use.input, use.id, tool.name);
+          if (choice !== "yes" && choice !== "always") {
+            const result = { type: "tool_result", tool_use_id: use.id, content: `Tool "${tool.name}" denied by user.`, is_error: true };
+            budget = this.decrementBudget(result, budget);
+            return { result, tool, durationMs: Date.now() - start };
+          }
+        } else {
+          const suggestedPattern = this.subjectFor(tool.name, use.input) ?? tool.name;
+          const pending = { type: "tool_confirm_pending", toolUseId: use.id, toolName: tool.name, input: use.input, suggestedPattern };
+          return { result: pending, tool, durationMs: Date.now() - start };
+        }
+      }
+      const span = this.opts.tracer?.startSpan(`tool.${tool.name}`, {
+        "tool.name": tool.name,
+        "tool.mutating": tool.mutating,
+        "tool.permission": tool.permission
+      });
+      try {
+        const result = await this.executeTool(tool, use, ctx, budget);
+        budget = this.decrementBudget(result, budget);
+        span?.setAttribute("tool.is_error", !!result.is_error);
+        span?.setAttribute(
+          "tool.output_bytes",
+          typeof result.content === "string" ? result.content.length : 0
+        );
+        return { result, tool, durationMs: Date.now() - start };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const scrubbed = this.opts.secretScrubber.scrub(msg);
+        this.opts.renderer?.writeToolResult(tool.name, scrubbed, true);
+        const result = { type: "tool_result", tool_use_id: use.id, content: `Tool "${tool.name}" threw: ${scrubbed}`, is_error: true };
+        budget = this.decrementBudget(result, budget);
+        if (err instanceof Error) span?.recordError(err);
+        span?.setAttribute("tool.is_error", true);
+        return { result, tool, durationMs: Date.now() - start };
+      } finally {
+        span?.end();
+      }
+    };
+    if (strategy === "sequential") {
+      const outputs = [];
+      for (const use of toolUses) {
+        if (use) outputs.push(await runOne(use));
+      }
+      return { outputs, remainingBudget: budget };
+    }
+    if (strategy === "parallel") {
+      const outputs = await Promise.all(toolUses.map((use) => runOne(use)));
+      return { outputs, remainingBudget: budget };
+    }
+    const nonMutating = [];
+    const mutating = [];
+    for (const use of toolUses) {
+      if (!use) continue;
+      const tool = this.registry.get(use.name);
+      if (tool?.mutating) mutating.push(use);
+      else nonMutating.push(use);
+    }
+    const firstPass = await Promise.all(nonMutating.map((use) => runOne(use)));
+    const secondPass = [];
+    for (const use of mutating) {
+      secondPass.push(await runOne(use));
+    }
+    return {
+      outputs: [...firstPass, ...secondPass],
+      remainingBudget: budget
+    };
+  }
+  /**
+   * Execute a single tool with timeout, permission check, and output capping.
+   * Emits `tool.started` via the injected EventBus (if any) right before
+   * invoking the tool — closes the observability gap between "model decided
+   * to call a tool" and "tool.executed".
+   */
+  async executeTool(tool, use, ctx, budget) {
+    this.opts.events?.emit("tool.started", {
+      name: tool.name,
+      id: use.id,
+      input: use.input
+    });
+    this.opts.renderer?.writeToolCall(tool.name, use.input);
+    const output = await this.runWithTimeout(tool, use.input, ctx.signal, ctx, use.id);
+    const text = this.serializer.serialize(output);
+    const scrubbed = this.opts.secretScrubber.scrub(text);
+    const { text: capped } = this.serializer.enforceCap(scrubbed, budget);
+    this.opts.renderer?.writeToolResult(tool.name, capped, false);
+    return {
+      type: "tool_result",
+      tool_use_id: use.id,
+      name: tool.name,
+      content: capped,
+      is_error: false
+    };
+  }
+  async runWithTimeout(tool, input, parentSignal, ctx, toolUseId) {
+    if (parentSignal.aborted) {
+      throw parentSignal.reason instanceof Error ? parentSignal.reason : new Error(typeof parentSignal.reason === "string" ? parentSignal.reason : "aborted");
+    }
+    const timeoutMs = tool.timeoutMs ?? this.iterationTimeoutMs;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
+    const combined = AbortSignal.any([parentSignal, ctrl.signal]);
+    try {
+      if (typeof tool.executeStream === "function") {
+        return await this.runStreamedTool(tool, input, ctx, combined, toolUseId);
+      }
+      return await tool.execute(input, ctx, { signal: combined });
+    } catch (err) {
+      if (combined.aborted && typeof tool.cleanup === "function") {
+        try {
+          await tool.cleanup(input, ctx);
+        } catch {
+        }
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async runStreamedTool(tool, input, ctx, signal, toolUseId) {
+    let finalOutput;
+    let sawFinal = false;
+    const stream = tool.executeStream(input, ctx, { signal });
+    for await (const ev of stream) {
+      if (ev.type === "final") {
+        finalOutput = ev.output;
+        sawFinal = true;
+        break;
+      }
+      this.opts.events?.emit("tool.progress", {
+        name: tool.name,
+        id: toolUseId ?? "<unknown>",
+        event: ev
+      });
+    }
+    if (!sawFinal) {
+      throw new Error(`tool "${tool.name}" executeStream completed without a 'final' event`);
+    }
+    return finalOutput;
+  }
+  unknownToolResult(use, listFns) {
+    return {
+      type: "tool_result",
+      tool_use_id: use.id,
+      content: `Tool "${use.name}" is not registered. Available tools: ${listFns().join(", ")}`,
+      is_error: true
+    };
+  }
+  deniedResult(use, reason) {
+    return {
+      type: "tool_result",
+      tool_use_id: use.id,
+      content: `Tool "${use.name}" denied: ${reason ?? "policy"}`,
+      is_error: true
+    };
+  }
+  decrementBudget(result, budget) {
+    const contentBytes = typeof result.content === "string" ? Buffer.byteLength(result.content, "utf8") : Buffer.byteLength(JSON.stringify(result.content), "utf8");
+    return Math.max(0, budget - contentBytes);
+  }
+  /**
+   * Compute the suggestedPattern string for a tool+input pair.
+   * Matches the logic in DefaultPermissionPolicy so the TUI shows the
+   * same subject that the trust file would use.
+   */
+  subjectFor(toolName, input) {
+    if (!input || typeof input !== "object") return void 0;
+    const obj = input;
+    const globChars = /[*?\[\]]/g;
+    const escapeGlob = (s) => s.replace(globChars, (c) => `\\${c}`);
+    if (toolName === "bash" && typeof obj.command === "string") {
+      return escapeGlob(obj.command);
+    }
+    if (typeof obj.path === "string") {
+      return escapeGlob(obj.path.replace(/\\/g, "/"));
+    }
+    if (typeof obj.url === "string") {
+      return escapeGlob(obj.url);
+    }
+    if (typeof obj.name === "string") {
+      return escapeGlob(obj.name);
+    }
+    return void 0;
+  }
+};
+
+// src/defaults/session-reader.ts
+var DefaultSessionReader = class {
+  store;
+  constructor(opts) {
+    this.store = opts.store;
+  }
+  async query(q = {}) {
+    const raw = await this.store.list(q.limit ? Math.max(q.limit * 4, 100) : 1e3);
+    const titleNeedle = q.titleContains?.toLowerCase();
+    const filtered = raw.filter((s) => {
+      if (q.since && s.startedAt < q.since) return false;
+      if (q.until && s.startedAt > q.until) return false;
+      if (q.provider && s.provider !== q.provider) return false;
+      if (q.model && s.model !== q.model) return false;
+      if (q.minTokens !== void 0 && s.tokenTotal < q.minTokens) return false;
+      if (titleNeedle && !s.title.toLowerCase().includes(titleNeedle)) return false;
+      return true;
+    });
+    const out = filtered.map((s) => ({
+      id: s.id,
+      title: s.title,
+      startedAt: s.startedAt,
+      provider: s.provider,
+      model: s.model,
+      tokenTotal: s.tokenTotal
+    }));
+    return q.limit ? out.slice(0, q.limit) : out;
+  }
+  async *replay(sessionId) {
+    const data = await this.store.load(sessionId);
+    for (const e of data.events) yield e;
+  }
+  async search(q, sessionId) {
+    const limit = q.limit ?? 100;
+    const matcher = buildMatcher(q);
+    const allowedTypes = q.types ? new Set(q.types) : null;
+    const ids = sessionId ? [sessionId] : (await this.store.list(1e3)).map((s) => s.id);
+    const hits = [];
+    for (const id of ids) {
+      let data;
+      try {
+        data = await this.store.load(id);
+      } catch {
+        continue;
+      }
+      for (let i = 0; i < data.events.length; i++) {
+        const ev = data.events[i];
+        if (allowedTypes && !allowedTypes.has(ev.type)) continue;
+        const text = eventText(ev);
+        if (text === null) continue;
+        const hit = matcher(text);
+        if (!hit) continue;
+        hits.push({
+          sessionId: id,
+          eventIndex: i,
+          ts: ev.ts,
+          type: ev.type,
+          snippet: snippetOf(text, hit.start, hit.end)
+        });
+        if (hits.length >= limit) return hits;
+      }
+    }
+    return hits;
+  }
+  async export(sessionId, opts) {
+    const data = await this.store.load(sessionId);
+    const includeTools = opts.includeTools ?? true;
+    const includeDiagnostics = opts.includeDiagnostics ?? true;
+    const filtered = data.events.filter((e) => {
+      if (!includeTools && (e.type === "tool_use" || e.type === "tool_result" || e.type === "tool_call_start" || e.type === "tool_call_end")) {
+        return false;
+      }
+      if (!includeDiagnostics && (e.type === "error" || e.type === "compaction" || e.type === "message_truncated")) {
+        return false;
+      }
+      return true;
+    });
+    if (opts.format === "json") {
+      return JSON.stringify({ metadata: data.metadata, events: filtered }, null, 2);
+    }
+    if (opts.format === "text") {
+      return renderPlainText(data.metadata, filtered);
+    }
+    return renderMarkdown(data.metadata, filtered);
+  }
+  async metadata(sessionId) {
+    const data = await this.store.load(sessionId);
+    return data.metadata;
+  }
+};
+function buildMatcher(q) {
+  const ci = q.caseInsensitive ?? true;
+  if (q.regex) {
+    const flags = ci ? "i" : "";
+    const re = new RegExp(q.query, flags);
+    return (text) => {
+      const m = re.exec(text);
+      return m ? { start: m.index, end: m.index + m[0].length } : null;
+    };
+  }
+  const needle = ci ? q.query.toLowerCase() : q.query;
+  return (text) => {
+    const hay = ci ? text.toLowerCase() : text;
+    const idx = hay.indexOf(needle);
+    return idx === -1 ? null : { start: idx, end: idx + needle.length };
+  };
+}
+function eventText(e) {
+  switch (e.type) {
+    case "user_input":
+      return contentToString(e.content);
+    case "llm_response":
+      return contentToString(e.content);
+    case "tool_use":
+      return `${e.name} ${JSON.stringify(e.input)}`;
+    case "tool_result":
+      return typeof e.content === "string" ? e.content : JSON.stringify(e.content);
+    case "error":
+      return `${e.phase}: ${e.message}`;
+    case "session_start":
+    case "session_resumed":
+      return `${e.model}/${e.provider}`;
+    case "task_created":
+    case "task_completed":
+      return e.title;
+    case "task_failed":
+      return `${e.title}: ${e.error}`;
+    case "skill_activated":
+    case "skill_deactivated":
+      return e.skillName;
+    default:
+      return null;
+  }
+}
+function contentToString(content) {
+  if (typeof content === "string") return content;
+  return content.map((b) => {
+    switch (b.type) {
+      case "text":
+        return b.text;
+      case "tool_use":
+        return `[tool_use:${b.name} ${JSON.stringify(b.input)}]`;
+      case "tool_result":
+        return typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+      default:
+        return "";
+    }
+  }).join("\n");
+}
+var SNIPPET_RADIUS = 60;
+function snippetOf(text, start, end) {
+  const from = Math.max(0, start - SNIPPET_RADIUS);
+  const to = Math.min(text.length, end + SNIPPET_RADIUS);
+  const prefix = from > 0 ? "\u2026" : "";
+  const suffix = to < text.length ? "\u2026" : "";
+  return prefix + text.slice(from, to).replace(/\s+/g, " ").trim() + suffix;
+}
+function renderMarkdown(meta, events) {
+  const lines = [];
+  lines.push(`# Session ${meta.id}`);
+  lines.push("");
+  if (meta.model || meta.provider) {
+    lines.push(`- **Model:** ${meta.provider ?? "?"}/${meta.model ?? "?"}`);
+  }
+  lines.push(`- **Started:** ${meta.startedAt}`);
+  if (meta.endedAt) lines.push(`- **Ended:** ${meta.endedAt}`);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (const e of events) {
+    switch (e.type) {
+      case "user_input": {
+        lines.push(`## User \u2014 ${e.ts}`);
+        lines.push("");
+        lines.push(contentToString(e.content));
+        lines.push("");
+        break;
+      }
+      case "llm_response": {
+        lines.push(`## Assistant \u2014 ${e.ts}`);
+        lines.push("");
+        lines.push(contentToString(e.content));
+        if (e.stopReason && e.stopReason !== "end_turn") {
+          lines.push("");
+          lines.push(`*stop: ${e.stopReason}*`);
+        }
+        lines.push("");
+        break;
+      }
+      case "tool_use": {
+        lines.push(`### Tool call: \`${e.name}\``);
+        lines.push("");
+        lines.push("```json");
+        lines.push(JSON.stringify(e.input, null, 2));
+        lines.push("```");
+        lines.push("");
+        break;
+      }
+      case "tool_result": {
+        const body = typeof e.content === "string" ? e.content : JSON.stringify(e.content, null, 2);
+        lines.push(`### Tool result${e.isError ? " (error)" : ""}`);
+        lines.push("");
+        lines.push("```");
+        lines.push(body);
+        lines.push("```");
+        lines.push("");
+        break;
+      }
+      case "error": {
+        lines.push(`> **Error** (${e.phase}): ${e.message}`);
+        lines.push("");
+        break;
+      }
+      case "compaction": {
+        lines.push(`> **Compaction**: ${e.before} \u2192 ${e.after} tokens`);
+        lines.push("");
+        break;
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderPlainText(meta, events) {
+  const lines = [];
+  lines.push(`Session ${meta.id} \u2014 ${meta.provider ?? "?"}/${meta.model ?? "?"} \u2014 started ${meta.startedAt}`);
+  lines.push("".padEnd(72, "-"));
+  for (const e of events) {
+    switch (e.type) {
+      case "user_input":
+        lines.push(`[${e.ts}] USER`);
+        lines.push(contentToString(e.content));
+        lines.push("");
+        break;
+      case "llm_response":
+        lines.push(`[${e.ts}] ASSISTANT`);
+        lines.push(contentToString(e.content));
+        lines.push("");
+        break;
+      case "tool_use":
+        lines.push(`[${e.ts}] TOOL_USE ${e.name} ${JSON.stringify(e.input)}`);
+        break;
+      case "tool_result":
+        lines.push(
+          `[${e.ts}] TOOL_RESULT${e.isError ? " (error)" : ""} ${typeof e.content === "string" ? e.content : JSON.stringify(e.content)}`
+        );
+        break;
+      case "error":
+        lines.push(`[${e.ts}] ERROR (${e.phase}): ${e.message}`);
+        break;
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/defaults/observability/metrics.ts
+var RESERVOIR_SIZE = 1024;
+function labelKey(labels) {
+  if (!labels) return "";
+  const keys = Object.keys(labels).sort();
+  return keys.map((k) => `${k}=${labels[k]}`).join(",");
+}
+function quantile(sorted, q) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.floor(q * sorted.length));
+  return sorted[idx] ?? 0;
+}
+var InMemoryMetricsSink = class {
+  counters = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  counter(name, value = 1, labels) {
+    const series = this.getOrCreate(this.counters, name);
+    const key = labelKey(labels);
+    const state = series.get(key) ?? { value: 0 };
+    state.value += value;
+    series.set(key, state);
+  }
+  gauge(name, value, labels) {
+    const series = this.getOrCreate(this.gauges, name);
+    series.set(labelKey(labels), { value });
+  }
+  histogram(name, value, labels) {
+    const series = this.getOrCreate(this.histograms, name);
+    const key = labelKey(labels);
+    let state = series.get(key);
+    if (!state) {
+      state = { count: 0, sum: 0, min: value, max: value, samples: [] };
+      series.set(key, state);
+    }
+    state.count++;
+    state.sum += value;
+    if (value < state.min) state.min = value;
+    if (value > state.max) state.max = value;
+    if (state.samples.length < RESERVOIR_SIZE) {
+      state.samples.push(value);
+    } else {
+      const r = Math.floor(Math.random() * state.count);
+      if (r < RESERVOIR_SIZE) state.samples[r] = value;
+    }
+  }
+  snapshot() {
+    const series = [];
+    for (const [name, byLabel] of this.counters) {
+      for (const [key, state] of byLabel) {
+        series.push({
+          name,
+          type: "counter",
+          labels: parseLabelKey(key),
+          values: { value: state.value }
+        });
+      }
+    }
+    for (const [name, byLabel] of this.gauges) {
+      for (const [key, state] of byLabel) {
+        series.push({
+          name,
+          type: "gauge",
+          labels: parseLabelKey(key),
+          values: { value: state.value }
+        });
+      }
+    }
+    for (const [name, byLabel] of this.histograms) {
+      for (const [key, state] of byLabel) {
+        const sorted = [...state.samples].sort((a, b) => a - b);
+        series.push({
+          name,
+          type: "histogram",
+          labels: parseLabelKey(key),
+          values: {
+            count: state.count,
+            sum: state.sum,
+            min: state.min,
+            max: state.max,
+            p50: quantile(sorted, 0.5),
+            p95: quantile(sorted, 0.95),
+            p99: quantile(sorted, 0.99)
+          }
+        });
+      }
+    }
+    return { timestamp: Date.now(), series };
+  }
+  reset() {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+  }
+  getOrCreate(bag, name) {
+    let series = bag.get(name);
+    if (!series) {
+      series = /* @__PURE__ */ new Map();
+      bag.set(name, series);
+    }
+    return series;
+  }
+};
+function parseLabelKey(key) {
+  if (!key) return {};
+  const labels = {};
+  for (const pair of key.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq > 0) labels[pair.slice(0, eq)] = pair.slice(eq + 1);
+  }
+  return labels;
+}
+var NoopMetricsSink = class {
+  counter() {
+  }
+  gauge() {
+  }
+  histogram() {
+  }
+  snapshot() {
+    return { timestamp: Date.now(), series: [] };
+  }
+  reset() {
+  }
+};
+
+// src/defaults/observability/health.ts
+var SEVERITY = {
+  healthy: 0,
+  degraded: 1,
+  unhealthy: 2
+};
+var DefaultHealthRegistry = class {
+  checks = /* @__PURE__ */ new Map();
+  timeoutMs;
+  constructor(opts = {}) {
+    this.timeoutMs = opts.timeoutMs ?? 5e3;
+  }
+  register(check) {
+    this.checks.set(check.name, check);
+  }
+  unregister(name) {
+    this.checks.delete(name);
+  }
+  async run() {
+    const results = await Promise.all(
+      Array.from(this.checks.values()).map(async (c) => {
+        const result = await this.runOne(c);
+        return { name: c.name, ...result };
+      })
+    );
+    let status = "healthy";
+    for (const r of results) {
+      if (SEVERITY[r.status] > SEVERITY[status]) status = r.status;
+    }
+    return { status, timestamp: Date.now(), checks: results };
+  }
+  async runOne(check) {
+    const timeout = new Promise((resolve3) => {
+      setTimeout(
+        () => resolve3({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        this.timeoutMs
+      );
+    });
+    try {
+      return await Promise.race([check.check(), timeout]);
+    } catch (err) {
+      return { status: "unhealthy", detail: err instanceof Error ? err.message : String(err) };
+    }
+  }
+};
+
+// src/defaults/observability/tracer.ts
+var NoopTracer = class {
+  startSpan() {
+    return NOOP_SPAN;
   }
-  async createFlow(specContent, options) {
-    const flow = new TaskFlow({
-      tracker: this.tracker,
-      events: this.events,
-      ...options
-    });
-    const graph = await flow.fromSpec(specContent);
-    this.flows.set(graph.id, flow);
-    return flow;
+};
+var NOOP_SPAN = {
+  setAttribute() {
+  },
+  recordError() {
+  },
+  end() {
   }
-  getTracker() {
-    return this.tracker;
+};
+
+// src/defaults/observability/otel-tracer.ts
+var OTEL_STATUS_ERROR = 2;
+var OTelTracer = class {
+  constructor(upstream) {
+    this.upstream = upstream;
   }
-  getFlow(graphId) {
-    return this.flows.get(graphId);
+  upstream;
+  startSpan(name, attrs) {
+    const otelSpan = this.upstream.startSpan(name, attrs ? { attributes: attrs } : void 0);
+    return new OTelSpan(otelSpan);
   }
-  listFlows() {
-    return Array.from(this.flows.entries()).map(([id, flow]) => ({
-      id,
-      title: flow.getGraph()?.title ?? "Untitled",
-      phase: flow.getPhase()
-    }));
+};
+var OTelSpan = class {
+  constructor(span) {
+    this.span = span;
+  }
+  span;
+  setAttribute(key, value) {
+    this.span.setAttribute(key, value);
+  }
+  recordError(err) {
+    this.span.recordException(err);
+    this.span.setStatus?.({ code: OTEL_STATUS_ERROR, message: err.message });
+  }
+  end() {
+    this.span.end();
   }
 };
 
-// src/utils/tool-output-serializer.ts
-function createToolOutputSerializer(opts = {}) {
-  const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
-  function serialize(value) {
-    if (typeof value === "string") return value;
-    if (value === null || value === void 0) return "";
-    if (typeof value === "object") {
-      if (Array.isArray(value)) return value.map(serialize).join("\n");
-      if ("text" in value) {
-        const t = value.text;
-        return typeof t === "string" ? t : JSON.stringify(value, null, 2);
+// src/defaults/observability/event-bridge.ts
+function wireMetricsToEvents(events, sink) {
+  const unsubs = [];
+  unsubs.push(
+    events.on("session.started", () => sink.counter("agent.sessions.started")),
+    events.on("session.ended", (e) => {
+      sink.counter("agent.sessions.ended");
+      sink.histogram("agent.session.tokens.input", e.usage.input);
+      sink.histogram("agent.session.tokens.output", e.usage.output);
+    }),
+    events.on("session.damaged", () => sink.counter("agent.sessions.damaged")),
+    events.on("iteration.completed", () => sink.counter("agent.iterations.total")),
+    events.on("iteration.limit_reached", () => sink.counter("agent.iteration_limit.hit")),
+    events.on("provider.response", (e) => {
+      sink.counter("provider.responses.total", 1, { stop_reason: e.stopReason });
+      sink.counter("provider.tokens.input", e.usage.input);
+      sink.counter("provider.tokens.output", e.usage.output);
+      if (e.usage.cacheRead) sink.counter("provider.tokens.cache_read", e.usage.cacheRead);
+      if (e.usage.cacheWrite) sink.counter("provider.tokens.cache_write", e.usage.cacheWrite);
+    }),
+    events.on(
+      "provider.retry",
+      (e) => sink.counter("provider.retries.total", 1, {
+        provider: e.providerId,
+        status: String(e.status)
+      })
+    ),
+    events.on(
+      "provider.error",
+      (e) => sink.counter("provider.errors.total", 1, {
+        provider: e.providerId,
+        status: String(e.status),
+        retryable: String(e.retryable)
+      })
+    ),
+    events.on("tool.started", (e) => sink.counter("tool.starts.total", 1, { tool: e.name })),
+    events.on("tool.executed", (e) => {
+      sink.counter("tool.executions.total", 1, { tool: e.name, ok: String(e.ok) });
+      sink.histogram("tool.duration_ms", e.durationMs, { tool: e.name });
+    }),
+    events.on("token.threshold", (e) => sink.gauge("agent.tokens.used", e.used)),
+    events.on("compaction.fired", (e) => {
+      sink.counter("compaction.fired.total");
+      sink.histogram("compaction.reduction_tokens", e.before - e.after);
+    }),
+    events.on(
+      "mcp.server.connected",
+      (e) => sink.counter("mcp.connects.total", 1, { server: e.name })
+    ),
+    events.on(
+      "mcp.server.reconnected",
+      (e) => sink.counter("mcp.reconnects.total", 1, { server: e.name })
+    ),
+    events.on(
+      "mcp.server.disconnected",
+      (e) => sink.counter("mcp.disconnects.total", 1, { server: e.name })
+    ),
+    events.on("error", (e) => sink.counter("agent.errors.total", 1, { phase: e.phase }))
+  );
+  return () => {
+    for (const u of unsubs) u();
+  };
+}
+
+// src/defaults/observability/prometheus.ts
+var NUMBER_FORMAT_INFINITY = "NaN";
+function escapeLabelValue(v) {
+  return v.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, '\\"');
+}
+function formatLabels(labels) {
+  const keys = Object.keys(labels);
+  if (keys.length === 0) return "";
+  const parts = keys.map((k) => `${k}="${escapeLabelValue(labels[k] ?? "")}"`);
+  return `{${parts.join(",")}}`;
+}
+function formatNumber(n) {
+  if (!Number.isFinite(n)) return NUMBER_FORMAT_INFINITY;
+  return Number.isInteger(n) ? n.toString() : n.toString();
+}
+function joinLabels(base, extra) {
+  return { ...base, ...extra };
+}
+function renderPrometheus(snapshot) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of snapshot.series) {
+    let g = groups.get(s.name);
+    if (!g) {
+      g = { type: s.type, rows: [] };
+      groups.set(s.name, g);
+    }
+    g.rows.push({ labels: s.labels, values: s.values });
+  }
+  const lines = [];
+  for (const [name, g] of groups) {
+    const promType = g.type === "histogram" ? "summary" : g.type;
+    lines.push(`# HELP ${name} ${name}`);
+    lines.push(`# TYPE ${name} ${promType}`);
+    if (g.type === "counter" || g.type === "gauge") {
+      for (const row of g.rows) {
+        lines.push(`${name}${formatLabels(row.labels)} ${formatNumber(row.values.value ?? 0)}`);
       }
-      try {
-        return JSON.stringify(value, null, 2);
-      } catch {
-        return String(value);
+    } else {
+      for (const row of g.rows) {
+        const { count = 0, sum = 0, p50 = 0, p95 = 0, p99 = 0 } = row.values;
+        lines.push(
+          `${name}${formatLabels(joinLabels(row.labels, { quantile: "0.5" }))} ${formatNumber(p50)}`
+        );
+        lines.push(
+          `${name}${formatLabels(joinLabels(row.labels, { quantile: "0.95" }))} ${formatNumber(p95)}`
+        );
+        lines.push(
+          `${name}${formatLabels(joinLabels(row.labels, { quantile: "0.99" }))} ${formatNumber(p99)}`
+        );
+        lines.push(`${name}_sum${formatLabels(row.labels)} ${formatNumber(sum)}`);
+        lines.push(`${name}_count${formatLabels(row.labels)} ${formatNumber(count)}`);
       }
     }
-    return String(value);
   }
-  function enforceCap(text, remainingBudget) {
-    if (remainingBudget <= 0) {
-      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+  return lines.join("\n") + "\n";
+}
+var PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
+async function startMetricsServer(opts) {
+  const { createServer } = await import('http');
+  const host = opts.host ?? "127.0.0.1";
+  const path13 = opts.path ?? "/metrics";
+  const healthPath = opts.healthPath ?? "/healthz";
+  const healthRegistry = opts.healthRegistry;
+  const server = createServer((req, res) => {
+    if (!req.url || req.method !== "GET") {
+      res.statusCode = req.url ? 405 : 400;
+      res.end();
+      return;
     }
-    const textBytes = Buffer.byteLength(text, "utf8");
-    if (textBytes <= remainingBudget) {
-      return { text, newBudget: remainingBudget - textBytes };
+    const url = req.url.split("?")[0];
+    if (url === path13) {
+      let body;
+      try {
+        body = renderPrometheus(opts.sink.snapshot());
+      } catch (err) {
+        res.statusCode = 500;
+        res.setHeader("content-type", "text/plain; charset=utf-8");
+        res.end(`metrics render failed: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+      }
+      res.statusCode = 200;
+      res.setHeader("content-type", PROMETHEUS_CONTENT_TYPE);
+      res.end(body);
+      return;
     }
-    const marker = `
-\u2026[truncated ${textBytes - remainingBudget} bytes]\u2026
-`;
-    const markerBytes = Buffer.byteLength(marker, "utf8");
-    const available = remainingBudget - markerBytes;
-    if (available <= 0) {
-      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    if (healthRegistry && url === healthPath) {
+      healthRegistry.run().then(
+        (agg) => {
+          res.statusCode = agg.status === "unhealthy" ? 503 : 200;
+          res.setHeader("content-type", "application/json; charset=utf-8");
+          res.end(JSON.stringify(agg, null, 2));
+        },
+        (err) => {
+          res.statusCode = 500;
+          res.setHeader("content-type", "text/plain; charset=utf-8");
+          res.end(`health run failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      );
+      return;
     }
-    const half = Math.floor(available / 2);
-    const first = text.slice(0, half);
-    Buffer.byteLength(first, "utf8");
-    const second = text.slice(text.length - half);
-    return { text: `${first}${marker}${second}`, newBudget: 0 };
-  }
-  return { serialize, enforceCap, capBytes };
+    res.statusCode = 404;
+    res.setHeader("content-type", "text/plain; charset=utf-8");
+    res.end("Not Found");
+  });
+  await new Promise((resolve3, reject) => {
+    const onError = (err) => {
+      server.off("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve3();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(opts.port, host);
+  });
+  const addr = server.address();
+  const boundPort = typeof addr === "object" && addr ? addr.port : opts.port;
+  return {
+    port: boundPort,
+    url: `http://${host}:${boundPort}${path13}`,
+    close: () => new Promise((resolve3, reject) => {
+      server.close((err) => err ? reject(err) : resolve3());
+    })
+  };
 }
 
-// src/defaults/tool-executor.ts
-var ToolExecutor = class {
-  constructor(registry, opts) {
-    this.registry = registry;
-    this.opts = opts;
-    this.iterationTimeoutMs = opts.iterationTimeoutMs ?? 3e5;
-    this.serializer = createToolOutputSerializer({
-      perIterationOutputCapBytes: opts.perIterationOutputCapBytes ?? 1e5
-    });
-  }
-  registry;
-  opts;
-  serializer;
-  iterationTimeoutMs;
-  /**
-   * Execute a batch of tool uses using the configured strategy.
-   * Returns the execution results and the remaining output budget.
-   */
-  async executeBatch(toolUses, ctx, strategy) {
-    let budget = this.opts.perIterationOutputCapBytes ?? 1e5;
-    const runOne = async (use, index) => {
-      const start = Date.now();
-      const tool = this.registry.get(use.name);
-      let result;
-      if (!tool) {
-        result = this.unknownToolResult(use, () => this.registry.list().map((t) => t.name));
-      } else {
-        const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
-        if (decision.permission === "deny") {
-          result = this.deniedResult(use, decision.reason);
-        } else if (decision.permission === "confirm") {
-          result = this.confirmResult(use);
-        } else {
-          try {
-            result = await this.executeTool(tool, use, ctx, budget);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            const scrubbed = this.opts.secretScrubber.scrub(msg);
-            this.opts.renderer?.writeToolResult(tool.name, scrubbed, true);
-            result = {
-              type: "tool_result",
-              tool_use_id: use.id,
-              content: `Tool "${use.name}" threw: ${scrubbed}`,
-              is_error: true
-            };
-          }
-        }
-      }
-      const contentBytes = typeof result.content === "string" ? Buffer.byteLength(result.content, "utf8") : Buffer.byteLength(JSON.stringify(result.content), "utf8");
-      budget = Math.max(0, budget - contentBytes);
-      return { result, tool, durationMs: Date.now() - start };
+// src/defaults/observability/otlp-metrics.ts
+var DEFAULT_INTERVAL_MS = 3e4;
+var DEFAULT_TIMEOUT_MS = 1e4;
+function joinEndpoint(base) {
+  if (/\/v1\/metrics\/?$/.test(base)) return base;
+  return base.replace(/\/$/, "") + "/v1/metrics";
+}
+function attributesFor(labels) {
+  return Object.entries(labels).map(([key, value]) => ({
+    key,
+    value: { stringValue: value }
+  }));
+}
+function buildExportBody(opts) {
+  const metrics = [];
+  for (const s of opts.series) {
+    const dp = {
+      attributes: attributesFor(s.labels),
+      timeUnixNano: opts.timeUnixNano
     };
-    if (strategy === "sequential") {
-      const outputs = [];
-      for (let i = 0; i < toolUses.length; i++) {
-        const use = toolUses[i];
-        if (use) outputs.push(await runOne(use));
-      }
-      return { outputs, remainingBudget: budget };
-    }
-    if (strategy === "parallel") {
-      const outputs = await Promise.all(toolUses.map((use, i) => runOne(use)));
-      return { outputs, remainingBudget: budget };
-    }
-    const nonMutating = [];
-    const mutating = [];
-    for (let i = 0; i < toolUses.length; i++) {
-      const use = toolUses[i];
-      if (!use) continue;
-      const tool = this.registry.get(use.name);
-      if (tool?.mutating) mutating.push({ use, index: i });
-      else nonMutating.push({ use, index: i });
-    }
-    const firstPass = await Promise.all(nonMutating.map(({ use, index }) => runOne(use)));
-    const secondPass = [];
-    for (const { use, index } of mutating) {
-      secondPass.push(await runOne(use));
+    if (s.type === "counter") {
+      dp.asDouble = s.values.value ?? 0;
+      metrics.push({
+        name: s.name,
+        sum: { dataPoints: [dp], aggregationTemporality: 2, isMonotonic: true }
+      });
+    } else if (s.type === "gauge") {
+      dp.asDouble = s.values.value ?? 0;
+      metrics.push({ name: s.name, gauge: { dataPoints: [dp] } });
+    } else {
+      dp.count = String(s.values.count ?? 0);
+      dp.sum = s.values.sum ?? 0;
+      dp.quantileValues = [
+        { quantile: 0.5, value: s.values.p50 ?? 0 },
+        { quantile: 0.95, value: s.values.p95 ?? 0 },
+        { quantile: 0.99, value: s.values.p99 ?? 0 }
+      ];
+      metrics.push({ name: s.name, summary: { dataPoints: [dp] } });
     }
-    return {
-      outputs: [...firstPass, ...secondPass],
-      remainingBudget: budget
-    };
   }
-  /**
-   * Execute a single tool with timeout, permission check, and output capping.
-   * Emits `tool.started` via the injected EventBus (if any) right before
-   * invoking the tool — closes the observability gap between "model decided
-   * to call a tool" and "tool.executed".
-   */
-  async executeTool(tool, use, ctx, budget) {
-    this.opts.events?.emit("tool.started", {
-      name: tool.name,
-      id: use.id,
-      input: use.input
+  return {
+    resourceMetrics: [
+      {
+        resource: { attributes: attributesFor(opts.resourceAttributes) },
+        scopeMetrics: [
+          {
+            scope: { name: opts.scopeName },
+            metrics
+          }
+        ]
+      }
+    ]
+  };
+}
+function buildOtlpMetricsRequest(sink, opts = {}) {
+  return buildExportBody({
+    series: sink.snapshot().series,
+    resourceAttributes: opts.resourceAttributes ?? { "service.name": "wrongstack" },
+    scopeName: opts.scopeName ?? "wrongstack",
+    timeUnixNano: String(BigInt(Date.now()) * 1000000n)
+  });
+}
+function startOtlpMetricsExporter(opts) {
+  const url = joinEndpoint(opts.endpoint);
+  const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const onError = opts.onError ?? (() => {
+  });
+  const resourceAttributes = opts.resourceAttributes ?? { "service.name": "wrongstack" };
+  const scopeName = opts.scopeName ?? "wrongstack";
+  let stopped = false;
+  const headers = {
+    "content-type": "application/json",
+    ...opts.headers ?? {}
+  };
+  if (opts.authorization) headers.authorization = opts.authorization;
+  async function pushOnce() {
+    if (stopped) return;
+    const body = buildExportBody({
+      series: opts.sink.snapshot().series,
+      resourceAttributes,
+      scopeName,
+      timeUnixNano: String(BigInt(Date.now()) * 1000000n)
     });
-    this.opts.renderer?.writeToolCall(tool.name, use.input);
-    const output = await this.runWithTimeout(tool, use.input, ctx.signal, ctx);
-    const text = this.serializer.serialize(output);
-    const scrubbed = this.opts.secretScrubber.scrub(text);
-    const { text: capped } = this.serializer.enforceCap(scrubbed, budget);
-    this.opts.renderer?.writeToolResult(tool.name, capped, false);
-    return {
-      type: "tool_result",
-      tool_use_id: use.id,
-      name: tool.name,
-      content: capped,
-      is_error: false
-    };
-  }
-  async runWithTimeout(tool, input, parentSignal, ctx) {
-    if (parentSignal.aborted) {
-      throw parentSignal.reason instanceof Error ? parentSignal.reason : new Error(typeof parentSignal.reason === "string" ? parentSignal.reason : "aborted");
-    }
-    const timeoutMs = tool.timeoutMs ?? this.iterationTimeoutMs;
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
-    const combined = anySignal([parentSignal, ctrl.signal]);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      return await tool.execute(input, ctx, { signal: combined });
+      const res = await fetchImpl(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        onError(new Error(`OTLP push failed: ${res.status} ${res.statusText} ${text}`));
+      }
+    } catch (err) {
+      onError(err);
     } finally {
       clearTimeout(timer);
     }
   }
-  unknownToolResult(use, listFns) {
-    return {
-      type: "tool_result",
-      tool_use_id: use.id,
-      content: `Tool "${use.name}" is not registered. Available tools: ${listFns().join(", ")}`,
-      is_error: true
-    };
+  const handle = setInterval(() => {
+    void pushOnce();
+  }, intervalMs);
+  handle.unref?.();
+  return {
+    flush: pushOnce,
+    async stop() {
+      stopped = true;
+      clearInterval(handle);
+      await pushOnce().catch(onError);
+    }
+  };
+}
+var SPAN_STATUS_CODE_UNSET = 0;
+var SPAN_STATUS_CODE_OK = 1;
+var SPAN_STATUS_CODE_ERROR = 2;
+function hex(bytes) {
+  return crypto2.randomBytes(bytes).toString("hex");
+}
+function nowNs() {
+  return BigInt(Date.now()) * 1000000n;
+}
+var CapturingSpan = class {
+  constructor(state, onEnd) {
+    this.state = state;
+    this.onEnd = onEnd;
   }
-  deniedResult(use, reason) {
-    return {
-      type: "tool_result",
-      tool_use_id: use.id,
-      content: `Tool "${use.name}" denied: ${reason ?? "policy"}`,
-      is_error: true
-    };
+  state;
+  onEnd;
+  setAttribute(key, value) {
+    this.state.attributes[key] = value;
   }
-  confirmResult(use) {
-    return {
-      type: "tool_result",
-      tool_use_id: use.id,
-      content: `Tool "${use.name}" requires user confirmation but no prompt handler was available.`,
-      is_error: true
-    };
+  recordError(err) {
+    this.state.status = { code: SPAN_STATUS_CODE_ERROR, message: err.message };
+    this.state.attributes["exception.message"] = err.message;
+    if (err.name) this.state.attributes["exception.type"] = err.name;
+  }
+  end() {
+    if (this.state.endTimeUnixNano !== void 0) return;
+    this.state.endTimeUnixNano = nowNs();
+    if (this.state.status.code === SPAN_STATUS_CODE_UNSET) {
+      this.state.status.code = SPAN_STATUS_CODE_OK;
+    }
+    this.onEnd(this.state);
   }
 };
-function anySignal(signals) {
-  if (typeof AbortSignal.any === "function") {
-    return AbortSignal.any(signals);
+var DEFAULT_INTERVAL_MS2 = 5e3;
+var DEFAULT_BUFFER_CAP = 2048;
+var DEFAULT_TIMEOUT_MS2 = 1e4;
+function joinEndpoint2(base) {
+  if (/\/v1\/traces\/?$/.test(base)) return base;
+  return base.replace(/\/$/, "") + "/v1/traces";
+}
+function encodeAttr(key, value) {
+  if (typeof value === "boolean") return { key, value: { boolValue: value } };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { key, value: { intValue: String(value) } } : { key, value: { doubleValue: value } };
   }
-  const ctrl = new AbortController();
-  const abortSources = [];
-  for (const s of signals) {
-    if (s.aborted) {
-      ctrl.abort(s.reason);
-      return ctrl.signal;
+  return { key, value: { stringValue: value } };
+}
+function buildOtlpTracesRequest(spans, opts = {}) {
+  const resourceAttributes = opts.resourceAttributes ?? { "service.name": "wrongstack" };
+  const scopeName = opts.scopeName ?? "wrongstack";
+  const otlpSpans = spans.map((s) => ({
+    traceId: s.traceId,
+    spanId: s.spanId,
+    name: s.name,
+    kind: 1,
+    // SPAN_KIND_INTERNAL
+    startTimeUnixNano: s.startTimeUnixNano.toString(),
+    endTimeUnixNano: (s.endTimeUnixNano ?? s.startTimeUnixNano).toString(),
+    attributes: Object.entries(s.attributes).map(([k, v]) => encodeAttr(k, v)),
+    status: s.status
+  }));
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: Object.entries(resourceAttributes).map(
+            ([k, v]) => encodeAttr(k, v)
+          )
+        },
+        scopeSpans: [{ scope: { name: scopeName }, spans: otlpSpans }]
+      }
+    ]
+  };
+}
+function startOtlpTraceExporter(opts) {
+  const url = joinEndpoint2(opts.endpoint);
+  const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS2;
+  const maxBuffered = opts.maxBufferedSpans ?? DEFAULT_BUFFER_CAP;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const onError = opts.onError ?? (() => {
+  });
+  const resourceAttributes = opts.resourceAttributes ?? { "service.name": "wrongstack" };
+  const scopeName = opts.scopeName ?? "wrongstack";
+  let stopped = false;
+  const buffer = [];
+  const headers = {
+    "content-type": "application/json",
+    ...opts.headers ?? {}
+  };
+  if (opts.authorization) headers.authorization = opts.authorization;
+  const tracer = {
+    startSpan(name, attrs) {
+      const state = {
+        traceId: hex(16),
+        spanId: hex(8),
+        name,
+        startTimeUnixNano: nowNs(),
+        attributes: { ...attrs ?? {} },
+        status: { code: SPAN_STATUS_CODE_UNSET }
+      };
+      return new CapturingSpan(state, (ended) => {
+        if (buffer.length >= maxBuffered) buffer.shift();
+        buffer.push(ended);
+      });
+    }
+  };
+  async function pushOnce() {
+    if (buffer.length === 0) return;
+    const batch = buffer.splice(0, buffer.length);
+    const body = buildOtlpTracesRequest(batch, { resourceAttributes, scopeName });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetchImpl(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        onError(new Error(`OTLP traces push failed: ${res.status} ${res.statusText} ${text}`));
+      }
+    } catch (err) {
+      onError(err);
+    } finally {
+      clearTimeout(timer);
     }
-    abortSources.push(s);
-  }
-  for (const s of abortSources) {
-    s.addEventListener("abort", () => ctrl.abort(s.reason), { once: true });
   }
-  return ctrl.signal;
+  const handle = setInterval(() => {
+    if (!stopped) void pushOnce();
+  }, intervalMs);
+  handle.unref?.();
+  return {
+    tracer,
+    flush: pushOnce,
+    async stop() {
+      stopped = true;
+      clearInterval(handle);
+      await pushOnce().catch(onError);
+    },
+    buffered: () => [...buffer]
+  };
 }
 
 // src/defaults/context-manager.ts
@@ -4544,6 +5975,107 @@ function createContextManagerTool(opts = {}) {
 }
 var contextManagerTool = createContextManagerTool();
 
-export { AutoCompactionMiddleware, AutonomousRunner, DefaultAttachmentStore, DefaultConfigLoader, DefaultErrorHandler, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, DefaultTokenCounter, DoneConditionChecker, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, IntelligentCompactor, LLMSelector, QueueStore, RecoveryLock, SelectiveCompactor, SpecDrivenDev, SpecParser, TaskFlow, TaskGenerator, TaskTracker, ToolExecutor, classifyFamily, contextManagerTool, createContextManagerTool, createMessage, decryptConfigSecrets, encryptConfigSecrets, loadProjectModes, loadUserModes, migratePlaintextSecrets, rewriteConfigEncrypted };
+// src/defaults/mcp-servers.ts
+var filesystemServer = () => ({
+  name: "filesystem",
+  description: "Read, write, and navigate the local filesystem (read-heavy tools)",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
+  permission: "confirm"
+});
+var githubServer = () => ({
+  name: "github",
+  description: "GitHub API \u2014 issues, PRs, repos, search, file ops (requires GITHUB_PERSONAL_ACCESS_TOKEN)",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-github"],
+  env: { GITHUB_PERSONAL_ACCESS_TOKEN: process.env.GITHUB_PERSONAL_ACCESS_TOKEN ?? "" },
+  permission: "confirm"
+});
+var context7Server = () => ({
+  name: "context7",
+  description: "Codebase-aware documentation and Q&A (context7.ai)",
+  transport: "streamable-http",
+  url: "https://server.context7.ai/mcp",
+  permission: "confirm"
+});
+var braveSearchServer = () => ({
+  name: "brave-search",
+  description: "Web search (Brave). Requires BRAVE_SEARCH_API_KEY \u2014 free tier 2k queries/month",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-brave-search"],
+  env: { BRAVE_SEARCH_API_KEY: process.env.BRAVE_SEARCH_API_KEY ?? "" },
+  permission: "confirm"
+});
+var blockServer = () => ({
+  name: "block",
+  description: "Postgres database access via SQL (Block MCP server)",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-block"],
+  permission: "confirm"
+});
+var everArtServer = () => ({
+  name: "everart",
+  description: "AI image generation (EverArt). Requires EVERART_API_KEY",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-everart"],
+  env: { EVERART_API_KEY: process.env.EVERART_API_KEY ?? "" },
+  permission: "confirm"
+});
+var slackServer = () => ({
+  name: "slack",
+  description: "Slack \u2014 messaging, channels, search. Requires SLACK_BOT_TOKEN + SLACK_TEAM_ID",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-slack"],
+  env: {
+    SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN ?? "",
+    SLACK_TEAM_ID: process.env.SLACK_TEAM_ID ?? ""
+  },
+  permission: "confirm"
+});
+var awsServer = () => ({
+  name: "aws",
+  description: "AWS \u2014 EC2, S3, Lambda, IAM, CloudFormation, costs. Requires AWS credentials",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-aws"],
+  permission: "confirm"
+});
+var googleMapsServer = () => ({
+  name: "google-maps",
+  description: "Google Maps \u2014 directions, geocoding, places. Requires GOOGLE_MAPS_API_KEY",
+  transport: "stdio",
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-google-maps"],
+  env: { GOOGLE_MAPS_API_KEY: process.env.GOOGLE_MAPS_API_KEY ?? "" },
+  permission: "confirm"
+});
+var sentinelServer = () => ({
+  name: "sentinel",
+  description: "Security vulnerability scanning (Sentinel)",
+  transport: "streamable-http",
+  url: "https://mcp.sentinel.ai",
+  permission: "deny"
+  // security tool — require explicit confirmation
+});
+var allServers = () => ({
+  filesystem: { ...filesystemServer(), enabled: false },
+  github: { ...githubServer(), enabled: false },
+  context7: { ...context7Server(), enabled: false },
+  "brave-search": { ...braveSearchServer(), enabled: false },
+  block: { ...blockServer(), enabled: false },
+  everart: { ...everArtServer(), enabled: false },
+  slack: { ...slackServer(), enabled: false },
+  aws: { ...awsServer(), enabled: false },
+  "google-maps": { ...googleMapsServer(), enabled: false },
+  sentinel: { ...sentinelServer(), enabled: false }
+});
+
+export { AutoCompactionMiddleware, AutonomousRunner, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, DefaultTokenCounter, DoneConditionChecker, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, QueueStore, RecoveryLock, SelectiveCompactor, SpecDrivenDev, SpecParser, SubagentBudget, TaskFlow, TaskGenerator, TaskTracker, ToolExecutor, allServers, awsServer, blockServer, braveSearchServer, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, context7Server, contextManagerTool, createContextManagerTool, createMessage, decryptConfigSecrets, encryptConfigSecrets, everArtServer, filesystemServer, githubServer, googleMapsServer, loadProjectModes, loadUserModes, makeAgentSubagentRunner, migratePlaintextSecrets, renderPrometheus, rewriteConfigEncrypted, runConfigMigrations, sentinelServer, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, wireMetricsToEvents };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map