@wrongstack/core 0.1.0

package/dist/defaults/index.js

@@ -0,0 +1,4549 @@
+import * as fs4 from 'fs';
+import * as path2 from 'path';
+import * as fsp from 'fs/promises';
+import { randomBytes, createCipheriv, createDecipheriv, randomUUID } from 'crypto';
+import * as os from 'os';
+import { EventEmitter } from 'events';
+
+// src/defaults/logger.ts
+
+// src/utils/color.ts
+var isColorTty = () => {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return true;
+  return Boolean(process.stdout?.isTTY);
+};
+var COLOR = isColorTty();
+var wrap = (open3, close) => (s) => COLOR ? `\x1B[${open3}m${s}\x1B[${close}m` : s;
+var color = {
+  reset: wrap("0", "0"),
+  bold: wrap("1", "22"),
+  dim: wrap("2", "22"),
+  italic: wrap("3", "23"),
+  underline: wrap("4", "24"),
+  red: wrap("31", "39"),
+  green: wrap("32", "39"),
+  yellow: wrap("33", "39"),
+  blue: wrap("34", "39"),
+  magenta: wrap("35", "39"),
+  cyan: wrap("36", "39"),
+  gray: wrap("90", "39"),
+  amber: wrap("38;5;214", "39"),
+  pink: wrap("38;5;205", "39"),
+  bgRed: wrap("41", "49"),
+  bgGreen: wrap("42", "49")
+};
+
+// src/defaults/logger.ts
+var LEVEL_RANK = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var COLORS = {
+  error: color.red,
+  warn: color.yellow,
+  info: color.cyan,
+  debug: color.gray,
+  trace: color.dim
+};
+var DefaultLogger = class _DefaultLogger {
+  level;
+  file;
+  bindings;
+  pretty;
+  constructor(opts = {}) {
+    this.level = opts.level ?? process.env.WRONGSTACK_LOG_LEVEL ?? "info";
+    this.file = opts.file;
+    this.bindings = opts.bindings ?? {};
+    this.pretty = opts.pretty ?? true;
+    if (this.file) {
+      try {
+        fs4.mkdirSync(path2.dirname(this.file), { recursive: true });
+      } catch {
+      }
+    }
+  }
+  error(msg, ctx) {
+    this.log("error", msg, ctx);
+  }
+  warn(msg, ctx) {
+    this.log("warn", msg, ctx);
+  }
+  info(msg, ctx) {
+    this.log("info", msg, ctx);
+  }
+  debug(msg, ctx) {
+    this.log("debug", msg, ctx);
+  }
+  trace(msg, ctx) {
+    this.log("trace", msg, ctx);
+  }
+  child(bindings) {
+    return new _DefaultLogger({
+      level: this.level,
+      file: this.file,
+      pretty: this.pretty,
+      bindings: { ...this.bindings, ...bindings }
+    });
+  }
+  log(level, msg, ctx) {
+    const r = LEVEL_RANK[level];
+    const allowed = LEVEL_RANK[this.level];
+    if (r > allowed) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { ts, level, msg, ...this.bindings };
+    if (ctx !== void 0) {
+      entry.ctx = ctx instanceof Error ? { message: ctx.message, stack: ctx.stack } : ctx;
+    }
+    if (this.file) {
+      try {
+        fs4.appendFileSync(this.file, `${JSON.stringify(entry)}
+`);
+      } catch {
+      }
+    }
+    if (r <= LEVEL_RANK.warn || this.level === "debug" || this.level === "trace") {
+      const head = `${color.dim(ts)} ${COLORS[level](level.toUpperCase().padEnd(5))} ${msg}`;
+      if (ctx !== void 0) {
+        process.stderr.write(`${head} ${formatCtx(ctx)}
+`);
+      } else {
+        process.stderr.write(`${head}
+`);
+      }
+    }
+  }
+};
+function formatCtx(ctx) {
+  if (ctx instanceof Error) return color.dim(ctx.message);
+  if (typeof ctx === "string") return color.dim(ctx);
+  try {
+    return color.dim(JSON.stringify(ctx));
+  } catch {
+    return color.dim(String(ctx));
+  }
+}
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "pnpm-workspace.yaml",
+  "go.mod",
+  "Cargo.toml",
+  "pyproject.toml",
+  ".wrongstack"
+];
+var DefaultPathResolver = class {
+  projectRoot;
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = path2.resolve(cwd);
+    this.projectRoot = this.detectProjectRoot(this.cwd);
+  }
+  detectProjectRoot(start) {
+    let dir = path2.resolve(start);
+    const root = path2.parse(dir).root;
+    while (dir !== root) {
+      for (const marker of PROJECT_MARKERS) {
+        try {
+          fs4.accessSync(path2.join(dir, marker));
+          return dir;
+        } catch {
+        }
+      }
+      const parent = path2.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return path2.resolve(start);
+  }
+  resolve(input) {
+    const abs = path2.isAbsolute(input) ? input : path2.resolve(this.cwd, input);
+    let real;
+    try {
+      real = fs4.realpathSync(abs);
+    } catch {
+      real = path2.normalize(abs);
+    }
+    return real;
+  }
+  isInsideRoot(absPath) {
+    const normalized = path2.normalize(absPath);
+    const root = path2.normalize(this.projectRoot);
+    if (normalized === root) return true;
+    const rel = path2.relative(root, normalized);
+    return !rel.startsWith("..") && !path2.isAbsolute(rel);
+  }
+  ensureInsideRoot(absPath) {
+    const resolved = this.resolve(absPath);
+    if (!this.isInsideRoot(resolved)) {
+      throw new Error(
+        `Path "${absPath}" resolves outside the project root (${this.projectRoot})`
+      );
+    }
+    return resolved;
+  }
+};
+
+// 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;
+  output = 0;
+  cacheRead = 0;
+  cacheWrite = 0;
+  costInput = 0;
+  costOutput = 0;
+  registry;
+  providerId;
+  events;
+  priceCache = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.registry = opts.registry;
+    this.providerId = opts.providerId;
+    this.events = opts.events;
+  }
+  account(usage, model) {
+    this.input += usage.input;
+    this.output += usage.output;
+    this.cacheRead += usage.cacheRead ?? 0;
+    this.cacheWrite += usage.cacheWrite ?? 0;
+    const price = model ? this.priceCache.get(model) : void 0;
+    if (price) {
+      this.applyPrice(usage, price);
+    } else if (this.registry && this.providerId && model) {
+      void this.registry.getModel(this.providerId, model).then((m) => {
+        if (m) {
+          const p = priceFromModel(m);
+          this.priceCache.set(model, p);
+          this.applyPrice(usage, p);
+        }
+      }).catch(() => {
+        this.events?.emit("token.cost_estimate_unavailable", { model: model ?? "<unknown>" });
+        return void 0;
+      });
+    }
+  }
+  /** Synchronous variant for code paths that have already resolved the model. */
+  accountWithModel(usage, resolved) {
+    this.input += usage.input;
+    this.output += usage.output;
+    this.cacheRead += usage.cacheRead ?? 0;
+    this.cacheWrite += usage.cacheWrite ?? 0;
+    const price = priceFromModel(resolved);
+    this.priceCache.set(resolved.modelId, price);
+    this.applyPrice(usage, price);
+  }
+  total() {
+    return {
+      input: this.input,
+      output: this.output,
+      cacheRead: this.cacheRead,
+      cacheWrite: this.cacheWrite
+    };
+  }
+  estimateCost() {
+    return {
+      input: round4(this.costInput),
+      output: round4(this.costOutput),
+      total: round4(this.costInput + this.costOutput),
+      currency: "USD"
+    };
+  }
+  cacheStats() {
+    const denom = this.cacheRead + this.input;
+    return {
+      readTokens: this.cacheRead,
+      writeTokens: this.cacheWrite,
+      hitRatio: denom === 0 ? 0 : this.cacheRead / denom
+    };
+  }
+  /** Invalidate cached prices so the next account() call fetches fresh data. */
+  invalidateCache() {
+    this.priceCache.clear();
+  }
+  reset() {
+    this.input = 0;
+    this.output = 0;
+    this.cacheRead = 0;
+    this.cacheWrite = 0;
+    this.costInput = 0;
+    this.costOutput = 0;
+  }
+  applyPrice(usage, price) {
+    if (price.input) this.costInput += usage.input / 1e6 * price.input;
+    if (price.output) this.costOutput += usage.output / 1e6 * price.output;
+    if (usage.cacheRead && price.cacheRead) {
+      this.costInput += usage.cacheRead / 1e6 * price.cacheRead;
+    }
+    if (usage.cacheWrite && price.cacheWrite) {
+      this.costInput += usage.cacheWrite / 1e6 * price.cacheWrite;
+    }
+  }
+};
+function priceFromModel(m) {
+  return {
+    input: m.cost?.input,
+    output: m.cost?.output,
+    cacheRead: m.cost?.cache_read,
+    cacheWrite: m.cost?.cache_write
+  };
+}
+function round4(n) {
+  return Math.round(n * 1e4) / 1e4;
+}
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path2.dirname(targetPath);
+  await fsp.mkdir(dir, { recursive: true });
+  const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fsp.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fsp.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fsp.open(tmp, "r+");
+      await fh.sync();
+      await fh.close();
+    } catch {
+    }
+    let mode;
+    try {
+      const stat4 = await fsp.stat(targetPath);
+      mode = stat4.mode & 511;
+    } catch {
+    }
+    if (mode !== void 0) {
+      await fsp.chmod(tmp, mode);
+    }
+    await fsp.rename(tmp, targetPath);
+  } catch (err) {
+    try {
+      await fsp.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function ensureDir(dir) {
+  await fsp.mkdir(dir, { recursive: true });
+}
+
+// src/defaults/session-store.ts
+var DefaultSessionStore = class {
+  dir;
+  events;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.events = opts.events;
+  }
+  async create(meta) {
+    await ensureDir(this.dir);
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const id = meta.id ?? `${startedAt.replace(/[:.]/g, "-")}-${randomBytes(2).toString("hex")}`;
+    const file = path2.join(this.dir, `${id}.jsonl`);
+    let handle;
+    try {
+      handle = await fsp.open(file, "a", 384);
+    } catch (err) {
+      throw new Error(`Failed to open session file: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+      return new FileSessionWriter(id, handle, startedAt, meta, { dir: this.dir, filePath: file });
+    } catch (err) {
+      await handle.close().catch(() => {
+      });
+      throw err;
+    }
+  }
+  async resume(id) {
+    const data = await this.load(id);
+    const file = path2.join(this.dir, `${id}.jsonl`);
+    let handle;
+    try {
+      handle = await fsp.open(file, "a", 384);
+    } catch (err) {
+      throw new Error(
+        `Failed to open session "${id}" for append: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    const writer = new FileSessionWriter(
+      id,
+      handle,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      {
+        id,
+        model: data.metadata.model,
+        provider: data.metadata.provider
+      },
+      { resumed: true, dir: this.dir, filePath: file }
+    );
+    return { writer, data };
+  }
+  async load(id) {
+    const file = path2.join(this.dir, `${id}.jsonl`);
+    const raw = await fsp.readFile(file, "utf8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const events = [];
+    for (const line of lines) {
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    const meta = this.metaFromEvents(id, events);
+    const { messages, usage } = this.replay(events, id);
+    return { metadata: meta, events, messages, usage };
+  }
+  async list(limit = 20) {
+    try {
+      await ensureDir(this.dir);
+      const files = await fsp.readdir(this.dir);
+      const ids = files.filter((f) => f.endsWith(".jsonl")).map((f) => f.replace(/\.jsonl$/, ""));
+      const sessions = await Promise.all(
+        ids.map((id) => this.summaryFor(id).catch(() => null))
+      );
+      const out = sessions.filter((s) => s !== null);
+      out.sort((a, b) => a.startedAt < b.startedAt ? 1 : -1);
+      return out.slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+  async summaryFor(id) {
+    const manifest = path2.join(this.dir, `${id}.summary.json`);
+    try {
+      const raw = await fsp.readFile(manifest, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      const full = path2.join(this.dir, `${id}.jsonl`);
+      const stat4 = await fsp.stat(full);
+      const summary = await this.summarize(id, stat4.mtime.toISOString());
+      await fsp.writeFile(manifest, JSON.stringify(summary), { mode: 384 }).catch(() => void 0);
+      return summary;
+    }
+  }
+  async delete(id) {
+    await fsp.unlink(path2.join(this.dir, `${id}.jsonl`));
+    await fsp.unlink(path2.join(this.dir, `${id}.summary.json`)).catch(() => void 0);
+  }
+  async summarize(id, mtime) {
+    try {
+      const data = await this.load(id);
+      const firstUser = data.events.find((e) => e.type === "user_input");
+      const title = firstUser && firstUser.type === "user_input" ? userInputTitle(firstUser.content) : "(empty session)";
+      return {
+        id,
+        title,
+        startedAt: data.metadata.startedAt,
+        model: data.metadata.model ?? "unknown",
+        provider: data.metadata.provider ?? "unknown",
+        tokenTotal: data.usage.input + data.usage.output
+      };
+    } catch {
+      return {
+        id,
+        title: "(damaged)",
+        startedAt: mtime,
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    }
+  }
+  metaFromEvents(id, events) {
+    const start = events.find((e) => e.type === "session_start");
+    const end = events.find((e) => e.type === "session_end");
+    return {
+      id,
+      startedAt: start?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      endedAt: end?.ts,
+      model: start?.model,
+      provider: start?.provider
+    };
+  }
+  replay(events, sessionId = "unknown") {
+    const messages = [];
+    let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    const openToolUses = /* @__PURE__ */ new Set();
+    for (const e of events) {
+      if (e.type === "user_input") {
+        openToolUses.clear();
+        messages.push({ role: "user", content: e.content });
+      } else if (e.type === "llm_response") {
+        messages.push({ role: "assistant", content: e.content });
+        for (const b of e.content) {
+          if (b.type === "tool_use") openToolUses.add(b.id);
+        }
+        usage = {
+          input: usage.input + (e.usage.input ?? 0),
+          output: usage.output + (e.usage.output ?? 0),
+          cacheRead: (usage.cacheRead ?? 0) + (e.usage.cacheRead ?? 0),
+          cacheWrite: (usage.cacheWrite ?? 0) + (e.usage.cacheWrite ?? 0)
+        };
+      } else if (e.type === "tool_result") {
+        if (!openToolUses.has(e.id)) {
+          this.events?.emit("session.damaged", {
+            sessionId,
+            detail: `Orphan tool_result "${e.id}" has no matching tool_use`
+          });
+          continue;
+        }
+        openToolUses.delete(e.id);
+        const content = [
+          {
+            type: "tool_result",
+            tool_use_id: e.id,
+            content: typeof e.content === "string" ? e.content : JSON.stringify(e.content),
+            is_error: e.isError
+          }
+        ];
+        const last = messages[messages.length - 1];
+        if (last && last.role === "user") {
+          if (Array.isArray(last.content)) {
+            last.content.push(...content);
+          } else if (typeof last.content === "string") {
+            last.content = [{ type: "text", text: last.content }, ...content];
+          } else {
+            messages.push({ role: "user", content });
+          }
+        } else {
+          messages.push({ role: "user", content });
+        }
+      }
+    }
+    if (openToolUses.size > 0) {
+      throw new Error(
+        `Session damaged: ${openToolUses.size} tool_use blocks without matching results`
+      );
+    }
+    return { messages, usage };
+  }
+};
+var FileSessionWriter = class {
+  constructor(id, handle, startedAt, meta, opts = {}) {
+    this.id = id;
+    this.handle = handle;
+    this.startedAt = startedAt;
+    this.meta = meta;
+    this.resumed = opts.resumed ?? false;
+    this.manifestFile = opts.dir ? path2.join(opts.dir, `${id}.summary.json`) : "";
+    this.filePath = opts.filePath ?? "";
+    this.summary = {
+      id,
+      title: "(empty session)",
+      startedAt,
+      model: meta.model ?? "unknown",
+      provider: meta.provider ?? "unknown",
+      tokenTotal: 0
+    };
+  }
+  id;
+  handle;
+  startedAt;
+  meta;
+  closed = false;
+  manifestFile;
+  summary;
+  tokenIn = 0;
+  tokenOut = 0;
+  filePath;
+  initDone = false;
+  resumed;
+  async writeSessionStart() {
+    if (this.initDone || this.closed) return;
+    this.initDone = true;
+    const record = `${JSON.stringify({
+      type: this.resumed ? "session_resumed" : "session_start",
+      ts: this.startedAt,
+      id: this.id,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown"
+    })}
+`;
+    try {
+      if (this.filePath) {
+        await fsp.writeFile(this.filePath, record, { flag: "a", mode: 384 });
+      }
+    } catch {
+    }
+  }
+  async append(event) {
+    if (this.closed) return;
+    if (!this.initDone) {
+      await this.writeSessionStart();
+    }
+    this.observeForSummary(event);
+    try {
+      await this.handle.appendFile(`${JSON.stringify(event)}
+`, "utf8");
+    } catch (err) {
+      console.warn("[session] append failed:", err instanceof Error ? err.message : String(err));
+    }
+  }
+  /**
+   * Watch events as they're appended and keep the summary state hot, so
+   * `close()` can flush a `<id>.summary.json` manifest without re-reading
+   * the JSONL. `list()` reads only manifests, turning a per-session full
+   * parse into a single stat+read.
+   */
+  observeForSummary(event) {
+    if (event.type === "user_input" && this.summary.title === "(empty session)") {
+      this.summary = { ...this.summary, title: userInputTitle(event.content) };
+    } else if (event.type === "llm_response") {
+      this.tokenIn += event.usage.input;
+      this.tokenOut += event.usage.output;
+      this.summary = { ...this.summary, tokenTotal: this.tokenIn + this.tokenOut };
+    } else if (event.type === "session_end") {
+      const total = event.usage.input + event.usage.output;
+      if (total > 0) this.summary = { ...this.summary, tokenTotal: total };
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.manifestFile) {
+      try {
+        await fsp.writeFile(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
+      } catch {
+      }
+    }
+    try {
+      await this.handle.close();
+    } catch {
+    }
+  }
+};
+function userInputTitle(content) {
+  if (typeof content === "string") return content.slice(0, 60);
+  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 {
+  file;
+  constructor(opts) {
+    this.file = path2.join(opts.dir, "queue.json");
+  }
+  async write(items) {
+    if (items.length === 0) {
+      await this.clear();
+      return;
+    }
+    await atomicWrite(this.file, JSON.stringify(items), { mode: 384 });
+  }
+  async read() {
+    let raw;
+    try {
+      raw = await fsp.readFile(this.file, "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return [];
+      return [];
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+    if (!Array.isArray(parsed)) return [];
+    const out = [];
+    for (const v of parsed) {
+      if (isPersistedQueueItem(v)) out.push(v);
+    }
+    return out;
+  }
+  async clear() {
+    try {
+      await fsp.unlink(this.file);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return;
+      console.warn(`QueueStore.clear() failed for ${this.file}: ${err.message}`);
+    }
+  }
+};
+function isPersistedQueueItem(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  return typeof o["displayText"] === "string" && Array.isArray(o["blocks"]);
+}
+var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
+var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)\]/g;
+var DefaultAttachmentStore = class {
+  items = /* @__PURE__ */ new Map();
+  refs = [];
+  nextSeq = { text: 0, image: 0, file: 0 };
+  spoolDir;
+  spoolThreshold;
+  constructor(opts = {}) {
+    this.spoolDir = opts.spoolDir;
+    this.spoolThreshold = opts.spoolThresholdBytes ?? DEFAULT_SPOOL_THRESHOLD;
+  }
+  async add(input) {
+    const seq = ++this.nextSeq[input.kind];
+    const id = `${kindPrefix(input.kind)}-${seq}-${randomBytes(3).toString("hex")}`;
+    const bytes = Buffer.byteLength(input.data, input.kind === "image" ? "base64" : "utf8");
+    let spooledPath;
+    let data = input.data;
+    if (this.spoolDir && bytes >= this.spoolThreshold) {
+      await fsp.mkdir(this.spoolDir, { recursive: true });
+      spooledPath = path2.join(this.spoolDir, `${id}.bin`);
+      await fsp.writeFile(spooledPath, input.data, input.kind === "image" ? "base64" : "utf8");
+      data = void 0;
+    }
+    const att = {
+      id,
+      kind: input.kind,
+      meta: input.meta ?? {},
+      data,
+      path: spooledPath,
+      bytes,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.items.set(id, att);
+    const ref = { id, kind: input.kind, seq, meta: att.meta };
+    this.refs.push(ref);
+    return ref;
+  }
+  async get(id) {
+    return this.items.get(id);
+  }
+  list() {
+    return [...this.refs];
+  }
+  async expand(text) {
+    const matches = [...text.matchAll(PLACEHOLDER_RE)];
+    if (matches.length === 0) return text ? [{ type: "text", text }] : [];
+    const blocks = [];
+    let lastIndex = 0;
+    for (const m of matches) {
+      const idx = m.index ?? 0;
+      const before = text.slice(lastIndex, idx);
+      if (before) blocks.push({ type: "text", text: before });
+      const kind = prefixToKind(m[1]);
+      const seq = Number(m[2]);
+      const ref = this.refs.find((r) => r.kind === kind && r.seq === seq);
+      const att = ref ? this.items.get(ref.id) : void 0;
+      if (!att) {
+        blocks.push({ type: "text", text: m[0] });
+      } else {
+        blocks.push(await this.toBlock(att));
+      }
+      lastIndex = idx + m[0].length;
+    }
+    const tail = text.slice(lastIndex);
+    if (tail) blocks.push({ type: "text", text: tail });
+    return mergeAdjacentText(blocks);
+  }
+  async clear() {
+    this.items.clear();
+    this.refs.length = 0;
+    this.nextSeq = { text: 0, image: 0, file: 0 };
+  }
+  async toBlock(att) {
+    if (att.kind === "image") {
+      const data = att.data ?? (att.path ? await fsp.readFile(att.path, { encoding: "base64" }) : "");
+      return {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: att.meta.mediaType ?? "image/png",
+          data
+        }
+      };
+    }
+    const raw = att.data ?? (att.path ? await fsp.readFile(att.path, "utf8") : "");
+    const label = att.meta.filename ? `<file path="${att.meta.filename}">` : "<pasted>";
+    const close = att.meta.filename ? "</file>" : "</pasted>";
+    return { type: "text", text: `${label}
+${raw}
+${close}` };
+  }
+};
+function kindPrefix(kind) {
+  return kind === "text" ? "pasted" : kind;
+}
+function prefixToKind(prefix) {
+  if (prefix === "pasted") return "text";
+  if (prefix === "image") return "image";
+  return "file";
+}
+function mergeAdjacentText(blocks) {
+  const out = [];
+  for (const b of blocks) {
+    const prev = out[out.length - 1];
+    if (b.type === "text" && prev && prev.type === "text") {
+      prev.text += b.text;
+    } else {
+      out.push(b);
+    }
+  }
+  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;
+  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 = 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;
+    }
+    fs4.mkdirSync(path2.dirname(this.keyFile), { recursive: true });
+    const key = randomBytes(KEY_BYTES);
+    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`);
+      }
+      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)) {
+    if (typeof v === "string" && isSecretField(k)) {
+      out[k] = transform(v);
+    } else if (typeof v === "object" && v !== null) {
+      out[k] = walk(v, vault, transform);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var SECRET_KEY_PATTERN = /(?:apikey|api_key|authtoken|auth_token|bearer|secret|password|passwd|pwd|refreshtoken|refresh_token|sessionkey|session_key|access[_-]?token|private[_-]?key)/i;
+var NON_SECRET_OVERRIDES = /* @__PURE__ */ new Set(["publickey", "public_key"]);
+function isSecretField(name) {
+  const lc = name.toLowerCase();
+  if (NON_SECRET_OVERRIDES.has(lc)) return false;
+  return SECRET_KEY_PATTERN.test(lc);
+}
+async function rewriteConfigEncrypted(configPath, vault, patch) {
+  let current = {};
+  try {
+    const raw = await fsp.readFile(configPath, "utf8");
+    current = JSON.parse(raw);
+  } catch {
+  }
+  const merged = deepMerge(current, patch ?? {});
+  const encrypted = encryptConfigSecrets(merged, vault);
+  await fsp.mkdir(path2.dirname(configPath), { recursive: true });
+  await fsp.writeFile(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
+  try {
+    await fsp.chmod(configPath, 384);
+  } catch {
+  }
+}
+async function migratePlaintextSecrets(configPath, vault) {
+  let raw;
+  try {
+    raw = await fsp.readFile(configPath, "utf8");
+  } catch {
+    return { migrated: 0, file: configPath };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { migrated: 0, file: configPath };
+  }
+  const counter = { n: 0 };
+  const migrated = walkCount(parsed, vault, counter);
+  if (counter.n === 0) return { migrated: 0, file: configPath };
+  await fsp.writeFile(configPath, JSON.stringify(migrated, null, 2), { mode: 384 });
+  try {
+    await fsp.chmod(configPath, 384);
+  } catch {
+  }
+  return { migrated: counter.n, file: configPath };
+}
+function walkCount(node, vault, counter) {
+  if (node === null || node === void 0) return node;
+  if (typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    return node.map((item) => walkCount(item, vault, counter));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(node)) {
+    if (typeof v === "string" && isSecretField(k) && !vault.isEncrypted(v) && v.length > 0) {
+      out[k] = vault.encrypt(v);
+      counter.n++;
+    } else if (typeof v === "object" && v !== null) {
+      out[k] = walkCount(v, vault, counter);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function deepMerge(a, b) {
+  const out = { ...a };
+  for (const [k, v] of Object.entries(b)) {
+    const existing = out[k];
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+      out[k] = deepMerge(existing, v);
+    } else {
+      out[k] = v;
+    }
+  }
+  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) {
+  return s.replace(/[.+^${}()|\\/]/g, "\\$&");
+}
+function compileGlob(pattern) {
+  let i = 0;
+  let re = "^";
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        re += ".*";
+        i += 2;
+        if (pattern[i] === "/") i++;
+      } else {
+        re += "[^/]*";
+        i++;
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+      i++;
+    } else if (c === "[") {
+      let cls = "[";
+      i++;
+      if (pattern[i] === "!" || pattern[i] === "^") {
+        cls += "^";
+        i++;
+      }
+      while (i < pattern.length && pattern[i] !== "]") {
+        const ch = pattern[i] ?? "";
+        if (ch === "\\") {
+          cls += "\\\\";
+        } else if (ch === "]" || ch === "^") {
+          cls += `\\${ch}`;
+        } else {
+          cls += ch;
+        }
+        i++;
+      }
+      cls += "]";
+      re += cls;
+      i++;
+    } else {
+      re += escapeRegex(c ?? "");
+      i++;
+    }
+  }
+  re += "$";
+  return new RegExp(re);
+}
+function matchGlob(pattern, input) {
+  return compileGlob(pattern).test(input);
+}
+function matchAny(patterns, input) {
+  return patterns.some((p) => matchGlob(p, input));
+}
+
+// src/utils/safe-json.ts
+function safeParse(input, maxBytes = 5e6) {
+  if (input.length > maxBytes) {
+    return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
+  }
+  try {
+    return { ok: true, value: JSON.parse(input) };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/defaults/permission-policy.ts
+var DefaultPermissionPolicy = class {
+  policy = {};
+  loaded = false;
+  trustFile;
+  yolo;
+  promptDelegate;
+  constructor(opts) {
+    this.trustFile = opts.trustFile;
+    this.yolo = opts.yolo ?? false;
+    this.promptDelegate = opts.promptDelegate;
+  }
+  async reload() {
+    try {
+      const raw = await fsp.readFile(this.trustFile, "utf8");
+      const parsed = safeParse(raw);
+      if (parsed.ok && parsed.value) this.policy = parsed.value;
+    } catch {
+      this.policy = {};
+    }
+    this.loaded = true;
+  }
+  async evaluate(tool, input, _ctx) {
+    if (!this.loaded) await this.reload();
+    const namespaceEntry = this.findNamespaceEntry(tool.name);
+    const entry = this.policy[tool.name] ?? namespaceEntry;
+    const subject = this.subjectFor(tool.name, input);
+    if (entry?.deny && subject && matchAny(entry.deny, subject)) {
+      return { permission: "deny", source: "deny", reason: "matched deny pattern" };
+    }
+    if (tool.permission === "deny") {
+      return { permission: "deny", source: "default", reason: "tool default deny" };
+    }
+    if (entry?.allow && subject && matchAny(entry.allow, subject)) {
+      return { permission: "auto", source: "trust", reason: "matched allow pattern" };
+    }
+    if (entry?.auto) {
+      return { permission: "auto", source: "trust" };
+    }
+    if (this.yolo) {
+      return { permission: "auto", source: "yolo" };
+    }
+    if (tool.permission === "auto") {
+      return { permission: "auto", source: "default" };
+    }
+    if (this.promptDelegate) {
+      const decision = await this.promptDelegate(tool, input, subject ?? tool.name);
+      if (decision === "always") {
+        await this.trust({ tool: tool.name, pattern: subject ?? tool.name });
+        return { permission: "auto", source: "user", reason: "user always-allowed" };
+      }
+      if (decision === "deny") {
+        return { permission: "deny", source: "user", reason: "user denied" };
+      }
+      return { permission: decision === "yes" ? "auto" : "deny", source: "user" };
+    }
+    return { permission: "confirm", source: "default" };
+  }
+  async trust(rule) {
+    if (!this.loaded) await this.reload();
+    const entry = this.policy[rule.tool] ?? {};
+    entry.allow = Array.from(/* @__PURE__ */ new Set([...entry.allow ?? [], rule.pattern]));
+    this.policy[rule.tool] = entry;
+    try {
+      await atomicWrite(this.trustFile, JSON.stringify(this.policy, null, 2));
+    } catch (err) {
+      const existing = this.policy[rule.tool];
+      if (existing?.allow) {
+        const idx = existing.allow.indexOf(rule.pattern);
+        if (idx !== -1) existing.allow.splice(idx, 1);
+      }
+      throw err;
+    }
+  }
+  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;
+  }
+  findNamespaceEntry(toolName) {
+    for (const key of Object.keys(this.policy)) {
+      if (key.includes("*") && matchGlob(key, toolName)) {
+        return this.policy[key];
+      }
+    }
+    return void 0;
+  }
+};
+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,
+    perIterationOutputCapBytes: 1e5,
+    autoExtendLimit: true
+  },
+  log: { level: "info" },
+  features: {
+    mcp: true,
+    plugins: true,
+    memory: true,
+    modelsRegistry: true,
+    skills: true
+  }
+};
+var ENV_MAP = {
+  WRONGSTACK_PROVIDER: (c, v) => {
+    c.provider = v;
+  },
+  WRONGSTACK_MODEL: (c, v) => {
+    c.model = v;
+  },
+  WRONGSTACK_API_KEY: (c, v) => {
+    c.apiKey = v;
+  },
+  WRONGSTACK_BASE_URL: (c, v) => {
+    c.baseUrl = v;
+  },
+  WRONGSTACK_LOG_LEVEL: (c, v) => {
+    if (!c.log) c.log = { level: "info" };
+    c.log.level = v;
+  }
+};
+function isPrimitiveArray(a) {
+  return a.every((v) => v === null || typeof v !== "object");
+}
+function deepMerge2(base, patch) {
+  if (typeof base !== "object" || base === null) return patch ?? base;
+  if (typeof patch !== "object" || patch === null) return base;
+  const out = { ...base };
+  for (const [k, v] of Object.entries(patch)) {
+    const existing = out[k];
+    if (Array.isArray(v)) {
+      if (Array.isArray(existing) && isPrimitiveArray(v) && isPrimitiveArray(existing)) {
+        out[k] = [.../* @__PURE__ */ new Set([...existing, ...v])];
+      } else {
+        out[k] = v;
+        if (process.env.WRONGSTACK_DEBUG_CONFIG) {
+          console.warn(
+            `[config] Non-primitive array for "${k}" replaced (global + local config merge). Global entries: ${existing?.length ?? 0}, local entries: ${v.length}.`
+          );
+        }
+      }
+    } else if (typeof v === "object" && v !== null && typeof existing === "object" && existing !== null) {
+      out[k] = deepMerge2(existing, v);
+    } else if (v !== void 0) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var DefaultConfigLoader = class {
+  paths;
+  strict;
+  vault;
+  extraSources;
+  constructor(opts) {
+    this.paths = opts.paths;
+    this.strict = opts.strict ?? false;
+    this.vault = opts.vault;
+    this.extraSources = opts.sources ?? [];
+  }
+  async load(opts = {}) {
+    let cfg = { ...BEHAVIOR_DEFAULTS };
+    const [global, local] = await Promise.all([
+      this.readJson(this.paths.globalConfig),
+      this.readJson(this.paths.projectLocalConfig)
+    ]);
+    cfg = deepMerge2(cfg, global);
+    cfg = deepMerge2(cfg, local);
+    for (const [key, fn] of Object.entries(ENV_MAP)) {
+      const v = process.env[key];
+      if (v) fn(cfg, v);
+    }
+    const sorted = [...this.extraSources].sort((a, b) => {
+      const pd = (a.priority ?? 50) - (b.priority ?? 50);
+      if (pd !== 0) return pd;
+      return a.name.localeCompare(b.name);
+    });
+    for (const src of sorted) {
+      try {
+        const patch = await src.read();
+        if (patch && Object.keys(patch).length > 0) {
+          cfg = deepMerge2(cfg, patch);
+        }
+      } catch (err) {
+        console.warn(`Config source "${src.name}" failed`, err);
+      }
+    }
+    if (opts.cliFlags) {
+      cfg = deepMerge2(cfg, opts.cliFlags);
+    }
+    if (this.vault) {
+      cfg = decryptConfigSecrets(cfg, this.vault);
+    }
+    this.validateBehavior(cfg);
+    if (this.strict) this.validateIdentity(cfg);
+    return Object.freeze(cfg);
+  }
+  async readJson(file) {
+    try {
+      const raw = await fsp.readFile(file, "utf8");
+      const parsed = safeParse(raw);
+      if (parsed.ok && parsed.value) return parsed.value;
+    } catch {
+    }
+    return {};
+  }
+  validateBehavior(cfg) {
+    if (cfg.version === void 0) throw new Error("Config: missing version field");
+    if (cfg.version !== 1) throw new Error(`Config: unsupported version ${cfg.version}`);
+    const c = cfg.context;
+    if (!c) throw new Error("Config: missing context section");
+    if (c.warnThreshold >= c.softThreshold || c.softThreshold >= c.hardThreshold) {
+      throw new Error("Config: context thresholds must satisfy warn < soft < hard");
+    }
+  }
+  validateIdentity(cfg) {
+    if (!cfg.provider) {
+      throw new Error(
+        "Config: no provider configured. Run `wstack init` or set WRONGSTACK_PROVIDER."
+      );
+    }
+    if (!cfg.model) {
+      throw new Error(
+        "Config: no model configured. Run `wstack init` or set WRONGSTACK_MODEL."
+      );
+    }
+  }
+};
+
+// src/defaults/compactor.ts
+var HybridCompactor = class {
+  preserveK;
+  eliseThreshold;
+  estimator;
+  constructor(opts = {}) {
+    this.preserveK = opts.preserveK ?? 10;
+    this.eliseThreshold = opts.eliseThreshold ?? 2e3;
+    this.estimator = opts.estimator ?? roughTokenEstimate;
+  }
+  async compact(ctx, opts = {}) {
+    const beforeTokens = this.estimateMessages(ctx.messages);
+    const reductions = [];
+    const phase1Saved = this.eliseOldToolResults(ctx);
+    if (phase1Saved > 0) reductions.push({ phase: "elision", saved: phase1Saved });
+    if (opts.aggressive) {
+      const phase2Saved = this.collapseAncientTurns(ctx);
+      if (phase2Saved > 0) reductions.push({ phase: "summary", saved: phase2Saved });
+    }
+    const afterTokens = this.estimateMessages(ctx.messages);
+    return { before: beforeTokens, after: afterTokens, reductions };
+  }
+  eliseOldToolResults(ctx) {
+    const messages = ctx.messages;
+    let pairCount = 0;
+    let preserveStart = messages.length;
+    for (let i = messages.length - 1; i >= 0 && pairCount < this.preserveK; i--) {
+      const m = messages[i];
+      if (!m) continue;
+      if (m.role === "user" || m.role === "assistant") {
+        pairCount++;
+        preserveStart = i;
+      }
+    }
+    let saved = 0;
+    for (let i = 0; i < preserveStart; i++) {
+      const msg = messages[i];
+      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);
+        if (tokens < this.eliseThreshold) return b;
+        saved += tokens;
+        const elided = {
+          type: "tool_result",
+          tool_use_id: b.tool_use_id,
+          content: `[elided: ~${tokens} tokens removed. Call the tool again if needed.]`,
+          is_error: b.is_error
+        };
+        return elided;
+      });
+      messages[i] = { ...msg, content: newContent };
+    }
+    return saved;
+  }
+  collapseAncientTurns(ctx) {
+    const messages = ctx.messages;
+    const cutTarget = Math.max(0, messages.length - this.preserveK * 2);
+    if (cutTarget <= 0) return 0;
+    let boundary = -1;
+    for (let i = cutTarget; i < messages.length; i++) {
+      const m = messages[i];
+      if (!m) continue;
+      if (m.role === "user" && hasTextContent(m)) {
+        boundary = i;
+        break;
+      }
+    }
+    if (boundary <= 0) return 0;
+    const removed = messages.slice(0, boundary);
+    const removedTokens = this.estimateMessages(removed);
+    const summary = [
+      {
+        role: "user",
+        content: `[previous_session_summary: ${removed.length} earlier turns compacted. Todo state preserved in context.]`
+      },
+      { role: "assistant", content: "Continuing from compacted context." }
+    ];
+    ctx.messages.splice(0, boundary, ...summary);
+    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);
+      } 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)
+            );
+          }
+        }
+      }
+    }
+    return total;
+  }
+};
+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) {
+  return b.type === "text";
+}
+
+// src/defaults/intelligent-compactor.ts
+var IntelligentCompactor = class {
+  provider;
+  warnThreshold;
+  softThreshold;
+  hardThreshold;
+  maxContext;
+  preserveK;
+  eliseThreshold;
+  summarizerPrompt;
+  summarizerModel;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.warnThreshold = opts.warnThreshold ?? 0.6;
+    this.softThreshold = opts.softThreshold ?? 0.75;
+    this.hardThreshold = opts.hardThreshold ?? 0.9;
+    this.maxContext = opts.maxContext ?? 128e3;
+    this.preserveK = opts.preserveK ?? 4;
+    this.eliseThreshold = opts.eliseThreshold ?? 500;
+    this.summarizerPrompt = opts.summarizerPrompt ?? "You are a context summarizer. Given a list of conversation messages, produce a concise but complete summary that preserves all factual information, decisions made, and any state changes (e.g. file edits, todo updates). Do not add commentary. Output only the summary.";
+    this.summarizerModel = opts.summarizerModel;
+  }
+  async compact(ctx, opts = {}) {
+    const beforeTokens = this.estimateTokens(ctx.messages);
+    const reductions = [];
+    const load = beforeTokens / this.maxContext;
+    const aggressive = opts.aggressive ?? load >= this.softThreshold;
+    const saved1 = this.eliseOldToolResults(ctx);
+    if (saved1 > 0) reductions.push({ phase: "elision", saved: saved1 });
+    if (aggressive) {
+      const saved2 = await this.summarizeAncientTurns(ctx);
+      if (saved2 > 0) reductions.push({ phase: "summary", saved: saved2 });
+    } else if (load >= this.warnThreshold) {
+      const saved2 = this.lightweightCompact(ctx);
+      if (saved2 > 0) reductions.push({ phase: "elision", saved: saved2 });
+    }
+    const afterTokens = this.estimateTokens(ctx.messages);
+    return { before: beforeTokens, after: afterTokens, reductions };
+  }
+  async summarizeAncientTurns(ctx) {
+    const messages = ctx.messages;
+    const cutoff = Math.max(0, messages.length - this.preserveK * 2);
+    if (cutoff <= 2) return 0;
+    const boundary = this.findSafeBoundary(messages, 0, cutoff);
+    if (boundary <= 1) return 0;
+    const toSummarize = messages.slice(0, boundary);
+    const removedTokens = this.estimateTokens(toSummarize);
+    let summaryText;
+    try {
+      summaryText = await this.callSummarizer(toSummarize, ctx);
+    } catch {
+      summaryText = `[${toSummarize.length} earlier turns omitted \u2014 key decisions and file states preserved in context]`;
+    }
+    const summaryMsg = {
+      role: "system",
+      content: `[prior_turns_summary: ${summaryText}]`
+    };
+    const summaryTokens = this.estimateTokens([summaryMsg]);
+    ctx.messages.splice(0, boundary, summaryMsg);
+    return Math.max(0, removedTokens - summaryTokens);
+  }
+  findSafeBoundary(messages, from, to) {
+    for (let i = to; i >= from; i--) {
+      const m = messages[i];
+      if (!m) continue;
+      if (m.role === "user" && this.hasTextContent(m)) {
+        return this.findExchangeStart(messages, i);
+      }
+    }
+    return -1;
+  }
+  findExchangeStart(messages, userIndex) {
+    for (let i = userIndex - 1; i >= 0; i--) {
+      const m = messages[i];
+      if (!m) continue;
+      if (m.role === "assistant") {
+        const hasToolUse = Array.isArray(m.content) ? m.content.some((b) => b.type === "tool_use") : false;
+        if (!hasToolUse) {
+          return i + 1;
+        }
+      } else if (m.role !== "user") ; else {
+        return i;
+      }
+    }
+    return 0;
+  }
+  async callSummarizer(messages, ctx) {
+    const prompt = [
+      { type: "text", text: this.summarizerPrompt },
+      { type: "text", text: "\n\nConversation to summarize:\n" },
+      ...this.messagesToText(messages)
+    ];
+    const req = {
+      model: this.summarizerModel ?? ctx.model,
+      system: prompt,
+      messages: [],
+      maxTokens: 1024
+    };
+    const signal = ctx.signal ?? new AbortController().signal;
+    const res = await this.provider.complete(req, { signal });
+    const textBlocks = res.content.filter(isTextBlock);
+    return textBlocks.map((b) => b.text).join("\n").trim() || "(empty summary)";
+  }
+  messagesToText(messages) {
+    const lines = [];
+    for (const m of messages) {
+      const role = m.role.padEnd(10, " ");
+      if (typeof m.content === "string") {
+        lines.push(`[${role}]: ${m.content.slice(0, 500)}`);
+      } else if (Array.isArray(m.content)) {
+        const textParts = m.content.filter(isTextBlock).map((b) => b.text);
+        if (textParts.length > 0) {
+          lines.push(`[${role}]: ${textParts.join(" ").slice(0, 500)}`);
+        }
+      }
+    }
+    return [{ type: "text", text: lines.join("\n") }];
+  }
+  lightweightCompact(ctx) {
+    return this.eliseOldToolResults(ctx);
+  }
+  eliseOldToolResults(ctx) {
+    const messages = ctx.messages;
+    let pairCount = 0;
+    let preserveStart = messages.length;
+    for (let i = messages.length - 1; i >= 0 && pairCount < this.preserveK; i--) {
+      const m = messages[i];
+      if (!m) continue;
+      if (m.role === "user" || m.role === "assistant") {
+        pairCount++;
+        preserveStart = i;
+      }
+    }
+    let saved = 0;
+    for (let i = 0; i < preserveStart; i++) {
+      const msg = messages[i];
+      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);
+        if (tokens < this.eliseThreshold) return b;
+        saved += tokens;
+        return {
+          type: "tool_result",
+          tool_use_id: b.tool_use_id,
+          content: `[elided: ~${tokens} tokens]`,
+          is_error: b.is_error
+        };
+      });
+      messages[i] = { ...msg, content: newContent };
+    }
+    return saved;
+  }
+  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);
+  }
+  estimateTokens(messages) {
+    let total = 0;
+    for (const m of messages) {
+      if (typeof m.content === "string") {
+        total += this.roughTokenEstimate(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)
+            );
+          }
+        }
+      }
+    }
+    return total;
+  }
+  roughTokenEstimate(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+  }
+};
+
+// src/defaults/llm-selector.ts
+var DEFAULT_SYSTEM_PROMPT = `You are a context pruning assistant. Given a conversation history and a token budget, decide which message ranges are worth keeping verbatim and which should be collapsed into summaries.
+
+Output a JSON object with this structure:
+{
+  "kept": [{"from": 0, "to": 5, "importance": "critical"}],
+  "collapsed": [{"from": 6, "to": 20, "summary": "optional summary"}],
+  "reasoning": "brief explanation of decisions"
+}
+
+Importance tiers:
+- "critical": decisions, file edits, tool results that affect state, final answers
+- "high": substantive tool use, complex reasoning, non-obvious observations
+- "medium": routine exchanges, confirmations, straightforward Q&A
+
+Rules:
+- Always keep the most recent K pairs (preserve recency)
+- Never collapse the final 2 user/assistant pairs (working memory)
+- Preserve tool results that modified files or had external effects
+- Collapse old, low-information exchanges (greetings, acknowledgements, etc.)
+- If unsure, keep rather than collapse (errors are more costly than waste)
+
+Return ONLY the JSON object, no markdown, no explanation outside the JSON.`;
+function estimateTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      total += Math.ceil(m.content.length / 4);
+    } else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === "text") total += Math.ceil(b.text.length / 4);
+        else total += Math.ceil(JSON.stringify(b).length / 4);
+      }
+    }
+  }
+  return total;
+}
+function formatMessages(messages, maxChars = 8e3) {
+  const lines = [];
+  let used = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    const role = m.role.padEnd(10, " ");
+    let text;
+    if (typeof m.content === "string") {
+      text = m.content.slice(0, 500);
+    } else {
+      const content = m.content;
+      text = content.filter(isTextBlock).map((b) => b.text).join(" ");
+      const toolUses = content.filter((b) => b.type === "tool_use");
+      if (toolUses.length > 0) {
+        text += ` [tools: ${toolUses.map((b) => b.name).join(", ")}]`;
+      }
+    }
+    const line = `[${i}][${role}]: ${text}`;
+    if (used + line.length > maxChars) break;
+    lines.push(line);
+    used += line.length;
+  }
+  return lines.join("\n");
+}
+var LLMSelector = class {
+  provider;
+  model;
+  maxContextTokens;
+  systemPrompt;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.model = opts.model ?? "unknown";
+    this.maxContextTokens = opts.maxContextTokens ?? 4e4;
+    this.systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+  }
+  async select(messages, maxToKeep) {
+    const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
+    const historyText = formatMessages(messages);
+    const totalTokens = estimateTokens(messages);
+    const systemText = `${this.systemPrompt}
+
+Conversation (${messages.length} messages, ~${totalTokens} tokens, budget: ${effectiveBudget}):
+`;
+    const budgetInstruction = totalTokens > effectiveBudget ? `
+
+IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiveBudget}). You MUST collapse enough to fit. Prefer collapsing older/lower-importance ranges.` : "";
+    const req = {
+      model: this.model,
+      system: [{ type: "text", text: systemText + budgetInstruction }],
+      messages: [{ role: "user", content: historyText }],
+      maxTokens: 1024
+    };
+    let raw;
+    try {
+      const res = await this.provider.complete(req, { signal: new AbortController().signal });
+      const textBlocks = res.content.filter(isTextBlock);
+      raw = textBlocks.map((b) => b.text).join("\n").trim();
+    } catch (err) {
+      return this.fallbackSelect(messages, effectiveBudget);
+    }
+    return this.parseSelectorOutput(raw, messages.length);
+  }
+  fallbackSelect(messages, budget) {
+    const toKeep = [];
+    const toCollapse = [];
+    let tokenCount = 0;
+    let startIdx = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i];
+      const cost = typeof m.content === "string" ? Math.ceil(m.content.length / 4) : m.content.reduce((acc, b) => acc + (b.type === "text" ? Math.ceil(b.text.length / 4) : Math.ceil(JSON.stringify(b).length / 4)), 0);
+      if (tokenCount + cost <= budget) {
+        tokenCount += cost;
+      } else {
+        startIdx = i + 1;
+        break;
+      }
+    }
+    if (startIdx > 0) {
+      toCollapse.push({ from: 0, to: startIdx - 1 });
+    }
+    toKeep.push({ from: startIdx, to: messages.length - 1, importance: "high" });
+    return {
+      kept: toKeep,
+      collapsed: toCollapse,
+      reasoning: `Fallback: kept last ${messages.length - startIdx} messages within ${budget} token budget`
+    };
+  }
+  parseSelectorOutput(raw, messageCount) {
+    const jsonStart = raw.indexOf("{");
+    const jsonEnd = raw.lastIndexOf("}");
+    if (jsonStart === -1 || jsonEnd === -1) {
+      return this.fallbackSelect(
+        Array.from({ length: messageCount }, (_, i) => ({ role: "user", content: "" })),
+        this.maxContextTokens
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw.slice(jsonStart, jsonEnd + 1));
+    } catch {
+      return this.fallbackSelect(
+        Array.from({ length: messageCount }, (_, i) => ({ role: "user", content: "" })),
+        this.maxContextTokens
+      );
+    }
+    const obj = parsed;
+    const kept = obj.kept ?? [];
+    const collapsed = obj.collapsed ?? [];
+    return {
+      kept: kept.map((k) => ({ from: k.from, to: k.to, importance: k.importance ?? "medium" })),
+      collapsed: collapsed.map((c) => ({ from: c.from, to: c.to, summary: c.summary })),
+      reasoning: typeof obj.reasoning === "string" ? obj.reasoning : ""
+    };
+  }
+};
+
+// src/defaults/selective-compactor.ts
+var SelectiveCompactor = class {
+  provider;
+  selector;
+  warnThreshold;
+  softThreshold;
+  hardThreshold;
+  maxContext;
+  preserveK;
+  eliseThreshold;
+  summarizerModel;
+  summarizerPrompt;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel });
+    this.warnThreshold = opts.warnThreshold ?? 0.6;
+    this.softThreshold = opts.softThreshold ?? 0.75;
+    this.hardThreshold = opts.hardThreshold ?? 0.9;
+    this.maxContext = opts.maxContext ?? 128e3;
+    this.preserveK = opts.preserveK ?? 4;
+    this.eliseThreshold = opts.eliseThreshold ?? 500;
+    this.summarizerModel = opts.summarizerModel ?? opts.selectorModel ?? "unknown";
+    this.summarizerPrompt = opts.summarizerPrompt ?? "You are a context summarizer. Given a list of messages, produce a concise summary that preserves all factual information, decisions, file changes, and state changes. Do not add commentary or opinions.";
+  }
+  async compact(ctx, opts = {}) {
+    const beforeTokens = this.estimateTokens(ctx.messages);
+    const reductions = [];
+    const load = beforeTokens / this.maxContext;
+    const shouldCompact = load >= this.warnThreshold || opts.aggressive;
+    if (!shouldCompact) {
+      const saved = this.eliseOldToolResults(ctx);
+      if (saved > 0) reductions.push({ phase: "elision", saved });
+      const afterTokens2 = this.estimateTokens(ctx.messages);
+      return { before: beforeTokens, after: afterTokens2, reductions };
+    }
+    const savedElision = this.eliseOldToolResults(ctx);
+    if (savedElision > 0) reductions.push({ phase: "elision", saved: savedElision });
+    const afterPhase1 = this.estimateTokens(ctx.messages);
+    const targetBudget = this.computeTargetBudget(load, opts.aggressive ?? false);
+    if (afterPhase1 > targetBudget) {
+      const savedSelective = await this.runSelector(ctx, targetBudget);
+      if (savedSelective > 0) reductions.push({ phase: "selective", saved: savedSelective });
+    }
+    const afterTokens = this.estimateTokens(ctx.messages);
+    return { before: beforeTokens, after: afterTokens, reductions };
+  }
+  /**
+   * Run the LLM selector to decide what to keep vs collapse.
+   * Returns the token savings achieved.
+   */
+  async runSelector(ctx, targetBudget) {
+    const before = this.estimateTokens(ctx.messages);
+    let result;
+    try {
+      result = await this.selector.select(ctx.messages, targetBudget);
+    } catch {
+      return this.aggressiveRecencyTrim(ctx, targetBudget);
+    }
+    await this.executePlan(ctx, result);
+    const after = this.estimateTokens(ctx.messages);
+    return Math.max(0, before - after);
+  }
+  /**
+   * Execute a SelectorResult plan: collapse/remove ranges and
+   * insert summaries where the selector provided them.
+   */
+  async executePlan(ctx, plan) {
+    const messages = ctx.messages;
+    if (messages.length === 0) return;
+    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;
+      let summary = range.summary;
+      if (!summary) {
+        const toSummarize = messages.slice(range.from, range.to + 1);
+        summary = await this.summarizeRange(toSummarize, ctx);
+      }
+      const summaryMsg = {
+        role: "system",
+        content: `[prior_turns_${range.from}-${range.to}: ${summary}]`
+      };
+      messages.splice(range.from, range.to - range.from + 1, summaryMsg);
+    }
+  }
+  async summarizeRange(messages, ctx) {
+    const systemText = `${this.summarizerPrompt}
+
+Summarize the following message range:`;
+    const body = messages.map((m, i) => `[${i}] ${m.role}: ${this.messagePreview(m)}`).join("\n");
+    const req = {
+      model: this.summarizerModel,
+      system: [{ type: "text", text: systemText }],
+      messages: [{ role: "user", content: body }],
+      maxTokens: 512
+    };
+    try {
+      const res = await this.provider.complete(req, { signal: ctx.signal ?? new AbortController().signal });
+      return res.content.filter(isTextBlock).map((b) => b.text).join("\n").trim() || "(empty)";
+    } catch {
+      return `[${messages.length} earlier turns omitted]`;
+    }
+  }
+  messagePreview(m) {
+    if (typeof m.content === "string") return m.content.slice(0, 300);
+    return m.content.filter(isTextBlock).map((b) => b.text).join(" ").slice(0, 300);
+  }
+  /**
+   * Fallback when selector fails: aggressively trim from the oldest end
+   * until we hit targetBudget.
+   */
+  aggressiveRecencyTrim(ctx, targetBudget) {
+    const messages = ctx.messages;
+    this.estimateTokens(messages);
+    const preserveIdx = Math.max(0, messages.length - this.preserveK * 2);
+    if (preserveIdx <= 0) return 0;
+    let boundary = preserveIdx;
+    for (let i = preserveIdx; i < messages.length && i < preserveIdx + 6; i++) {
+      const m = messages[i];
+      if (m.role === "user" && this.hasTextContent(m)) {
+        boundary = i;
+        break;
+      }
+    }
+    const removed = messages.slice(0, boundary);
+    const removedTokens = this.estimateTokens(removed);
+    const summaryMsg = {
+      role: "system",
+      content: `[${removed.length} earlier turns trimmed \u2014 see session log for details]`
+    };
+    messages.splice(0, boundary, summaryMsg);
+    return Math.max(0, removedTokens - this.estimateTokens([summaryMsg]));
+  }
+  computeTargetBudget(load, aggressive) {
+    if (load >= this.hardThreshold) {
+      return Math.floor(this.maxContext * 0.5);
+    }
+    if (load >= this.softThreshold) {
+      return Math.floor(this.maxContext * 0.65);
+    }
+    return Math.floor(this.maxContext * 0.75);
+  }
+  eliseOldToolResults(ctx) {
+    const messages = ctx.messages;
+    let pairCount = 0;
+    let preserveStart = messages.length;
+    for (let i = messages.length - 1; i >= 0 && pairCount < this.preserveK; i--) {
+      const m = messages[i];
+      if (!m) continue;
+      if (m.role === "user" || m.role === "assistant") {
+        pairCount++;
+        preserveStart = i;
+      }
+    }
+    let saved = 0;
+    for (let i = 0; i < preserveStart; i++) {
+      const msg = messages[i];
+      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);
+        if (tokens < this.eliseThreshold) return b;
+        saved += tokens;
+        return {
+          type: "tool_result",
+          tool_use_id: b.tool_use_id,
+          content: `[elided: ~${tokens} tokens]`,
+          is_error: b.is_error
+        };
+      });
+      messages[i] = { ...msg, content: newContent };
+    }
+    return saved;
+  }
+  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);
+  }
+  estimateTokens(messages) {
+    let total = 0;
+    for (const m of messages) {
+      if (typeof m.content === "string") {
+        total += this.roughTokenEstimate(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)
+            );
+          }
+        }
+      }
+    }
+    return total;
+  }
+  roughTokenEstimate(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+  }
+};
+
+// src/defaults/auto-compaction-middleware.ts
+var AutoCompactionMiddleware = class {
+  name = "AutoCompaction";
+  compactor;
+  warnThreshold;
+  // fraction of maxContext (0-1)
+  softThreshold;
+  hardThreshold;
+  maxContext;
+  estimator;
+  aggressiveOn;
+  /**
+   * @param compactor        Compactor to use for compaction
+   * @param maxContext       Provider's max context window in tokens
+   * @param estimator        Token estimation function (ctx → token count)
+   * @param thresholds      Threshold fractions (0-1) of maxContext
+   * @param aggressiveOn    Which threshold triggers aggressive (full LLM summarization)
+   */
+  constructor(compactor, maxContext, estimator, thresholds, aggressiveOn = "soft") {
+    this.compactor = compactor;
+    this.maxContext = maxContext;
+    this.estimator = estimator;
+    this.warnThreshold = thresholds.warn;
+    this.softThreshold = thresholds.soft;
+    this.hardThreshold = thresholds.hard;
+    this.aggressiveOn = aggressiveOn;
+  }
+  handler() {
+    return async (ctx, next) => {
+      const tokens = this.estimator(ctx);
+      const load = tokens / this.maxContext;
+      if (load >= this.hardThreshold) {
+        await this.compact(ctx, true);
+      } else if (load >= this.softThreshold) {
+        await this.compact(ctx, this.aggressiveOn !== "hard");
+      } else if (load >= this.warnThreshold) {
+        await this.compact(ctx, false);
+      }
+      return next(ctx);
+    };
+  }
+  async compact(ctx, aggressive) {
+    try {
+      await this.compactor.compact(ctx, { aggressive });
+    } catch {
+    }
+  }
+};
+var DEFAULT_URL = "https://models.dev/api.json";
+var DEFAULT_TTL_SECONDS = 24 * 3600;
+var FAMILY_BY_NPM = {
+  "@ai-sdk/anthropic": "anthropic",
+  "@ai-sdk/google-vertex/anthropic": "anthropic",
+  "@ai-sdk/openai": "openai",
+  "@ai-sdk/openai-compatible": "openai-compatible",
+  "@ai-sdk/groq": "openai-compatible",
+  "@ai-sdk/xai": "openai-compatible",
+  "@ai-sdk/cerebras": "openai-compatible",
+  "@ai-sdk/togetherai": "openai-compatible",
+  "@ai-sdk/perplexity": "openai-compatible",
+  "@ai-sdk/deepinfra": "openai-compatible",
+  "@openrouter/ai-sdk-provider": "openai-compatible",
+  "ai-gateway-provider": "openai-compatible",
+  "@ai-sdk/vercel": "openai-compatible",
+  "@ai-sdk/gateway": "openai-compatible",
+  "@aihubmix/ai-sdk-provider": "openai-compatible",
+  "venice-ai-sdk-provider": "openai-compatible",
+  "@ai-sdk/google": "google"
+};
+function classifyFamily(npm) {
+  if (!npm) return "unsupported";
+  return FAMILY_BY_NPM[npm] ?? "unsupported";
+}
+var DefaultModelsRegistry = class {
+  payload;
+  fetchedAt;
+  cacheFile;
+  url;
+  ttlMs;
+  fetchImpl;
+  seed;
+  maxStaleAgeMs;
+  constructor(opts) {
+    this.cacheFile = opts.cacheFile;
+    this.url = opts.url ?? DEFAULT_URL;
+    this.ttlMs = (opts.ttlSeconds ?? DEFAULT_TTL_SECONDS) * 1e3;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.seed = opts.seed;
+    const maxStaleSeconds = opts.maxStaleAgeSeconds ?? 7 * 24 * 3600;
+    this.maxStaleAgeMs = maxStaleSeconds * 1e3;
+  }
+  async load(opts = {}) {
+    if (this.payload && !opts.force) return this.payload;
+    if (this.seed) {
+      this.payload = this.seed;
+      this.fetchedAt = /* @__PURE__ */ new Date();
+      return this.payload;
+    }
+    if (!opts.force) {
+      const cached = await this.readCache();
+      if (cached && this.isFresh(cached.fetchedAt)) {
+        this.payload = cached.payload;
+        this.fetchedAt = new Date(cached.fetchedAt);
+        return cached.payload;
+      }
+    }
+    try {
+      return await this.refresh();
+    } catch (err) {
+      const cached = await this.readCache();
+      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
+        this.payload = cached.payload;
+        this.fetchedAt = new Date(cached.fetchedAt);
+        return cached.payload;
+      }
+      throw err;
+    }
+  }
+  async refresh() {
+    const res = await this.fetchImpl(this.url, {
+      method: "GET",
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) {
+      throw new Error(`ModelsRegistry: HTTP ${res.status} fetching ${this.url}`);
+    }
+    const json = await res.json();
+    this.payload = json;
+    this.fetchedAt = /* @__PURE__ */ new Date();
+    const envelope = {
+      fetchedAt: this.fetchedAt.toISOString(),
+      url: this.url,
+      payload: json
+    };
+    await atomicWrite(this.cacheFile, JSON.stringify(envelope));
+    return json;
+  }
+  async listProviders() {
+    const payload = await this.load();
+    return Object.values(payload).map((p) => this.resolveProvider(p));
+  }
+  async getProvider(id) {
+    const payload = await this.load();
+    const p = payload[id];
+    return p ? this.resolveProvider(p) : void 0;
+  }
+  async getModel(providerId, modelId) {
+    const provider = await this.getProvider(providerId);
+    if (!provider) return void 0;
+    const model = provider.models.find((m) => m.id === modelId);
+    if (!model) return void 0;
+    return {
+      providerId,
+      modelId,
+      capabilities: {
+        tools: model.tool_call ?? false,
+        vision: Boolean(model.modalities?.input?.includes("image")),
+        reasoning: model.reasoning ?? false,
+        maxContext: model.limit?.context ?? 0,
+        maxOutput: model.limit?.output,
+        knowledge: model.knowledge
+      },
+      cost: model.cost
+    };
+  }
+  async suggestModel(providerId) {
+    const provider = await this.getProvider(providerId);
+    if (!provider || provider.models.length === 0) return void 0;
+    const ranked = [...provider.models].sort((a, b) => {
+      const at = a.release_date ?? a.last_updated ?? "";
+      const bt = b.release_date ?? b.last_updated ?? "";
+      return bt.localeCompare(at);
+    });
+    return ranked[0]?.id;
+  }
+  async ageSeconds() {
+    if (!this.fetchedAt) {
+      const cached = await this.readCache();
+      if (!cached) return Number.POSITIVE_INFINITY;
+      return (Date.now() - new Date(cached.fetchedAt).getTime()) / 1e3;
+    }
+    return (Date.now() - this.fetchedAt.getTime()) / 1e3;
+  }
+  resolveProvider(p) {
+    return {
+      id: p.id,
+      name: p.name,
+      family: classifyFamily(p.npm),
+      apiBase: p.api,
+      envVars: p.env ?? [],
+      doc: p.doc,
+      models: Object.values(p.models ?? {}),
+      npm: p.npm
+    };
+  }
+  isFresh(fetchedAtIso) {
+    return Date.now() - new Date(fetchedAtIso).getTime() < this.ttlMs;
+  }
+  isWithinMaxStaleAge(fetchedAtIso) {
+    return Date.now() - new Date(fetchedAtIso).getTime() < this.maxStaleAgeMs;
+  }
+  async readCache() {
+    try {
+      const raw = await fsp.readFile(this.cacheFile, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Used by `wstack models refresh` to expose where the cache lives. */
+  cacheLocation() {
+    return path2.resolve(this.cacheFile);
+  }
+};
+
+// src/types/mode.ts
+var DEFAULT_MODES = [
+  {
+    id: "default",
+    name: "Default",
+    description: "General-purpose coding assistant",
+    prompt: "",
+    tags: ["general"]
+  },
+  {
+    id: "code-reviewer",
+    name: "Code Reviewer",
+    description: "Focus on code quality, best practices, and potential bugs",
+    prompt: `## Code Reviewer Mode
+
+When reviewing code:
+- Look for potential bugs, race conditions, and edge cases
+- Check for security vulnerabilities (SQL injection, XSS, CSRF, etc.)
+- Evaluate error handling completeness
+- Assess code readability and maintainability
+- Check for performance anti-patterns
+- Verify test coverage for critical paths
+- Ensure naming conventions are followed`,
+    tags: ["review", "quality", "security"],
+    toolPreferences: ["read", "grep", "git", "diff", "test"]
+  },
+  {
+    id: "code-auditor",
+    name: "Code Auditor",
+    description: "Security-focused code analysis",
+    prompt: `## Code Auditor Mode
+
+When auditing code for security:
+- Identify injection vulnerabilities (SQL, Command, XSS, LDAP)
+- Check authentication and authorization patterns
+- Look for sensitive data exposure (secrets, PII in logs)
+- Verify cryptographic implementations
+- Check for insecure dependencies or configurations
+- Assess input validation and output encoding
+- Look for timing attacks and information leakage`,
+    tags: ["security", "audit", "compliance"],
+    toolPreferences: ["grep", "read", "audit", "bash"]
+  },
+  {
+    id: "architect",
+    name: "Software Architect",
+    description: "Design patterns, scalability, and system design",
+    prompt: `## Architect Mode
+
+When designing or reviewing architecture:
+- Evaluate scalability and future growth
+- Check for appropriate design patterns
+- Assess coupling and cohesion
+- Look forSOLID principle violations
+- Evaluate data modeling decisions
+- Check for eventual consistency issues
+- Assess API design and contract stability
+- Consider operational aspects (monitoring, logging, deployment)`,
+    tags: ["architecture", "design", "scalability"],
+    toolPreferences: ["read", "glob", "tree", "diff"]
+  },
+  {
+    id: "debugger",
+    name: "Debugger",
+    description: "Root cause analysis and error investigation",
+    prompt: `## Debugger Mode
+
+When investigating bugs:
+- Reproduce the issue with minimal steps
+- Check error messages and stack traces thoroughly
+- Look for related logs and historical context
+- Verify assumptions about data flow
+- Check for race conditions in async code
+- Validate environment and configuration
+- Use binary search to isolate the root cause
+- Verify fixes with tests before considering done`,
+    tags: ["debug", "investigation", "error-resolution"],
+    toolPreferences: ["read", "grep", "bash", "logs", "test"]
+  },
+  {
+    id: "tester",
+    name: "QA Engineer",
+    description: "Test coverage, edge cases, and quality assurance",
+    prompt: `## Tester Mode
+
+When testing or writing tests:
+- Cover happy path and error paths equally
+- Think about edge cases and boundary conditions
+- Check for missing null/undefined handling tests
+- Verify error messages are tested
+- Look for race condition tests in async code
+- Assess mutation testing opportunities
+- Check for integration test gaps
+- Verify test isolation and cleanup`,
+    tags: ["testing", "qa", "quality"],
+    toolPreferences: ["read", "grep", "test", "bash"]
+  },
+  {
+    id: "devops",
+    name: "DevOps Engineer",
+    description: "Infrastructure, deployment, and operations",
+    prompt: `## DevOps Mode
+
+When working on infrastructure:
+- Check for containerization and deployment readiness
+- Verify CI/CD pipeline configurations
+- Assess monitoring and alerting setup
+- Look for health check endpoints
+- Check for graceful shutdown handling
+- Verify backup and disaster recovery plans
+- Assess secrets management
+- Check for resource limits and quotas`,
+    tags: ["devops", "infrastructure", "operations"],
+    toolPreferences: ["read", "bash", "grep", "logs", "git"]
+  },
+  {
+    id: "refactorer",
+    name: "Refactorer",
+    description: "Code improvement and modernization",
+    prompt: `## Refactorer Mode
+
+When refactoring code:
+- Maintain existing behavior \u2014 tests must pass before and after
+- Make one change at a time, verify after each
+- Prefer small, focused commits
+- Preserve API contracts unless explicitly changing
+- Remove dead code and comments
+- Improve naming as you go
+- Don't mix formatting changes with logic changes
+- Keep performance in mind \u2014 don't regress`,
+    tags: ["refactor", "modernization", "improvement"],
+    toolPreferences: ["read", "edit", "test", "git", "grep"]
+  }
+];
+
+// src/defaults/mode-store.ts
+var DefaultModeStore = class {
+  activeModeId = null;
+  modes;
+  configDir;
+  constructor(config) {
+    this.configDir = config.directory;
+    this.modes = [...DEFAULT_MODES];
+  }
+  async getActiveMode() {
+    if (!this.activeModeId) {
+      await this.loadActiveMode();
+    }
+    if (!this.activeModeId) return null;
+    return this.modes.find((m) => m.id === this.activeModeId) ?? null;
+  }
+  async setActiveMode(modeId) {
+    this.activeModeId = modeId;
+    await this.saveActiveMode();
+  }
+  async listModes() {
+    return [...this.modes];
+  }
+  async getMode(modeId) {
+    return this.modes.find((m) => m.id === modeId) ?? null;
+  }
+  async addMode(mode) {
+    const idx = this.modes.findIndex((m) => m.id === mode.id);
+    if (idx >= 0) {
+      this.modes[idx] = mode;
+    } else {
+      this.modes.push(mode);
+    }
+  }
+  async removeMode(modeId) {
+    const builtIn = DEFAULT_MODES.find((m) => m.id === modeId);
+    if (builtIn) {
+      throw new Error(`Cannot remove built-in mode "${modeId}"`);
+    }
+    this.modes = this.modes.filter((m) => m.id !== modeId);
+    if (this.activeModeId === modeId) {
+      this.activeModeId = null;
+      await this.saveActiveMode();
+    }
+  }
+  async loadActiveMode() {
+    try {
+      const configPath = path2.join(this.configDir, "mode.json");
+      const content = await fsp.readFile(configPath, "utf8");
+      const data = JSON.parse(content);
+      this.activeModeId = data.activeMode ?? null;
+    } catch {
+      this.activeModeId = "default";
+    }
+  }
+  async saveActiveMode() {
+    try {
+      await fsp.mkdir(this.configDir, { recursive: true });
+      const configPath = path2.join(this.configDir, "mode.json");
+      await fsp.writeFile(
+        configPath,
+        JSON.stringify({ activeMode: this.activeModeId }, null, 2),
+        "utf8"
+      );
+    } catch {
+    }
+  }
+};
+async function loadProjectModes(modesDir) {
+  const modes = [];
+  try {
+    const entries = await fsp.readdir(modesDir);
+    for (const entry of entries) {
+      if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
+      const filePath = path2.join(modesDir, entry);
+      const stat4 = await fsp.stat(filePath);
+      if (!stat4.isFile()) continue;
+      const content = await fsp.readFile(filePath, "utf8");
+      const id = path2.basename(entry, path2.extname(entry));
+      modes.push({
+        id,
+        name: id.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+        description: content.split("\n")[0] ?? id,
+        prompt: content,
+        tags: ["project"]
+      });
+    }
+  } catch {
+  }
+  return modes;
+}
+async function loadUserModes(modesDir) {
+  const modes = [];
+  try {
+    const manifestPath = path2.join(modesDir, "modes.json");
+    const content = await fsp.readFile(manifestPath, "utf8");
+    const manifest = JSON.parse(content);
+    for (const mode of manifest.modes) {
+      modes.push(mode);
+    }
+  } catch {
+  }
+  return modes;
+}
+var DefaultMultiAgentCoordinator = class extends EventEmitter {
+  coordinatorId;
+  config;
+  subagents = /* @__PURE__ */ new Map();
+  pendingTasks = [];
+  completedResults = [];
+  totalIterations = 0;
+  constructor(config) {
+    super();
+    this.coordinatorId = config.coordinatorId;
+    this.config = config;
+  }
+  async spawn(subagent) {
+    const id = subagent.id || randomUUID();
+    const context = {
+      subagentId: id,
+      tasks: [],
+      parentBridge: null,
+      doneCondition: this.config.doneCondition,
+      maxConcurrent: this.config.maxConcurrent ?? 4
+    };
+    this.subagents.set(id, {
+      config: subagent,
+      context,
+      status: "idle"
+    });
+    this.emit("subagent.started", { subagent: { ...subagent, id } });
+    return {
+      subagentId: id,
+      agentId: id
+    };
+  }
+  async assign(task) {
+    this.pendingTasks.push(task);
+    const available = this.getAvailableSubagent();
+    if (available) {
+      await this.dispatch(available, task);
+    }
+  }
+  async delegate(to, msg) {
+    const subagent = this.subagents.get(to);
+    if (!subagent) throw new Error(`Subagent "${to}" not found`);
+    if (!subagent.context.parentBridge) {
+      throw new Error(`Subagent "${to}" has no parentBridge \u2014 call setSubagentBridge() first`);
+    }
+    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.
+   */
+  setSubagentBridge(subagentId, bridge) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) throw new Error(`Subagent "${subagentId}" not found`);
+    subagent.context.parentBridge = bridge;
+  }
+  async stop(subagentId) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) return;
+    subagent.status = "stopped";
+    subagent.currentTask = void 0;
+    subagent.context.parentBridge = null;
+    this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
+  }
+  async stopAll() {
+    for (const id of this.subagents.keys()) {
+      await this.stop(id);
+    }
+  }
+  getStatus() {
+    return {
+      coordinatorId: this.coordinatorId,
+      subagents: Array.from(this.subagents.entries()).map(([id, s]) => ({
+        id,
+        name: s.config.name,
+        status: s.status,
+        currentTask: s.currentTask
+      })),
+      pendingTasks: this.pendingTasks.length,
+      completedTasks: this.completedResults.length,
+      totalIterations: this.totalIterations,
+      done: this.isDone()
+    };
+  }
+  getAvailableSubagent() {
+    for (const [id, s] of this.subagents) {
+      if (s.status === "idle") return id;
+    }
+    return null;
+  }
+  async dispatch(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 });
+      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");
+    }
+    if (this.config.doneCondition.maxIterations && this.totalIterations >= this.config.doneCondition.maxIterations) {
+      return true;
+    }
+    return false;
+  }
+  completeTask(result) {
+    this.completedResults.push(result);
+    this.totalIterations += result.iterations;
+    const subagent = this.subagents.get(result.subagentId);
+    if (subagent) {
+      subagent.status = "idle";
+      subagent.currentTask = void 0;
+    }
+    this.emit("task.completed", {
+      task: this.pendingTasks.shift(),
+      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.emit("done", {
+        results: this.completedResults,
+        totalIterations: this.totalIterations
+      });
+    }
+  }
+};
+var InMemoryBridgeTransport = class {
+  subs = /* @__PURE__ */ new Map();
+  send(msg, to) {
+    const handlers = this.subs.get(to);
+    if (handlers) {
+      for (const h of handlers) {
+        try {
+          h(msg);
+        } catch {
+        }
+      }
+    }
+    return Promise.resolve();
+  }
+  subscribe(agentId, handler) {
+    if (!this.subs.has(agentId)) this.subs.set(agentId, /* @__PURE__ */ new Set());
+    this.subs.get(agentId).add(handler);
+    return () => this.subs.get(agentId)?.delete(handler);
+  }
+  close(agentId) {
+    this.subs.delete(agentId);
+    return Promise.resolve();
+  }
+};
+var InMemoryAgentBridge = class {
+  agentId;
+  coordinatorId;
+  transport;
+  subscriptions = /* @__PURE__ */ new Set();
+  pendingRequests = /* @__PURE__ */ new Map();
+  stopped = false;
+  timeoutMs;
+  constructor(config, transport) {
+    this.agentId = config.agentId;
+    this.coordinatorId = config.coordinatorId;
+    this.transport = transport;
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+    this.transport.subscribe(this.agentId, (msg) => {
+      if (msg.type === "heartbeat") return;
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(msg.id);
+        pending.resolve(msg);
+        return;
+      }
+      for (const h of this.subscriptions) {
+        try {
+          h(msg);
+        } catch {
+        }
+      }
+    });
+  }
+  async send(msg) {
+    msg.timestamp = Date.now();
+    await this.transport.send(msg, msg.to ?? this.coordinatorId);
+  }
+  async broadcast(msg) {
+    msg.timestamp = Date.now();
+    msg.to = "*";
+    await this.transport.send(msg, "*");
+  }
+  subscribe(handler) {
+    this.subscriptions.add(handler);
+    return () => this.subscriptions.delete(handler);
+  }
+  async request(msg, timeoutMs) {
+    if (this.stopped) throw new Error("Bridge is stopped");
+    const timeout = timeoutMs ?? this.timeoutMs;
+    const correlationId = msg.id;
+    return new Promise((resolve3, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(correlationId);
+        reject(new Error(`Request ${correlationId} timed out after ${timeout}ms`));
+      }, timeout);
+      this.pendingRequests.set(correlationId, { resolve: resolve3, reject, timer });
+      msg.timestamp = Date.now();
+      this.transport.send(msg, msg.to ?? this.coordinatorId).catch((e) => {
+        clearTimeout(timer);
+        this.pendingRequests.delete(correlationId);
+        reject(e);
+      });
+    });
+  }
+  async stop() {
+    this.stopped = true;
+    for (const [, p] of this.pendingRequests) {
+      clearTimeout(p.timer);
+    }
+    this.pendingRequests.clear();
+    this.subscriptions.clear();
+    await this.transport.close(this.agentId);
+  }
+};
+function createMessage(type, from, payload, to) {
+  return {
+    id: randomUUID(),
+    type,
+    from,
+    to,
+    payload,
+    timestamp: Date.now(),
+    priority: "normal"
+  };
+}
+
+// src/defaults/autonomous-runner.ts
+var DoneConditionChecker = class {
+  constructor(condition) {
+    this.condition = condition;
+  }
+  condition;
+  check(state) {
+    switch (this.condition.type) {
+      case "iterations":
+        if (this.condition.maxIterations && state.iterations >= this.condition.maxIterations) {
+          return { done: true, reason: `max iterations (${this.condition.maxIterations}) reached`, ...state };
+        }
+        break;
+      case "tool_calls":
+        if (this.condition.maxToolCalls && state.toolCalls >= this.condition.maxToolCalls) {
+          return { done: true, reason: `max tool calls (${this.condition.maxToolCalls}) reached`, ...state };
+        }
+        break;
+      case "output_match":
+        if (this.condition.pattern && state.lastOutput) {
+          const regex = new RegExp(this.condition.pattern);
+          if (regex.test(state.lastOutput)) {
+            return { done: true, reason: `output matched pattern "${this.condition.pattern}"`, ...state };
+          }
+        }
+        break;
+    }
+    return { done: false, iterations: state.iterations, toolCalls: state.toolCalls };
+  }
+};
+var AutonomousRunner = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.doneChecker = new DoneConditionChecker(opts.doneCondition);
+  }
+  opts;
+  iterations = 0;
+  toolCalls = 0;
+  lastOutput;
+  stopped = false;
+  doneChecker;
+  async run() {
+    while (!this.stopped) {
+      const check = this.doneChecker.check({
+        iterations: this.iterations,
+        toolCalls: this.toolCalls,
+        lastOutput: this.lastOutput
+      });
+      if (check.done) {
+        const result = {
+          status: "done",
+          iterations: this.iterations,
+          toolCalls: this.toolCalls,
+          reason: check.reason
+        };
+        this.opts.onDone?.(result);
+        return result;
+      }
+      this.opts.onIteration?.({ iteration: this.iterations, toolCalls: this.toolCalls });
+      const ctrl = new AbortController();
+      const timeout = setTimeout(() => ctrl.abort(), this.opts.iterationTimeoutMs ?? 3e4);
+      try {
+        const result = await this.opts.agent.run(
+          "",
+          { signal: ctrl.signal, maxIterations: 1, executionStrategy: "sequential" }
+        );
+        this.iterations++;
+        this.lastOutput = result.finalText;
+        this.toolCalls++;
+        if (result.status === "failed" || result.status === "aborted") {
+          const failedResult = {
+            status: result.status,
+            error: result.error,
+            iterations: this.iterations,
+            toolCalls: this.toolCalls
+          };
+          this.opts.onDone?.(failedResult);
+          return failedResult;
+        }
+      } catch (e) {
+        if (e.message.includes("timeout")) {
+          const timeoutResult = {
+            status: "failed",
+            error: e,
+            iterations: this.iterations,
+            toolCalls: this.toolCalls,
+            reason: "iteration timeout"
+          };
+          this.opts.onDone?.(timeoutResult);
+          return timeoutResult;
+        }
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    return {
+      status: "aborted",
+      iterations: this.iterations,
+      toolCalls: this.toolCalls,
+      reason: "stopped externally"
+    };
+  }
+  stop() {
+    this.stopped = true;
+  }
+};
+
+// src/defaults/spec-parser.ts
+var SpecParser = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  parse(content) {
+    const lines = content.split("\n");
+    const sections = this.extractSections(lines);
+    const requirements = this.extractRequirements(lines);
+    return {
+      id: crypto.randomUUID(),
+      title: this.extractTitle(lines),
+      version: this.extractVersion(lines),
+      status: "draft",
+      overview: this.extractOverview(lines),
+      sections,
+      requirements,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+  }
+  extractTitle(lines) {
+    for (const line of lines) {
+      const m = /^#\s+(.+)/.exec(line.trim());
+      if (m?.[1]) return m[1];
+    }
+    return "Untitled Specification";
+  }
+  extractVersion(lines) {
+    for (const line of lines) {
+      const m = /version[:\s]+(\d+\.\d+\.\d+)/i.exec(line.trim());
+      if (m?.[1]) return m[1];
+    }
+    return "0.0.1";
+  }
+  extractOverview(lines) {
+    const overviewLines = [];
+    let inOverview = false;
+    let foundHeading = false;
+    for (const line of lines) {
+      if (/^##\s+Overview/i.test(line.trim())) {
+        inOverview = true;
+        foundHeading = true;
+        continue;
+      }
+      if (foundHeading && /^##\s+/.test(line.trim())) break;
+      if (inOverview) overviewLines.push(line);
+    }
+    return overviewLines.join("\n").trim() || "No overview provided";
+  }
+  extractSections(lines) {
+    const sections = [];
+    let currentSection = null;
+    let currentLines = [];
+    let depth = 1;
+    for (const line of lines) {
+      const h2 = /^##\s+(.+)/.exec(line.trim());
+      const h3 = /^###\s+(.+)/.exec(line.trim());
+      if (h2) {
+        if (currentSection && currentLines.length > 0) {
+          sections.push({
+            type: this.mapSectionType(currentSection.title ?? "unknown"),
+            title: currentSection.title ?? "Unknown",
+            level: depth,
+            content: currentLines.join("\n").trim()
+          });
+        }
+        currentSection = { title: h2[1] ?? "Unknown" };
+        currentLines = [];
+        depth = 2;
+        continue;
+      }
+      if (h3) {
+        currentLines.push(line);
+        continue;
+      }
+      if (currentSection) {
+        currentLines.push(line);
+      }
+    }
+    if (currentSection && currentLines.length > 0) {
+      sections.push({
+        type: this.mapSectionType(currentSection.title ?? "unknown"),
+        title: currentSection.title ?? "Unknown",
+        level: depth,
+        content: currentLines.join("\n").trim()
+      });
+    }
+    return sections;
+  }
+  extractRequirements(lines) {
+    const requirements = [];
+    let inRequirements = false;
+    let idCounter = 0;
+    for (const line of lines) {
+      if (/^##\s+Requirements/i.test(line.trim())) {
+        inRequirements = true;
+        continue;
+      }
+      if (inRequirements && /^##\s+/.test(line.trim())) break;
+      if (inRequirements) {
+        const req = this.parseRequirementLine(line, `REQ-${++idCounter}`);
+        if (req) requirements.push(req);
+      }
+    }
+    return requirements;
+  }
+  parseRequirementLine(line, id) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return null;
+    const typeMap = {
+      "functional": "functional",
+      "non-functional": "non-functional",
+      "security": "security",
+      "performance": "performance",
+      "ux": "ux"
+    };
+    let type = "functional";
+    let priority = "medium";
+    for (const [key, val] of Object.entries(typeMap)) {
+      if (trimmed.toLowerCase().includes(`[${key}]`)) {
+        type = val;
+      }
+    }
+    if (trimmed.includes("[critical]") || trimmed.includes("[prio:high]")) {
+      priority = "critical";
+    } else if (trimmed.includes("[high]")) {
+      priority = "high";
+    } else if (trimmed.includes("[low]")) {
+      priority = "low";
+    }
+    return {
+      id,
+      type,
+      priority,
+      description: trimmed.replace(/\[[^\]]+\]/g, "").trim(),
+      acceptanceCriteria: []
+    };
+  }
+  mapSectionType(title) {
+    const t = title.toLowerCase();
+    if (t.includes("overview")) return "overview";
+    if (t.includes("requirement")) return "requirements";
+    if (t.includes("architect")) return "architecture";
+    if (t.includes("api")) return "api";
+    if (t.includes("data")) return "data";
+    if (t.includes("security")) return "security";
+    if (t.includes("acceptance")) return "acceptance";
+    return "overview";
+  }
+  analyze(spec) {
+    const gaps = [];
+    const suggestions = [];
+    const risks = [];
+    const hasOverview = spec.sections.some((s) => s.type === "overview");
+    const hasRequirements = spec.sections.some((s) => s.type === "requirements");
+    const hasAcceptance = spec.sections.some((s) => s.type === "acceptance");
+    if (!hasOverview) gaps.push("Missing Overview section");
+    if (!hasRequirements) gaps.push("Missing Requirements section");
+    if (!hasAcceptance) gaps.push("Missing Acceptance Criteria section");
+    if (spec.requirements.length === 0) {
+      gaps.push("No requirements defined");
+      suggestions.push("Add specific functional and non-functional requirements");
+    }
+    const unverifiedReqs = spec.requirements.filter((r) => r.acceptanceCriteria.length === 0);
+    if (unverifiedReqs.length > 0) {
+      gaps.push(`${unverifiedReqs.length} requirements without acceptance criteria`);
+      suggestions.push("Define clear acceptance criteria for each requirement");
+    }
+    const criticalUnresolved = spec.requirements.filter(
+      (r) => r.priority === "critical" && r.blockedBy && r.blockedBy.length > 0
+    );
+    for (const req of criticalUnresolved) {
+      risks.push({
+        requirement: req.id,
+        risk: `Critical requirement blocked by ${req.blockedBy?.length} other requirements`,
+        severity: "high"
+      });
+    }
+    const completeness = Math.round(
+      ((hasOverview ? 1 : 0) + (hasRequirements ? 1 : 0) + (hasAcceptance ? 1 : 0) + (spec.requirements.length > 0 ? 1 : 0) + (spec.sections.length > 3 ? 1 : 0)) / 5 * 100
+    );
+    return {
+      specId: spec.id,
+      completeness,
+      coverage: {
+        requirements: spec.requirements.length,
+        apiEndpoints: spec.apiEndpoints?.length ?? 0,
+        edgeCases: 0,
+        errorHandling: 0
+      },
+      gaps,
+      risks,
+      suggestions
+    };
+  }
+  validate(spec) {
+    const errors = [];
+    const warnings = [];
+    if (!spec.title.trim()) {
+      errors.push({ path: "title", message: "Title is required" });
+    }
+    if (!spec.version.trim()) {
+      errors.push({ path: "version", message: "Version is required" });
+    }
+    for (const req of spec.requirements) {
+      if (!req.description.trim()) {
+        errors.push({ path: `requirement.${req.id}`, message: "Requirement description is empty" });
+      }
+      if (req.acceptanceCriteria.length === 0) {
+        warnings.push({ path: `requirement.${req.id}`, message: "No acceptance criteria defined" });
+      }
+    }
+    const blockedByIds = new Set(spec.requirements.flatMap((r) => r.blockedBy ?? []));
+    for (const id of blockedByIds) {
+      if (!spec.requirements.find((r) => r.id === id)) {
+        errors.push({ path: "requirements", message: `BlockedBy references non-existent requirement: ${id}` });
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+};
+
+// src/defaults/task-generator.ts
+var TaskGenerator = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async generateFromSpec(spec) {
+    const graph = await this.opts.taskTracker.createGraph(spec.id, spec.title);
+    const overview = spec.sections.find((s) => s.type === "overview");
+    if (overview) {
+      this.opts.taskTracker.addNode({
+        title: `Implement ${spec.title}`,
+        description: overview.content,
+        type: "feature",
+        priority: "high",
+        status: "pending"
+      });
+    }
+    const criticalReqs = spec.requirements.filter((r) => r.priority === "critical");
+    const highReqs = spec.requirements.filter((r) => r.priority === "high");
+    const mediumReqs = spec.requirements.filter((r) => r.priority === "medium");
+    const lowReqs = spec.requirements.filter((r) => r.priority === "low");
+    for (const req of criticalReqs) {
+      const task = this.createTaskFromRequirement(req, spec.title);
+      this.opts.taskTracker.addNode(task);
+    }
+    for (const req of highReqs) {
+      const task = this.createTaskFromRequirement(req, spec.title);
+      this.opts.taskTracker.addNode(task);
+    }
+    for (const req of mediumReqs) {
+      const task = this.createTaskFromRequirement(req, spec.title);
+      this.opts.taskTracker.addNode(task);
+    }
+    for (const req of lowReqs) {
+      const task = this.createTaskFromRequirement(req, spec.title);
+      this.opts.taskTracker.addNode(task);
+    }
+    if (spec.apiEndpoints && spec.apiEndpoints.length > 0) {
+      const apiParent = this.opts.taskTracker.addNode({
+        title: "API Implementation",
+        description: `Implement ${spec.apiEndpoints.length} API endpoints`,
+        type: "feature",
+        priority: "high",
+        status: "pending"
+      });
+      for (const endpoint of spec.apiEndpoints) {
+        const task = this.createTaskFromEndpoint(endpoint);
+        this.opts.taskTracker.addNode({
+          ...task,
+          parentId: apiParent.id
+        });
+      }
+    }
+    this.opts.taskTracker.addNode({
+      title: "Write Tests",
+      description: "Comprehensive test coverage for all features",
+      type: "test",
+      priority: "high",
+      status: "pending"
+    });
+    this.opts.taskTracker.addNode({
+      title: "Update Documentation",
+      description: "Update docs for new features",
+      type: "docs",
+      priority: "medium",
+      status: "pending"
+    });
+    return graph;
+  }
+  createTaskFromRequirement(req, specTitle) {
+    const type = this.mapRequirementType(req.type);
+    const tags = [req.type, req.priority];
+    return {
+      title: req.description,
+      description: this.buildDescription(req, specTitle),
+      type,
+      priority: this.mapPriority(req.priority),
+      status: "pending",
+      specRequirementId: req.id,
+      tags,
+      estimateHours: this.estimateHours(req)
+    };
+  }
+  createTaskFromEndpoint(endpoint) {
+    return {
+      title: `${endpoint.method} ${endpoint.path}`,
+      description: endpoint.description,
+      type: "feature",
+      priority: "high",
+      status: "pending",
+      tags: [endpoint.method],
+      estimateHours: this.estimateForEndpoint(endpoint)
+    };
+  }
+  buildDescription(req, specTitle) {
+    const lines = [
+      req.description,
+      "",
+      "**Type:** " + req.type,
+      "**Priority:** " + req.priority
+    ];
+    if (req.acceptanceCriteria.length > 0) {
+      lines.push("", "**Acceptance Criteria:**");
+      for (const criterion of req.acceptanceCriteria) {
+        lines.push(`- ${criterion}`);
+      }
+    }
+    if (req.blockedBy && req.blockedBy.length > 0) {
+      lines.push("", `**Blocked by:** ${req.blockedBy.join(", ")}`);
+    }
+    return lines.join("\n");
+  }
+  mapRequirementType(type) {
+    switch (type) {
+      case "functional":
+        return "feature";
+      case "non-functional":
+        return "feature";
+      case "security":
+        return "feature";
+      case "performance":
+        return "feature";
+      case "ux":
+        return "feature";
+      default:
+        return "feature";
+    }
+  }
+  mapPriority(priority) {
+    switch (priority) {
+      case "critical":
+        return "critical";
+      case "high":
+        return "high";
+      case "medium":
+        return "medium";
+      case "low":
+        return "low";
+      default:
+        return "medium";
+    }
+  }
+  estimateHours(req) {
+    switch (req.priority) {
+      case "critical":
+        return 8;
+      case "high":
+        return 4;
+      case "medium":
+        return 2;
+      case "low":
+        return 1;
+      default:
+        return 2;
+    }
+  }
+  estimateForEndpoint(endpoint) {
+    let hours = 2;
+    if (endpoint.auth) hours += 1;
+    if (endpoint.request) hours += 1;
+    return hours;
+  }
+  async generateSubtasks(parentTaskId, spec) {
+    const reqId = this.opts.taskTracker.getNode(parentTaskId)?.specRequirementId;
+    if (!reqId) return;
+    const req = spec.requirements.find((r) => r.id === reqId);
+    if (!req) return;
+    if (req.acceptanceCriteria.length > 0) {
+      for (const criterion of req.acceptanceCriteria) {
+        this.opts.taskTracker.addNode({
+          title: criterion,
+          description: `Verify: ${criterion}`,
+          type: "test",
+          priority: "medium",
+          status: "pending",
+          parentId: parentTaskId
+        });
+      }
+    }
+  }
+};
+var DefaultTaskStore = class {
+  graphs = /* @__PURE__ */ new Map();
+  async saveGraph(graph) {
+    this.graphs.set(graph.id, this.cloneGraph(graph));
+  }
+  async loadGraph(id) {
+    const g = this.graphs.get(id);
+    return g ? this.cloneGraph(g) : null;
+  }
+  async listGraphs() {
+    return Array.from(this.graphs.values()).map((g) => ({
+      id: g.id,
+      title: g.title,
+      updatedAt: g.updatedAt
+    }));
+  }
+  async deleteGraph(id) {
+    this.graphs.delete(id);
+  }
+  cloneGraph(g) {
+    return {
+      ...g,
+      nodes: new Map(g.nodes),
+      edges: [...g.edges],
+      rootNodes: [...g.rootNodes]
+    };
+  }
+};
+
+// src/types/task-graph.ts
+function computeTaskProgress(graph) {
+  const nodes = Array.from(graph.nodes.values());
+  const total = nodes.length;
+  const completed = nodes.filter((n) => n.status === "completed").length;
+  const pending = nodes.filter((n) => n.status === "pending").length;
+  const inProgress = nodes.filter((n) => n.status === "in_progress").length;
+  const blocked = nodes.filter((n) => n.status === "blocked").length;
+  const failed = nodes.filter((n) => n.status === "failed").length;
+  const review = nodes.filter((n) => n.status === "review").length;
+  const estimatedHours = nodes.reduce((sum, n) => sum + (n.estimateHours ?? 0), 0);
+  const actualHours = nodes.reduce((sum, n) => sum + (n.actualHours ?? 0), 0);
+  return {
+    total,
+    pending,
+    inProgress,
+    blocked,
+    failed,
+    review,
+    completed,
+    percentComplete: total > 0 ? Math.round(completed / total * 100) : 0,
+    estimatedHours,
+    actualHours
+  };
+}
+
+// src/defaults/task-tracker.ts
+var TaskTracker = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  graph = null;
+  transitions = [];
+  async createGraph(specId, title) {
+    this.graph = {
+      id: crypto.randomUUID(),
+      specId,
+      title,
+      nodes: /* @__PURE__ */ new Map(),
+      edges: [],
+      rootNodes: [],
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    await this.opts.store.saveGraph(this.graph);
+    return this.graph;
+  }
+  async loadGraph(id) {
+    this.graph = await this.opts.store.loadGraph(id);
+    return this.graph;
+  }
+  addNode(node) {
+    if (!this.graph) throw new Error("No graph loaded");
+    const now = Date.now();
+    const newNode = {
+      ...node,
+      id: crypto.randomUUID(),
+      status: node.status ?? "pending",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.graph.nodes.set(newNode.id, newNode);
+    if (!node.parentId) {
+      this.graph.rootNodes.push(newNode.id);
+    }
+    this.graph.updatedAt = now;
+    this.opts.store.saveGraph(this.graph);
+    return newNode;
+  }
+  addEdge(from, to, type = "depends_on") {
+    if (!this.graph) throw new Error("No graph loaded");
+    const edge = {
+      id: crypto.randomUUID(),
+      from,
+      to,
+      type
+    };
+    this.graph.edges.push(edge);
+    this.graph.updatedAt = Date.now();
+    this.opts.store.saveGraph(this.graph);
+  }
+  updateNodeStatus(id, status, reason) {
+    if (!this.graph) throw new Error("No graph loaded");
+    const node = this.graph.nodes.get(id);
+    if (!node) throw new Error(`Node ${id} not found`);
+    const from = node.status;
+    node.status = status;
+    node.updatedAt = Date.now();
+    if (status === "completed") {
+      node.completedAt = Date.now();
+    }
+    this.transitions.push({ from, to: status, timestamp: Date.now(), reason });
+    if (status === "completed") {
+      this.unblockDependents(id);
+    }
+    if (status === "in_progress") {
+      this.checkAndBlockIfNeeded(id);
+    }
+    this.graph.updatedAt = Date.now();
+    this.opts.store.saveGraph(this.graph);
+  }
+  getNode(id) {
+    return this.graph?.nodes.get(id);
+  }
+  getAllNodes(filter, sort) {
+    if (!this.graph) return [];
+    let nodes = Array.from(this.graph.nodes.values());
+    if (filter) {
+      nodes = nodes.filter((n) => {
+        if (filter.status?.length && !filter.status.includes(n.status)) return false;
+        if (filter.priority?.length && !filter.priority.includes(n.priority)) return false;
+        if (filter.type?.length && !filter.type.includes(n.type)) return false;
+        if (filter.assignee?.length && n.assignee && !filter.assignee.includes(n.assignee)) return false;
+        if (filter.tags?.length && n.tags && !n.tags.some((t) => filter.tags.includes(t))) return false;
+        if (filter.specRequirementId && n.specRequirementId !== filter.specRequirementId) return false;
+        return true;
+      });
+    }
+    if (sort) {
+      nodes.sort((a, b) => {
+        const aVal = a[sort.field] ?? "";
+        const bVal = b[sort.field] ?? "";
+        const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+        return sort.direction === "asc" ? cmp : -cmp;
+      });
+    }
+    return nodes;
+  }
+  getChildren(parentId) {
+    if (!this.graph) return [];
+    return Array.from(this.graph.nodes.values()).filter((n) => n.parentId === parentId);
+  }
+  getDependents(taskId) {
+    if (!this.graph) return [];
+    return this.graph.edges.filter((e) => e.from === taskId && e.type === "depends_on").map((e) => e.to);
+  }
+  getBlockers(taskId) {
+    if (!this.graph) return [];
+    return this.graph.edges.filter((e) => e.to === taskId && e.type === "depends_on").map((e) => e.from);
+  }
+  canStart(taskId) {
+    const blockers = this.getBlockers(taskId);
+    return blockers.every((id) => {
+      const node = this.graph?.nodes.get(id);
+      return node?.status === "completed";
+    });
+  }
+  getProgress() {
+    if (!this.graph) {
+      return {
+        total: 0,
+        pending: 0,
+        inProgress: 0,
+        blocked: 0,
+        failed: 0,
+        review: 0,
+        completed: 0,
+        percentComplete: 0,
+        estimatedHours: 0,
+        actualHours: 0
+      };
+    }
+    return computeTaskProgress(this.graph);
+  }
+  getTransitions(taskId) {
+    if (!taskId) return [...this.transitions];
+    return [...this.transitions];
+  }
+  unblockDependents(completedId) {
+    if (!this.graph) return;
+    const dependents = this.getDependents(completedId);
+    for (const depId of dependents) {
+      const dep = this.graph.nodes.get(depId);
+      if (dep?.status === "blocked") {
+        const remainingBlockers = this.getBlockers(depId);
+        const allUnblocked = remainingBlockers.every((id) => {
+          const blocker = this.graph?.nodes.get(id);
+          return blocker?.status === "completed";
+        });
+        if (allUnblocked) {
+          dep.status = "pending";
+          dep.updatedAt = Date.now();
+        }
+      }
+    }
+  }
+  checkAndBlockIfNeeded(taskId) {
+    if (!this.graph) return;
+    const blockers = this.getBlockers(taskId);
+    const someBlocked = blockers.some((id) => {
+      const blocker = this.graph?.nodes.get(id);
+      return blocker?.status !== "completed";
+    });
+    if (someBlocked) {
+      const node = this.graph.nodes.get(taskId);
+      if (node) {
+        node.status = "blocked";
+        node.updatedAt = Date.now();
+      }
+    }
+  }
+};
+
+// src/defaults/task-flow.ts
+var TaskFlow = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.setPhase("idle");
+  }
+  opts;
+  phase = "idle";
+  spec = null;
+  graph = null;
+  stopped = false;
+  emit(event, payload) {
+    this.opts.events.emit(event, payload);
+  }
+  async fromSpec(specContent) {
+    this.setPhase("parsing");
+    const parser = new SpecParser();
+    this.spec = parser.parse(specContent);
+    this.setPhase("analyzing");
+    const analysis = parser.analyze(this.spec);
+    this.emit("spec.analyzed", { analysis });
+    if (analysis.completeness < 50) {
+      this.emit("error", {
+        phase: "analyzing",
+        error: new Error(`Spec completeness too low: ${analysis.completeness}%`)
+      });
+      this.setPhase("failed");
+      throw new Error("Spec too incomplete");
+    }
+    this.setPhase("generating");
+    const generator = new TaskGenerator({ taskTracker: this.opts.tracker });
+    this.graph = await generator.generateFromSpec(this.spec);
+    return this.graph;
+  }
+  async execute(ctx) {
+    if (!this.graph) throw new Error("No graph loaded. Call fromSpec first.");
+    this.setPhase("executing");
+    this.stopped = false;
+    const pendingTasks = this.getExecutableTasks();
+    const maxConcurrent = this.opts.maxConcurrent ?? 2;
+    while (pendingTasks.length > 0 && !this.stopped) {
+      const batch = pendingTasks.splice(0, maxConcurrent);
+      const results = await Promise.allSettled(
+        batch.map((task) => this.executeSingleTask(task, ctx))
+      );
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const task = batch[i];
+        if (!result || !task) continue;
+        if (result.status === "rejected") {
+          this.opts.tracker.updateNodeStatus(task.id, "failed", result.reason?.message);
+          this.emit("task.failed", { taskId: task.id, error: result.reason?.message ?? "unknown" });
+          ctx.onTaskFail?.(task, result.reason);
+        } else {
+          this.opts.tracker.updateNodeStatus(task.id, "completed");
+          this.emit("task.completed", { taskId: task.id, result: result.value });
+          ctx.onTaskComplete?.(task, result.value);
+        }
+        this.emitProgress();
+      }
+      const stillPending = this.getExecutableTasks();
+      pendingTasks.length = 0;
+      pendingTasks.push(...stillPending);
+      if (this.checkDoneCondition()) {
+        break;
+      }
+    }
+    this.setPhase("completing");
+    this.emit("done", { graph: this.graph });
+    this.setPhase("done");
+    return this.graph;
+  }
+  async reviewTask(taskId, approved, comment) {
+    const task = this.opts.tracker.getNode(taskId);
+    if (!task) throw new Error(`Task ${taskId} not found`);
+    if (approved) {
+      this.opts.tracker.updateNodeStatus(taskId, "completed", comment);
+      this.emit("task.completed", { taskId });
+    } else {
+      this.opts.tracker.updateNodeStatus(taskId, "in_progress", comment ?? "Needs revision");
+      this.emit("task.review", { taskId });
+    }
+  }
+  stop() {
+    this.stopped = true;
+  }
+  getPhase() {
+    return this.phase;
+  }
+  getGraph() {
+    return this.graph;
+  }
+  getSpec() {
+    return this.spec;
+  }
+  setPhase(phase) {
+    const from = this.phase;
+    this.phase = phase;
+    this.emit("phase.change", { from, to: phase });
+  }
+  getExecutableTasks() {
+    return this.opts.tracker.getAllNodes({ status: ["pending", "blocked"] }).filter((n) => n.status === "pending" && this.opts.tracker.canStart(n.id)).sort((a, b) => {
+      const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      return (priorityOrder[a.priority] ?? 4) - (priorityOrder[b.priority] ?? 4);
+    });
+  }
+  async executeSingleTask(task, ctx) {
+    this.opts.tracker.updateNodeStatus(task.id, "in_progress");
+    this.emit("task.started", { taskId: task.id });
+    return ctx.executeTask(task);
+  }
+  checkDoneCondition() {
+    const condition = this.opts.doneCondition;
+    if (!condition) {
+      const progress = this.opts.tracker.getProgress();
+      return progress.percentComplete === 100;
+    }
+    switch (condition.type) {
+      case "all_tasks_done": {
+        const progress = this.opts.tracker.getProgress();
+        return progress.pending === 0 && progress.inProgress === 0;
+      }
+      case "iterations":
+        return false;
+      // Not tracked here
+      case "tool_calls":
+        return false;
+      default:
+        return false;
+    }
+  }
+  emitProgress() {
+    const progress = this.opts.tracker.getProgress();
+    this.emit("progress", {
+      percent: progress.percentComplete,
+      message: `${progress.completed}/${progress.total} tasks completed`
+    });
+  }
+};
+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()
+    }));
+  }
+};
+
+// 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, 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 };
+    };
+    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));
+    }
+    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);
+    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]);
+    try {
+      return await tool.execute(input, ctx, { signal: combined });
+    } 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
+    };
+  }
+  deniedResult(use, reason) {
+    return {
+      type: "tool_result",
+      tool_use_id: use.id,
+      content: `Tool "${use.name}" denied: ${reason ?? "policy"}`,
+      is_error: true
+    };
+  }
+  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
+    };
+  }
+};
+function anySignal(signals) {
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any(signals);
+  }
+  const ctrl = new AbortController();
+  const abortSources = [];
+  for (const s of signals) {
+    if (s.aborted) {
+      ctrl.abort(s.reason);
+      return ctrl.signal;
+    }
+    abortSources.push(s);
+  }
+  for (const s of abortSources) {
+    s.addEventListener("abort", () => ctrl.abort(s.reason), { once: true });
+  }
+  return ctrl.signal;
+}
+
+// src/defaults/context-manager.ts
+var CONTEXT_MANAGER_TOOL_NAME = "context_manager";
+function roughEstimate(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      total += Math.ceil(m.content.length / 4);
+    } else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === "text") total += Math.ceil(b.text.length / 4);
+        else if (b.type === "tool_use" || b.type === "tool_result") {
+          total += Math.ceil(JSON.stringify(b).length / 4);
+        }
+      }
+    }
+  }
+  return total;
+}
+function createContextManagerTool(opts = {}) {
+  return {
+    name: CONTEXT_MANAGER_TOOL_NAME,
+    description: 'Inspect or reorganize the conversation context window. Use "check" to see token budget. Use "summary" to collapse a message range into a concise note (provide "text" for custom summary). Use "prune" to remove specific messages by index. Use "add_note" to inject a summary note. Use "compact" to run aggressive compaction.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["check", "summary", "prune", "add_note", "compact"],
+          description: "The context operation to perform."
+        },
+        from: {
+          type: "number",
+          description: "Start index (inclusive) for summary/prune operations."
+        },
+        to: {
+          type: "number",
+          description: "End index (inclusive) for summary/prune operations."
+        },
+        text: {
+          type: "string",
+          description: 'Summary or note text. For "summary": the model-provided summary of the removed range. For "add_note": the note to inject.'
+        },
+        afterIndex: {
+          type: "number",
+          description: "Insert after this index (for add_note). Defaults to prepend (0)."
+        }
+      },
+      required: ["action"]
+    },
+    permission: "auto",
+    mutating: true,
+    async execute(input, ctx) {
+      const messages = ctx.messages;
+      const beforeTokens = roughEstimate(messages);
+      switch (input.action) {
+        case "check": {
+          return {
+            action: "check",
+            beforeTokens,
+            messageCount: messages.length,
+            notes: JSON.stringify({
+              messages: messages.length,
+              tokens: beforeTokens,
+              readFiles: ctx.readFiles.size,
+              todos: ctx.todos.length,
+              inProgress: ctx.todos.filter((t) => t.status === "in_progress").length
+            })
+          };
+        }
+        case "compact": {
+          if (!opts.compactor) {
+            return {
+              action: "compact",
+              beforeTokens,
+              messageCount: messages.length,
+              notes: "No compactor registered. Use /compact aggressive via slash command instead."
+            };
+          }
+          const report = await opts.compactor.compact(ctx);
+          return {
+            action: "compact",
+            beforeTokens,
+            afterTokens: report.after,
+            messageCount: messages.length
+          };
+        }
+        case "prune": {
+          const from = input.from ?? 0;
+          const to = input.to ?? messages.length - 1;
+          if (from < 0 || to >= messages.length || from > to) {
+            return {
+              action: "prune",
+              beforeTokens,
+              messageCount: messages.length,
+              notes: `Invalid range [${from}, ${to}] for ${messages.length} messages.`
+            };
+          }
+          const removed = messages.splice(from, to - from + 1);
+          const afterTokens = roughEstimate(messages);
+          return {
+            action: "prune",
+            beforeTokens,
+            afterTokens,
+            messageCount: messages.length,
+            removedCount: removed.length
+          };
+        }
+        case "add_note": {
+          const noteText = input.text ?? "(no summary)";
+          const afterIdx = Math.min(input.afterIndex ?? 0, messages.length);
+          const noteMsg = {
+            role: "system",
+            content: `[note: ${noteText}]`
+          };
+          messages.splice(afterIdx, 0, noteMsg);
+          const afterTokens = roughEstimate(messages);
+          return {
+            action: "add_note",
+            beforeTokens,
+            afterTokens,
+            messageCount: messages.length,
+            summary: noteText
+          };
+        }
+        case "summary": {
+          const from = input.from ?? 0;
+          const to = input.to ?? messages.length - 1;
+          if (from < 0 || to >= messages.length || from > to) {
+            return {
+              action: "summary",
+              beforeTokens,
+              messageCount: messages.length,
+              notes: `Invalid range [${from}, ${to}] for ${messages.length} messages.`
+            };
+          }
+          messages.slice(from, to + 1);
+          const summaryText = input.text ?? '[summary placeholder \u2014 provide "text" to record the summary]';
+          const summaryMsg = {
+            role: "system",
+            content: `[summary of messages ${from}\u2013${to}]: ${summaryText}`
+          };
+          messages.splice(from, to - from + 1, summaryMsg);
+          const afterTokens = roughEstimate(messages);
+          return {
+            action: "summary",
+            beforeTokens,
+            afterTokens,
+            messageCount: messages.length,
+            summary: summaryText
+          };
+        }
+        default:
+          return {
+            action: input.action,
+            beforeTokens,
+            messageCount: messages.length,
+            notes: `Unknown action: ${input.action}`
+          };
+      }
+    }
+  };
+}
+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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map