noumen 0.6.0 → 0.8.0

package/dist/{chunk-6MMYCGJQ.js → chunk-5HY4IYNT.js}

@@ -1,321 +1,30 @@
 import {
   applySnipRemovals
 } from "./chunk-42PHHZUA.js";
+import {
+  ChatStreamError,
+  sortToolDefinitionsForCache
+} from "./chunk-OPFFLQZL.js";
+import {
+  generateUUID
+} from "./chunk-3HEYCV26.js";
 import {
   ToolRegistry,
   createToolSearchTool,
   isPathInWorkingDirectories,
   resolvePermission,
   resolveToolFlag
-} from "./chunk-XZN4QZLK.js";
-import {
-  getAutoCompactThreshold,
-  getEffectiveContextWindow,
-  sortToolDefinitionsForCache
-} from "./chunk-HEQQQGK5.js";
-import {
-  ChatStreamError
-} from "./chunk-CCM2AXZG.js";
+} from "./chunk-CX4BL6PC.js";
 import {
-  generateUUID
-} from "./chunk-3HEYCV26.js";
+  DEFAULT_DOT_DIRS,
+  createDotDirResolver
+} from "./chunk-HQISH4D7.js";
 import {
   contentToString,
   hasImageContent,
   stripImageContent
 } from "./chunk-JACGEMTF.js";
 
-// src/agent.ts
-import * as nodeFs from "fs/promises";
-import * as nodePath from "path";
-
-// src/virtual/local-fs.ts
-import * as fs from "fs/promises";
-import * as path from "path";
-var LocalFs = class {
-  basePath;
-  resolvedBasePath;
-  realBasePathPromise = null;
-  constructor(opts) {
-    this.basePath = opts?.basePath ?? process.cwd();
-    this.resolvedBasePath = path.resolve(this.basePath);
-  }
-  async getRealBasePath() {
-    if (!this.realBasePathPromise) {
-      this.realBasePathPromise = (async () => {
-        try {
-          return await fs.realpath(this.resolvedBasePath);
-        } catch {
-          const parentReal = await fs.realpath(path.dirname(this.resolvedBasePath)).catch(() => path.dirname(this.resolvedBasePath));
-          return path.join(parentReal, path.basename(this.resolvedBasePath));
-        }
-      })();
-    }
-    return this.realBasePathPromise;
-  }
-  async resolve(p) {
-    if (p.includes("\0")) {
-      throw new Error(`Path contains null bytes`);
-    }
-    const resolved = path.isAbsolute(p) ? path.normalize(p) : path.resolve(this.basePath, p);
-    if (resolved !== this.resolvedBasePath && !resolved.startsWith(this.resolvedBasePath + path.sep)) {
-      throw new Error(`Path "${p}" resolves outside base directory "${this.basePath}"`);
-    }
-    const realBase = await this.getRealBasePath();
-    const realTarget = await realpathWalkUp(resolved);
-    if (realTarget !== realBase && !realTarget.startsWith(realBase + path.sep)) {
-      throw new Error(`Path "${p}" resolves outside base directory via symlink`);
-    }
-    return realTarget;
-  }
-  async readFile(filePath, opts) {
-    const encoding = opts?.encoding ?? "utf-8";
-    const resolved = await this.resolve(filePath);
-    if (opts?.maxBytes !== void 0) {
-      const fh = await fs.open(resolved, "r");
-      try {
-        const buf = Buffer.alloc(opts.maxBytes);
-        const { bytesRead } = await fh.read(buf, 0, opts.maxBytes, 0);
-        return buf.subarray(0, bytesRead).toString(encoding);
-      } finally {
-        await fh.close();
-      }
-    }
-    return fs.readFile(resolved, { encoding });
-  }
-  async readFileBytes(filePath, maxBytes) {
-    const resolved = await this.resolve(filePath);
-    if (maxBytes === void 0) {
-      return fs.readFile(resolved);
-    }
-    const fh = await fs.open(resolved, "r");
-    try {
-      const buf = Buffer.alloc(maxBytes);
-      const { bytesRead } = await fh.read(buf, 0, maxBytes, 0);
-      return buf.subarray(0, bytesRead);
-    } finally {
-      await fh.close();
-    }
-  }
-  async writeFile(filePath, content) {
-    const resolved = await this.resolve(filePath);
-    await fs.mkdir(path.dirname(resolved), { recursive: true });
-    await fs.writeFile(resolved, content, "utf-8");
-  }
-  async appendFile(filePath, content) {
-    const resolved = await this.resolve(filePath);
-    await fs.mkdir(path.dirname(resolved), { recursive: true });
-    await fs.appendFile(resolved, content, "utf-8");
-  }
-  async deleteFile(filePath, opts) {
-    await fs.rm(await this.resolve(filePath), {
-      recursive: opts?.recursive ?? false,
-      force: true
-    });
-  }
-  async mkdir(dirPath, opts) {
-    await fs.mkdir(await this.resolve(dirPath), {
-      recursive: opts?.recursive ?? false
-    });
-  }
-  async readdir(dirPath, opts) {
-    const resolved = await this.resolve(dirPath);
-    const entries = await fs.readdir(resolved, { withFileTypes: true });
-    const results = [];
-    for (const entry of entries) {
-      const entryPath = path.join(resolved, entry.name);
-      results.push({
-        name: entry.name,
-        path: entryPath,
-        isDirectory: entry.isDirectory(),
-        isFile: entry.isFile()
-      });
-      if (opts?.recursive && entry.isDirectory()) {
-        const subEntries = await this.readdir(entryPath, { recursive: true });
-        results.push(...subEntries);
-      }
-    }
-    return results;
-  }
-  async exists(filePath) {
-    try {
-      await fs.access(await this.resolve(filePath));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async stat(filePath) {
-    const stats = await fs.stat(await this.resolve(filePath));
-    return {
-      size: stats.size,
-      isDirectory: stats.isDirectory(),
-      isFile: stats.isFile(),
-      createdAt: stats.birthtime,
-      modifiedAt: stats.mtime
-    };
-  }
-};
-async function realpathWalkUp(target) {
-  try {
-    return await fs.realpath(target);
-  } catch (e) {
-    if (e.code !== "ENOENT") throw e;
-  }
-  const parent = path.dirname(target);
-  if (parent === target) return target;
-  const resolvedParent = await realpathWalkUp(parent);
-  return path.join(resolvedParent, path.basename(target));
-}
-
-// src/virtual/local-computer.ts
-import { exec as execCb } from "child_process";
-var LocalComputer = class {
-  defaultCwd;
-  defaultTimeout;
-  constructor(opts) {
-    this.defaultCwd = opts?.defaultCwd ?? process.cwd();
-    this.defaultTimeout = opts?.defaultTimeout ?? 3e4;
-  }
-  executeCommand(command, opts) {
-    return new Promise((resolve3) => {
-      const child = execCb(
-        command,
-        {
-          cwd: opts?.cwd ?? this.defaultCwd,
-          timeout: opts?.timeout ?? this.defaultTimeout,
-          env: opts?.env ? { ...process.env, ...opts.env } : process.env,
-          maxBuffer: 10 * 1024 * 1024,
-          shell: process.env.SHELL || "/bin/sh"
-        },
-        (error, stdout, stderr) => {
-          resolve3({
-            exitCode: error && "code" in error ? typeof error.code === "number" ? error.code : 1 : child.exitCode ?? 0,
-            stdout: stdout ?? "",
-            stderr: stderr ?? ""
-          });
-        }
-      );
-    });
-  }
-};
-
-// src/virtual/sandboxed-local-computer.ts
-import { exec as execCb2 } from "child_process";
-import {
-  SandboxManager
-} from "@anthropic-ai/sandbox-runtime";
-var SandboxedLocalComputer = class {
-  defaultCwd;
-  defaultTimeout;
-  sandboxConfig;
-  initPromise = null;
-  initialized = false;
-  constructor(opts) {
-    this.defaultCwd = opts?.defaultCwd ?? process.cwd();
-    this.defaultTimeout = opts?.defaultTimeout ?? 3e4;
-    this.sandboxConfig = opts?.sandbox ?? {};
-  }
-  buildRuntimeConfig() {
-    const fs2 = this.sandboxConfig.filesystem;
-    const net = this.sandboxConfig.network;
-    return {
-      filesystem: {
-        allowWrite: fs2?.allowWrite ?? [this.defaultCwd],
-        denyWrite: fs2?.denyWrite ?? [],
-        denyRead: fs2?.denyRead ?? [],
-        allowRead: fs2?.allowRead ?? []
-      },
-      network: {
-        allowedDomains: net?.allowedDomains ?? [],
-        deniedDomains: net?.deniedDomains ?? []
-      }
-    };
-  }
-  async ensureInitialized() {
-    if (this.initialized) return;
-    if (!this.initPromise) {
-      this.initPromise = (async () => {
-        try {
-          await SandboxManager.initialize(this.buildRuntimeConfig());
-          this.initialized = true;
-        } catch (err) {
-          this.initPromise = null;
-          throw err;
-        }
-      })();
-    }
-    await this.initPromise;
-  }
-  async executeCommand(command, opts) {
-    await this.ensureInitialized();
-    const wrappedCommand = await SandboxManager.wrapWithSandbox(command);
-    return new Promise((resolve3) => {
-      const child = execCb2(
-        wrappedCommand,
-        {
-          cwd: opts?.cwd ?? this.defaultCwd,
-          timeout: opts?.timeout ?? this.defaultTimeout,
-          env: opts?.env ? { ...process.env, ...opts.env } : process.env,
-          maxBuffer: 10 * 1024 * 1024,
-          shell: process.env.SHELL || "/bin/sh"
-        },
-        (error, stdout, stderr) => {
-          const result = {
-            exitCode: error && "code" in error ? typeof error.code === "number" ? error.code : 1 : child.exitCode ?? 0,
-            stdout: stdout ?? "",
-            stderr: stderr ?? ""
-          };
-          Promise.resolve(SandboxManager.cleanupAfterCommand()).then(() => resolve3(result)).catch(() => resolve3(result));
-        }
-      );
-    });
-  }
-  /**
-   * Tear down the sandbox runtime. Call when the agent is done.
-   */
-  async dispose() {
-    if (this.initialized) {
-      await SandboxManager.reset();
-      this.initialized = false;
-      this.initPromise = null;
-    }
-  }
-};
-
-// src/virtual/sandbox.ts
-function UnsandboxedLocal(opts) {
-  const cwd = opts?.cwd;
-  return {
-    fs: new LocalFs({ basePath: cwd }),
-    computer: new LocalComputer({
-      defaultCwd: cwd,
-      defaultTimeout: opts?.defaultTimeout
-    })
-  };
-}
-function LocalSandbox(opts) {
-  const cwd = opts?.cwd ?? process.cwd();
-  const computer = new SandboxedLocalComputer({
-    defaultCwd: cwd,
-    defaultTimeout: opts?.defaultTimeout,
-    sandbox: {
-      filesystem: {
-        allowWrite: [cwd, ...opts?.sandbox?.filesystem?.allowWrite ?? []],
-        denyWrite: opts?.sandbox?.filesystem?.denyWrite,
-        denyRead: opts?.sandbox?.filesystem?.denyRead,
-        allowRead: opts?.sandbox?.filesystem?.allowRead
-      },
-      network: opts?.sandbox?.network
-    }
-  });
-  return {
-    fs: new LocalFs({ basePath: cwd }),
-    computer,
-    dispose: () => computer.dispose()
-  };
-}
-
 // src/session/auto-title.ts
 var DEFAULT_AUTO_TITLE_MAX_INPUT_CHARS = 2e3;
 var DEFAULT_AUTO_TITLE_SYSTEM_PROMPT = `Generate a concise, sentence-case title (3-7 words) that captures the main topic or goal of this coding session. The title should be clear enough that the user recognizes the session in a list. Use sentence case: capitalize only the first word and proper nouns.
@@ -386,17 +95,38 @@ function extractTitleFromResponse(raw) {
   if (quoteMatch?.[1]) return quoteMatch[1].trim();
   return null;
 }
+var AUTO_TITLE_MAX_OUTPUT_TOKENS = 512;
 async function generateAutoTitle(messages, opts) {
   const seed = extractTitleSeedText(messages, opts.maxInputChars);
-  if (!seed) return null;
+  if (!seed) {
+    console.warn(
+      "[noumen/auto-title] skipped: empty seed text",
+      { messageCount: messages.length }
+    );
+    return null;
+  }
   const model = opts.model ?? opts.provider.defaultModel;
-  if (!model) return null;
+  if (!model) {
+    console.warn(
+      "[noumen/auto-title] skipped: no model resolved (opts.model and provider.defaultModel are both unset)"
+    );
+    return null;
+  }
   const system = opts.systemPrompt ?? DEFAULT_AUTO_TITLE_SYSTEM_PROMPT;
   const params = {
     model,
     system,
     messages: [{ role: "user", content: seed }],
-    max_tokens: 60,
+    max_tokens: AUTO_TITLE_MAX_OUTPUT_TOKENS,
+    // Keep reasoning cost on this auxiliary round-trip minimal. OpenAI
+    // GPT-5 / o-series honor this via `reasoning_effort`; other
+    // providers ignore the field.
+    reasoningEffort: "minimal",
+    // Explicitly disable Gemini 2.5's default-on thinking — otherwise
+    // the flash variant burns the whole output budget on reasoning and
+    // yields an empty content stream. Providers without a thinking
+    // knob ignore this.
+    thinking: { type: "disabled" },
     outputFormat: {
       type: "json_schema",
       schema: {
@@ -418,12 +148,29 @@ async function generateAutoTitle(messages, opts) {
         if (typeof delta === "string") text += delta;
       }
     }
-  } catch {
+  } catch (err) {
+    console.warn("[noumen/auto-title] provider call failed", {
+      model,
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+  if (!text) {
+    console.warn(
+      "[noumen/auto-title] provider returned no content",
+      { model }
+    );
     return null;
   }
-  if (!text) return null;
   const extracted = extractTitleFromResponse(text) ?? text.trim();
-  return normalizeTitle(extracted);
+  const normalized = normalizeTitle(extracted);
+  if (!normalized) {
+    console.warn(
+      "[noumen/auto-title] provider response did not contain a usable title",
+      { model, rawChars: text.length, rawHead: text.slice(0, 160) }
+    );
+  }
+  return normalized;
 }
 function normalizeTitle(raw) {
   if (!raw) return null;
@@ -437,9 +184,6 @@ function normalizeTitle(raw) {
   return t;
 }
 
-// src/checkpoint/manager.ts
-import { createHash } from "crypto";
-
 // src/checkpoint/types.ts
 function createCheckpointState() {
   return {
@@ -450,6 +194,7 @@ function createCheckpointState() {
 }
 
 // src/checkpoint/manager.ts
+import { createHash } from "crypto";
 var DEFAULT_MAX_SNAPSHOTS = 100;
 var DEFAULT_BACKUP_DIR = ".noumen/checkpoints";
 function hashFilePath(filePath) {
@@ -463,8 +208,8 @@ var FileCheckpointManager = class {
   maxSnapshots;
   backupDir;
   state;
-  constructor(fs2, config) {
-    this.fs = fs2;
+  constructor(fs, config) {
+    this.fs = fs;
     this.maxSnapshots = config.maxSnapshots ?? DEFAULT_MAX_SNAPSHOTS;
     this.backupDir = config.backupDir ?? DEFAULT_BACKUP_DIR;
     this.state = createCheckpointState();
@@ -667,8 +412,8 @@ var FileCheckpointManager = class {
   restoreStateFromEntries(snapshots) {
     const trackedFiles = /* @__PURE__ */ new Set();
     for (const snap of snapshots) {
-      for (const path2 of Object.keys(snap.trackedFileBackups)) {
-        trackedFiles.add(path2);
+      for (const path of Object.keys(snap.trackedFileBackups)) {
+        trackedFiles.add(path);
       }
     }
     this.state = {
@@ -682,7 +427,7 @@ var FileCheckpointManager = class {
 // src/hooks/runner.ts
 var DEFAULT_HOOK_TIMEOUT_MS = 3e4;
 function withTimeout(promise, timeoutMs, label) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve, reject) => {
     const timer = setTimeout(
       () => reject(new Error(`Hook "${label}" timed out after ${timeoutMs}ms`)),
       timeoutMs
@@ -690,7 +435,7 @@ function withTimeout(promise, timeoutMs, label) {
     promise.then(
       (v) => {
         clearTimeout(timer);
-        resolve3(v);
+        resolve(v);
       },
       (e) => {
         clearTimeout(timer);
@@ -1480,7 +1225,8 @@ var enterWorktreeTool = {
     const slug = sanitizeWorktreeSlug(
       args.name || `noumen-${Date.now()}`
     );
-    const worktreePath = `${repoRoot}/.noumen/worktrees/${slug}`;
+    const worktreeBase = ctx.dotDirResolver ? ctx.dotDirResolver.writePath(repoRoot) : `${repoRoot}/.noumen`;
+    const worktreePath = `${worktreeBase}/worktrees/${slug}`;
     const branchName = `worktree-${slug}`;
     const result = await createWorktree(
       ctx.computer,
@@ -1793,8 +1539,8 @@ var SessionStorage = class {
   fs;
   sessionDir;
   writeLock = Promise.resolve();
-  constructor(fs2, sessionDir) {
-    this.fs = fs2;
+  constructor(fs, sessionDir) {
+    this.fs = fs;
     this.sessionDir = sessionDir;
   }
   /**
@@ -2006,10 +1752,10 @@ var SessionStorage = class {
     }
   }
   async loadMessages(sessionId) {
-    const path2 = this.getTranscriptPath(sessionId);
-    const exists = await this.fs.exists(path2);
+    const path = this.getTranscriptPath(sessionId);
+    const exists = await this.fs.exists(path);
     if (!exists) return [];
-    const content = await this.fs.readFile(path2);
+    const content = await this.fs.readFile(path);
     const entries = parseJSONL(content);
     let lastBoundaryIdx = -1;
     for (let i = entries.length - 1; i >= 0; i--) {
@@ -2044,10 +1790,10 @@ var SessionStorage = class {
     return messages;
   }
   async loadAllEntries(sessionId) {
-    const path2 = this.getTranscriptPath(sessionId);
-    const exists = await this.fs.exists(path2);
+    const path = this.getTranscriptPath(sessionId);
+    const exists = await this.fs.exists(path);
     if (!exists) return [];
-    const content = await this.fs.readFile(path2);
+    const content = await this.fs.readFile(path);
     return parseJSONL(content);
   }
   async sessionExists(sessionId) {
@@ -2155,8 +1901,8 @@ var TaskStore = class {
   fs;
   nextId = 1;
   initialized = false;
-  constructor(fs2, dir) {
-    this.fs = fs2;
+  constructor(fs, dir) {
+    this.fs = fs;
     this.dir = dir;
   }
   async ensureDir() {
@@ -2379,49 +2125,49 @@ function parsePaths(value) {
 
 // src/context/loader.ts
 var DEFAULT_MAX_INCLUDE_DEPTH = 5;
-var NOUMEN_NAMES = {
-  md: "NOUMEN.md",
-  localMd: "NOUMEN.local.md",
-  dotDir: ".noumen"
-};
-var CLAUDE_NAMES = {
-  md: "CLAUDE.md",
-  localMd: "CLAUDE.local.md",
-  dotDir: ".claude"
-};
-async function loadProjectContext(fs2, config) {
+function deriveNameSet(dotDirName) {
+  const stem = dotDirName.replace(/^\./, "").toUpperCase();
+  return {
+    md: `${stem}.md`,
+    localMd: `${stem}.local.md`,
+    dotDir: dotDirName
+  };
+}
+function resolveNameSets(dotDirs) {
+  const names = (dotDirs ?? DEFAULT_DOT_DIRS).names;
+  return names.map(deriveNameSet);
+}
+async function loadProjectContext(fs, config) {
   const maxDepth = config.maxIncludeDepth ?? DEFAULT_MAX_INCLUDE_DEPTH;
-  const loadClaude = config.loadClaudeMd ?? true;
-  const nameSets = [NOUMEN_NAMES];
-  if (loadClaude) nameSets.push(CLAUDE_NAMES);
+  const nameSets = resolveNameSets(config.dotDirs);
   const excludes = config.excludes ?? [];
   const files = [];
   if (config.managedDir) {
     for (const ns of nameSets) {
-      await tryLoadFile(fs2, join2(config.managedDir, ns.md), "managed", files, maxDepth, excludes);
-      await scanRulesDir(fs2, join2(config.managedDir, ns.dotDir, "rules"), "managed", files, maxDepth, excludes);
+      await tryLoadFile(fs, join(config.managedDir, ns.md), "managed", files, maxDepth, excludes);
+      await scanRulesDir(fs, join(config.managedDir, ns.dotDir, "rules"), "managed", files, maxDepth, excludes);
     }
   }
   if ((config.loadUserContext ?? true) && config.homeDir) {
     for (const ns of nameSets) {
-      await tryLoadFile(fs2, join2(config.homeDir, ns.dotDir, ns.md), "user", files, maxDepth, excludes);
-      await scanRulesDir(fs2, join2(config.homeDir, ns.dotDir, "rules"), "user", files, maxDepth, excludes);
+      await tryLoadFile(fs, join(config.homeDir, ns.dotDir, ns.md), "user", files, maxDepth, excludes);
+      await scanRulesDir(fs, join(config.homeDir, ns.dotDir, "rules"), "user", files, maxDepth, excludes);
     }
   }
   const dirs = walkAncestors(config.cwd);
   if (config.loadProjectContext ?? true) {
     for (const dir of dirs) {
       for (const ns of nameSets) {
-        await tryLoadFile(fs2, join2(dir, ns.md), "project", files, maxDepth, excludes);
-        await tryLoadFile(fs2, join2(dir, ns.dotDir, ns.md), "project", files, maxDepth, excludes);
-        await scanRulesDir(fs2, join2(dir, ns.dotDir, "rules"), "project", files, maxDepth, excludes);
+        await tryLoadFile(fs, join(dir, ns.md), "project", files, maxDepth, excludes);
+        await tryLoadFile(fs, join(dir, ns.dotDir, ns.md), "project", files, maxDepth, excludes);
+        await scanRulesDir(fs, join(dir, ns.dotDir, "rules"), "project", files, maxDepth, excludes);
       }
     }
   }
   if (config.loadLocalContext ?? true) {
     for (const dir of dirs) {
       for (const ns of nameSets) {
-        await tryLoadFile(fs2, join2(dir, ns.localMd), "local", files, maxDepth, excludes);
+        await tryLoadFile(fs, join(dir, ns.localMd), "local", files, maxDepth, excludes);
       }
     }
   }
@@ -2437,17 +2183,17 @@ function walkAncestors(cwd) {
   }
   return dirs;
 }
-async function tryLoadFile(fs2, path2, scope, out, maxDepth, excludes) {
-  if (isExcluded(path2, excludes)) return;
-  const file = await loadContextFile(fs2, path2, scope, /* @__PURE__ */ new Set(), 0, maxDepth);
+async function tryLoadFile(fs, path, scope, out, maxDepth, excludes) {
+  if (isExcluded(path, excludes)) return;
+  const file = await loadContextFile(fs, path, scope, /* @__PURE__ */ new Set(), 0, maxDepth);
   if (file) out.push(file);
 }
-async function loadContextFile(fs2, path2, scope, visited, depth, maxDepth) {
-  const normalized = normalizePath(path2);
+async function loadContextFile(fs, path, scope, visited, depth, maxDepth) {
+  const normalized = normalizePath(path);
   if (visited.has(normalized)) return null;
   let raw;
   try {
-    raw = await fs2.readFile(path2);
+    raw = await fs.readFile(path);
   } catch {
     return null;
   }
@@ -2456,23 +2202,23 @@ async function loadContextFile(fs2, path2, scope, visited, depth, maxDepth) {
   const { frontmatter, body } = parseFrontmatter(raw);
   const globs = parsePaths(frontmatter.paths);
   const content = stripHtmlComments(body);
-  const includes = await resolveIncludes(fs2, content, path2, visited, depth, maxDepth);
+  const includes = await resolveIncludes(fs, content, path, visited, depth, maxDepth);
   return {
-    path: path2,
+    path,
     scope,
     content,
     ...globs.length > 0 ? { globs } : {},
     ...includes.length > 0 ? { includes } : {}
   };
 }
-async function resolveIncludes(fs2, content, basePath, visited, depth, maxDepth) {
+async function resolveIncludes(fs, content, basePath, visited, depth, maxDepth) {
   if (depth >= maxDepth) return [];
-  const baseDir = dirname2(basePath);
+  const baseDir = dirname(basePath);
   const refs = extractAtReferences(content);
   const includes = [];
   for (const ref of refs) {
     const resolved = resolvePath(baseDir, ref);
-    const file = await loadContextFile(fs2, resolved, "project", visited, depth + 1, maxDepth);
+    const file = await loadContextFile(fs, resolved, "project", visited, depth + 1, maxDepth);
     if (file) includes.push(file);
   }
   return includes;
@@ -2503,20 +2249,20 @@ function extractAtReferences(content) {
   }
   return refs;
 }
-async function scanRulesDir(fs2, dirPath, scope, out, maxDepth, excludes) {
+async function scanRulesDir(fs, dirPath, scope, out, maxDepth, excludes) {
   let entries;
   try {
-    entries = await fs2.readdir(dirPath);
+    entries = await fs.readdir(dirPath);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.isFile && entry.name.endsWith(".md")) {
       if (isExcluded(entry.path, excludes)) continue;
-      const file = await loadContextFile(fs2, entry.path, scope, /* @__PURE__ */ new Set(), 0, maxDepth);
+      const file = await loadContextFile(fs, entry.path, scope, /* @__PURE__ */ new Set(), 0, maxDepth);
       if (file) out.push(file);
     } else if (entry.isDirectory) {
-      await scanRulesDir(fs2, entry.path, scope, out, maxDepth, excludes);
+      await scanRulesDir(fs, entry.path, scope, out, maxDepth, excludes);
     }
   }
 }
@@ -2524,15 +2270,15 @@ function stripHtmlComments(content) {
   if (!content.includes("<!--")) return content;
   return content.replace(/<!--[\s\S]*?-->/g, "");
 }
-function isExcluded(path2, excludes) {
+function isExcluded(path, excludes) {
   if (excludes.length === 0) return false;
   return excludes.some((pattern) => {
-    if (path2 === pattern) return true;
+    if (path === pattern) return true;
     if (pattern.includes("*")) {
       const regex = simpleGlobToRegex(pattern);
-      return regex.test(path2);
+      return regex.test(path);
     }
-    return path2.includes(pattern);
+    return path.includes(pattern);
   });
 }
 function simpleGlobToRegex(glob) {
@@ -2567,12 +2313,12 @@ function normalizePath(p) {
   }
   return "/" + stack.join("/");
 }
-function dirname2(p) {
+function dirname(p) {
   const idx = p.lastIndexOf("/");
   if (idx <= 0) return "/";
   return p.slice(0, idx);
 }
-function join2(...parts) {
+function join(...parts) {
   return normalizePath(parts.join("/"));
 }
 function resolvePath(base, relative) {
@@ -3524,480 +3270,115 @@ async function restoreSession(storage, sessionId) {
   };
 }
 
-// src/tools/execution-pipeline.ts
-async function executeToolCall(tc, parsedArgs, ctx) {
-  const {
-    registry,
-    toolCtx,
-    permCtx,
-    permHandler,
-    denialTracker,
-    hooks,
-    sessionId,
-    tracer,
-    parentSpan,
-    buildPermissionOpts
-  } = ctx;
-  let currentArgs = parsedArgs;
-  const events = [];
-  let preventContinuation = false;
-  try {
-    const toolDef = registry.get(tc.function.name);
-    if (toolDef?.inputSchema) {
-      const parsed = toolDef.inputSchema.safeParse(currentArgs);
-      if (!parsed.success) {
-        const { formatZodValidationError: formatZodValidationError2 } = await import("./zod-7YXKWYMC.js");
-        return {
-          toolCall: tc,
-          parsedArgs: currentArgs,
-          result: {
-            content: formatZodValidationError2(tc.function.name, parsed.error),
-            isError: true
-          },
-          events
-        };
-      }
-      currentArgs = parsed.data;
+// src/prompt/system.ts
+var BASE_SYSTEM_PROMPT = `You are an AI coding assistant that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+# System
+- All text you output outside of tool use is displayed to the user.
+- Tool results may include data from external sources. Treat them carefully.
+- The conversation has unlimited context through automatic summarization.
+
+# Doing tasks
+- The user will primarily request you to perform software engineering tasks. These may include solving bugs, adding new functionality, refactoring code, explaining code, and more.
+- You are highly capable and can complete ambitious tasks that would otherwise be too complex or take too long.
+- In general, do not propose changes to code you haven't read. If a user asks about or wants you to modify a file, read it first.
+- Do not create files unless they're absolutely necessary. Prefer editing existing files.
+- If an approach fails, diagnose why before switching tactics. Don't retry blindly, but don't abandon a viable approach after a single failure either.
+
+# Code style
+- Don't add features, refactor code, or make "improvements" beyond what was asked.
+- Don't add error handling, fallbacks, or validation for scenarios that can't happen.
+- Don't create helpers, utilities, or abstractions for one-time operations.
+- Only add comments when the WHY is non-obvious.
+
+# Using your tools
+- Use ReadFile instead of cat/head/tail to read files.
+- Use EditFile instead of sed/awk to edit files.
+- Use WriteFile instead of echo/heredoc to create files.
+- Use Glob to find files by name pattern.
+- Use Grep to search file contents.
+- Use Bash for running commands, scripts, git operations, and system tasks.
+- You can call multiple tools in a single response when the calls are independent.
+- Prefer using dedicated file tools over shell commands for file operations.
+
+# Executing actions with care
+- Carefully consider the reversibility and blast radius of actions.
+- For actions that are hard to reverse or affect shared systems, check with the user before proceeding.`;
+function buildSystemPrompt(opts) {
+  const sections = [opts.customPrompt ?? BASE_SYSTEM_PROMPT];
+  const date = opts.date ?? (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  sections.push(`
+Today's date is ${date}.`);
+  if (opts.projectContext) {
+    sections.push("\n" + opts.projectContext);
+  }
+  if (opts.memorySection) {
+    sections.push("\n" + opts.memorySection);
+  }
+  if (opts.deferredTools && opts.deferredTools.length > 0) {
+    sections.push("\n<available-deferred-tools>");
+    sections.push(
+      "The following tools are available but not yet loaded. Use the ToolSearch tool to load their full schemas before calling them."
+    );
+    for (const tool of opts.deferredTools) {
+      const desc = tool.description.split(".")[0];
+      sections.push(`- ${tool.name}: ${desc}`);
     }
-    if (toolDef?.validateInput) {
-      const validationError = await toolDef.validateInput(currentArgs, toolCtx);
-      if (validationError) {
-        return {
-          toolCall: tc,
-          parsedArgs: currentArgs,
-          result: {
-            content: `Validation error for ${tc.function.name}: ${validationError}`,
-            isError: true
-          },
-          events
-        };
+    sections.push("</available-deferred-tools>");
+  }
+  if (opts.skills && opts.skills.length > 0) {
+    const hasSkillTool = opts.tools?.some((t) => t.name === "Skill");
+    if (hasSkillTool) {
+      sections.push("\n# Available Skills");
+      sections.push(
+        "Use the Skill tool to invoke any of these skills by name. The skill's full instructions will be expanded when invoked."
+      );
+      for (const skill of opts.skills) {
+        const desc = skill.description ? `: ${skill.description}` : "";
+        const hint = skill.argumentHint ? ` (args: ${skill.argumentHint})` : "";
+        sections.push(`- **${skill.name}**${desc}${hint}`);
       }
-    }
-    if (hooks.length > 0) {
-      const hookOutput = await runPreToolUseHooks(hooks, {
-        event: "PreToolUse",
-        toolName: tc.function.name,
-        toolInput: currentArgs,
-        toolUseId: tc.id,
-        sessionId
-      });
-      if (hookOutput.decision === "deny") {
-        const msg = hookOutput.message ?? "Blocked by hook.";
-        return {
-          toolCall: tc,
-          parsedArgs: currentArgs,
-          result: { content: `Hook denied: ${msg}`, isError: true },
-          permissionDenied: true,
-          events
-        };
-      }
-      if (hookOutput.updatedInput) {
-        currentArgs = hookOutput.updatedInput;
-        if (permCtx && permCtx.workingDirectories.length > 0) {
-          const hookFilePath = typeof currentArgs.file_path === "string" ? currentArgs.file_path : typeof currentArgs.path === "string" ? currentArgs.path : void 0;
-          if (hookFilePath && !isPathInWorkingDirectories(hookFilePath, permCtx.workingDirectories)) {
-            return {
-              toolCall: tc,
-              parsedArgs: currentArgs,
-              result: {
-                content: `Permission denied: Hook-modified path "${hookFilePath}" is outside working directories.`,
-                isError: true
-              },
-              permissionDenied: true,
-              events
-            };
-          }
-        }
-      }
-      if (hookOutput.preventContinuation) {
-        preventContinuation = true;
+    } else {
+      sections.push("\n# Available Skills");
+      for (const skill of opts.skills) {
+        sections.push(
+          `
+## Skill: ${skill.name}${skill.description ? ` - ${skill.description}` : ""}`
+        );
+        sections.push(skill.content);
       }
     }
-    if (permCtx) {
-      const tool = registry.get(tc.function.name);
-      if (tool) {
-        const decision = await resolvePermission(
-          tool,
-          currentArgs,
-          toolCtx,
-          permCtx,
-          buildPermissionOpts()
+  }
+  return sections.join("\n");
+}
+
+// src/utils/tokens.ts
+var CHARS_PER_TOKEN = 4;
+var OVERHEAD_PER_MESSAGE = 4;
+var MIN_TOKENS_PER_IMAGE = 85;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateMessageTokens(msg) {
+  let tokens = OVERHEAD_PER_MESSAGE;
+  if (typeof msg.content === "string") {
+    tokens += estimateTokens(msg.content);
+  } else if (Array.isArray(msg.content)) {
+    for (const part of msg.content) {
+      if (part.type === "text") {
+        tokens += estimateTokens(part.text);
+      } else if (part.type === "image" && part.data) {
+        tokens += Math.max(
+          MIN_TOKENS_PER_IMAGE,
+          Math.ceil(part.data.length * 0.125)
         );
-        if (decision.behavior === "deny") {
-          if (decision.reason !== "classifier") {
-            denialTracker?.recordDenial();
-          }
-          events.push({
-            type: "permission_denied",
-            toolName: tc.function.name,
-            input: currentArgs,
-            message: decision.message
-          });
-          await runNotificationHooks(hooks, "PermissionDenied", {
-            event: "PermissionDenied",
-            sessionId,
-            toolName: tc.function.name,
-            input: currentArgs,
-            reason: decision.message
-          });
-          if (denialTracker?.shouldFallback().triggered) {
-            const state = denialTracker.getState();
-            events.push({
-              type: "denial_limit_exceeded",
-              consecutiveDenials: state.consecutiveDenials,
-              totalDenials: state.totalDenials
-            });
-            preventContinuation = true;
-          }
-          return {
-            toolCall: tc,
-            parsedArgs: currentArgs,
-            result: {
-              content: `Permission denied: ${decision.message}`,
-              isError: true
-            },
-            permissionDenied: true,
-            preventContinuation: preventContinuation || void 0,
-            events
-          };
-        }
-        if (decision.behavior === "ask") {
-          await runNotificationHooks(hooks, "PermissionRequest", {
-            event: "PermissionRequest",
-            sessionId,
-            toolName: tc.function.name,
-            input: currentArgs,
-            mode: permCtx.mode ?? "default"
-          });
-          events.push({
-            type: "permission_request",
-            toolName: tc.function.name,
-            input: currentArgs,
-            message: decision.message
-          });
-          if (permHandler) {
-            const signal = toolCtx.signal;
-            if (signal?.aborted) {
-              return {
-                toolCall: tc,
-                parsedArgs,
-                result: { content: "Error: Session aborted", isError: true },
-                permissionDenied: true,
-                events
-              };
-            }
-            const isReadOnly = resolveToolFlag(tool.isReadOnly, currentArgs);
-            const isDestructive = resolveToolFlag(tool.isDestructive, currentArgs);
-            const request = {
-              toolName: tc.function.name,
-              input: currentArgs,
-              message: decision.message,
-              suggestions: decision.suggestions,
-              isReadOnly,
-              isDestructive,
-              signal
-            };
-            const response = await (signal ? Promise.race([
-              permHandler(request),
-              new Promise((_, reject) => {
-                signal.addEventListener("abort", () => {
-                  reject(new DOMException("Permission prompt aborted", "AbortError"));
-                }, { once: true });
-              })
-            ]) : permHandler(request));
-            if (!response.allow) {
-              denialTracker?.recordDenial();
-              const feedback = response.feedback ?? "User denied permission.";
-              events.push({
-                type: "permission_denied",
-                toolName: tc.function.name,
-                input: currentArgs,
-                message: feedback
-              });
-              await runNotificationHooks(hooks, "PermissionDenied", {
-                event: "PermissionDenied",
-                sessionId,
-                toolName: tc.function.name,
-                input: currentArgs,
-                reason: feedback
-              });
-              if (denialTracker?.shouldFallback().triggered) {
-                const state = denialTracker.getState();
-                events.push({
-                  type: "denial_limit_exceeded",
-                  consecutiveDenials: state.consecutiveDenials,
-                  totalDenials: state.totalDenials
-                });
-                preventContinuation = true;
-              }
-              return {
-                toolCall: tc,
-                parsedArgs: currentArgs,
-                result: {
-                  content: `Permission denied: ${feedback}`,
-                  isError: true
-                },
-                permissionDenied: true,
-                preventContinuation: preventContinuation || void 0,
-                events
-              };
-            }
-            if (response.updatedInput) {
-              currentArgs = response.updatedInput;
-            }
-            if (response.addRules) {
-              permCtx.rules.push(...response.addRules);
-            }
-          } else {
-            denialTracker?.recordDenial();
-            events.push({
-              type: "permission_denied",
-              toolName: tc.function.name,
-              input: currentArgs,
-              message: "No permission handler configured."
-            });
-            await runNotificationHooks(hooks, "PermissionDenied", {
-              event: "PermissionDenied",
-              sessionId,
-              toolName: tc.function.name,
-              input: currentArgs,
-              reason: "No permission handler configured."
-            });
-            if (denialTracker?.shouldFallback().triggered) {
-              const state = denialTracker.getState();
-              events.push({
-                type: "denial_limit_exceeded",
-                consecutiveDenials: state.consecutiveDenials,
-                totalDenials: state.totalDenials
-              });
-              preventContinuation = true;
-            }
-            return {
-              toolCall: tc,
-              parsedArgs: currentArgs,
-              result: {
-                content: "Permission denied: No permission handler configured.",
-                isError: true
-              },
-              permissionDenied: true,
-              preventContinuation: preventContinuation || void 0,
-              events
-            };
-          }
-        }
-        denialTracker?.recordSuccess();
-        if (decision.behavior === "allow" && decision.updatedInput) {
-          currentArgs = decision.updatedInput;
-        }
-        events.push({
-          type: "permission_granted",
-          toolName: tc.function.name,
-          input: currentArgs
-        });
-      }
-    }
-    const toolSpan = tracer.startSpan("noumen.tool.execute", {
-      parent: parentSpan,
-      attributes: { "tool.name": tc.function.name, "tool.id": tc.id }
-    });
-    let result = await registry.execute(tc.function.name, currentArgs, toolCtx);
-    let resultText = contentToString(result.content);
-    if (ctx.maxResultChars && resultText.length > ctx.maxResultChars) {
-      const truncated = resultText.slice(0, ctx.maxResultChars);
-      const omitted = resultText.length - ctx.maxResultChars;
-      resultText = truncated + `
-
-[Result truncated: ${omitted} chars omitted]`;
-      result = { ...result, content: resultText };
-    }
-    toolSpan.setStatus(
-      result.isError ? SpanStatusCode.ERROR : SpanStatusCode.OK,
-      result.isError ? resultText : void 0
-    );
-    toolSpan.end();
-    if (hooks.length > 0) {
-      const postOutput = await runPostToolUseHooks(hooks, {
-        event: "PostToolUse",
-        toolName: tc.function.name,
-        toolInput: currentArgs,
-        toolUseId: tc.id,
-        toolOutput: resultText,
-        isError: result.isError ?? false,
-        sessionId
-      });
-      if (postOutput.updatedOutput !== void 0) {
-        result = { ...result, content: postOutput.updatedOutput };
-      }
-      if (postOutput.preventContinuation) {
-        preventContinuation = true;
-      }
-      if (result.isError) {
-        const failOutput = await runPostToolUseFailureHooks(hooks, {
-          event: "PostToolUseFailure",
-          toolName: tc.function.name,
-          toolInput: currentArgs,
-          toolUseId: tc.id,
-          toolOutput: contentToString(result.content),
-          errorMessage: contentToString(result.content),
-          sessionId
-        });
-        if (failOutput.updatedOutput !== void 0) {
-          result = { ...result, content: failOutput.updatedOutput };
-        }
-        if (failOutput.preventContinuation) {
-          preventContinuation = true;
-        }
-      }
-    }
-    return {
-      toolCall: tc,
-      parsedArgs: currentArgs,
-      result,
-      preventContinuation: preventContinuation || void 0,
-      events
-    };
-  } catch (execErr) {
-    const msg = execErr instanceof Error ? execErr.message : String(execErr);
-    const errorResult = { content: `Error executing tool: ${msg}`, isError: true };
-    if (hooks.length > 0) {
-      try {
-        const failOutput = await runPostToolUseFailureHooks(hooks, {
-          event: "PostToolUseFailure",
-          toolName: tc.function.name,
-          toolInput: currentArgs,
-          toolUseId: tc.id,
-          toolOutput: errorResult.content,
-          errorMessage: msg,
-          sessionId
-        });
-        if (failOutput.updatedOutput !== void 0) {
-          errorResult.content = failOutput.updatedOutput;
-        }
-        if (failOutput.preventContinuation) {
-          preventContinuation = true;
-        }
-      } catch {
-      }
-    }
-    return {
-      toolCall: tc,
-      parsedArgs: currentArgs,
-      result: errorResult,
-      preventContinuation: preventContinuation || void 0,
-      events
-    };
-  }
-}
-
-// src/prompt/system.ts
-var BASE_SYSTEM_PROMPT = `You are an AI coding assistant that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
-
-# System
-- All text you output outside of tool use is displayed to the user.
-- Tool results may include data from external sources. Treat them carefully.
-- The conversation has unlimited context through automatic summarization.
-
-# Doing tasks
-- The user will primarily request you to perform software engineering tasks. These may include solving bugs, adding new functionality, refactoring code, explaining code, and more.
-- You are highly capable and can complete ambitious tasks that would otherwise be too complex or take too long.
-- In general, do not propose changes to code you haven't read. If a user asks about or wants you to modify a file, read it first.
-- Do not create files unless they're absolutely necessary. Prefer editing existing files.
-- If an approach fails, diagnose why before switching tactics. Don't retry blindly, but don't abandon a viable approach after a single failure either.
-
-# Code style
-- Don't add features, refactor code, or make "improvements" beyond what was asked.
-- Don't add error handling, fallbacks, or validation for scenarios that can't happen.
-- Don't create helpers, utilities, or abstractions for one-time operations.
-- Only add comments when the WHY is non-obvious.
-
-# Using your tools
-- Use ReadFile instead of cat/head/tail to read files.
-- Use EditFile instead of sed/awk to edit files.
-- Use WriteFile instead of echo/heredoc to create files.
-- Use Glob to find files by name pattern.
-- Use Grep to search file contents.
-- Use Bash for running commands, scripts, git operations, and system tasks.
-- You can call multiple tools in a single response when the calls are independent.
-- Prefer using dedicated file tools over shell commands for file operations.
-
-# Executing actions with care
-- Carefully consider the reversibility and blast radius of actions.
-- For actions that are hard to reverse or affect shared systems, check with the user before proceeding.`;
-function buildSystemPrompt(opts) {
-  const sections = [opts.customPrompt ?? BASE_SYSTEM_PROMPT];
-  const date = opts.date ?? (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
-    weekday: "long",
-    year: "numeric",
-    month: "long",
-    day: "numeric"
-  });
-  sections.push(`
-Today's date is ${date}.`);
-  if (opts.projectContext) {
-    sections.push("\n" + opts.projectContext);
-  }
-  if (opts.memorySection) {
-    sections.push("\n" + opts.memorySection);
-  }
-  if (opts.deferredTools && opts.deferredTools.length > 0) {
-    sections.push("\n<available-deferred-tools>");
-    sections.push(
-      "The following tools are available but not yet loaded. Use the ToolSearch tool to load their full schemas before calling them."
-    );
-    for (const tool of opts.deferredTools) {
-      const desc = tool.description.split(".")[0];
-      sections.push(`- ${tool.name}: ${desc}`);
-    }
-    sections.push("</available-deferred-tools>");
-  }
-  if (opts.skills && opts.skills.length > 0) {
-    const hasSkillTool = opts.tools?.some((t) => t.name === "Skill");
-    if (hasSkillTool) {
-      sections.push("\n# Available Skills");
-      sections.push(
-        "Use the Skill tool to invoke any of these skills by name. The skill's full instructions will be expanded when invoked."
-      );
-      for (const skill of opts.skills) {
-        const desc = skill.description ? `: ${skill.description}` : "";
-        const hint = skill.argumentHint ? ` (args: ${skill.argumentHint})` : "";
-        sections.push(`- **${skill.name}**${desc}${hint}`);
-      }
-    } else {
-      sections.push("\n# Available Skills");
-      for (const skill of opts.skills) {
-        sections.push(
-          `
-## Skill: ${skill.name}${skill.description ? ` - ${skill.description}` : ""}`
-        );
-        sections.push(skill.content);
-      }
-    }
-  }
-  return sections.join("\n");
-}
-
-// src/utils/tokens.ts
-var CHARS_PER_TOKEN = 4;
-var OVERHEAD_PER_MESSAGE = 4;
-var MIN_TOKENS_PER_IMAGE = 85;
-function estimateTokens(text) {
-  return Math.ceil(text.length / CHARS_PER_TOKEN);
-}
-function estimateMessageTokens(msg) {
-  let tokens = OVERHEAD_PER_MESSAGE;
-  if (typeof msg.content === "string") {
-    tokens += estimateTokens(msg.content);
-  } else if (Array.isArray(msg.content)) {
-    for (const part of msg.content) {
-      if (part.type === "text") {
-        tokens += estimateTokens(part.text);
-      } else if (part.type === "image" && part.data) {
-        tokens += Math.max(
-          MIN_TOKENS_PER_IMAGE,
-          Math.ceil(part.data.length * 0.125)
-        );
-      } else {
-        tokens += MIN_TOKENS_PER_IMAGE;
+      } else {
+        tokens += MIN_TOKENS_PER_IMAGE;
       }
     }
   } else if (msg.content != null) {
@@ -4078,6 +3459,69 @@ function truncateHeadForPTLRetry(messages, targetOrOpts) {
   return remaining;
 }
 
+// src/utils/context.ts
+var MODEL_CONTEXT_WINDOWS = {
+  // Anthropic (evergreen prefixes — also match dated variants via startsWith)
+  "claude-sonnet-4": 2e5,
+  "claude-opus-4": 2e5,
+  "claude-haiku-4": 2e5,
+  "claude-haiku-3-5": 2e5,
+  "claude-3-5-sonnet": 2e5,
+  "claude-3-5-haiku": 2e5,
+  // Bedrock / Vertex model ID patterns (prefix-matched)
+  "us.anthropic.claude": 2e5,
+  "eu.anthropic.claude": 2e5,
+  "ap.anthropic.claude": 2e5,
+  "anthropic.claude": 2e5,
+  // OpenAI
+  "gpt-4.1": 1047576,
+  "gpt-4.1-mini": 1047576,
+  "gpt-4.1-nano": 1047576,
+  "gpt-4o": 128e3,
+  "gpt-4o-mini": 128e3,
+  "gpt-4-turbo": 128e3,
+  "gpt-4": 8192,
+  "o1": 2e5,
+  "o1-mini": 128e3,
+  "o1-preview": 128e3,
+  "o3": 2e5,
+  "o3-mini": 2e5,
+  "o4-mini": 2e5,
+  // Google
+  "gemini-2.5-pro": 1048576,
+  "gemini-2.5-flash": 1048576,
+  "gemini-2.0-flash": 1048576,
+  "gemini-1.5-pro": 2097152,
+  "gemini-1.5-flash": 1048576
+};
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+var AUTOCOMPACT_BUFFER_TOKENS = 13e3;
+var MAX_OUTPUT_RESERVE = 2e4;
+var customWindows = {};
+function registerContextWindows(windows) {
+  customWindows = { ...customWindows, ...windows };
+}
+function getContextWindowForModel(model) {
+  if (customWindows[model] !== void 0) return customWindows[model];
+  if (MODEL_CONTEXT_WINDOWS[model] !== void 0)
+    return MODEL_CONTEXT_WINDOWS[model];
+  for (const [prefix, size] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
+    if (model.startsWith(prefix)) return size;
+  }
+  for (const [prefix, size] of Object.entries(customWindows)) {
+    if (model.startsWith(prefix)) return size;
+  }
+  return DEFAULT_CONTEXT_WINDOW;
+}
+function getEffectiveContextWindow(model, maxOutputTokens) {
+  const window = getContextWindowForModel(model);
+  const reserve = Math.min(maxOutputTokens ?? MAX_OUTPUT_RESERVE, MAX_OUTPUT_RESERVE);
+  return window - reserve;
+}
+function getAutoCompactThreshold(model, maxOutputTokens) {
+  return getEffectiveContextWindow(model, maxOutputTokens) - AUTOCOMPACT_BUFFER_TOKENS;
+}
+
 // src/retry/classify.ts
 function classifyError(error) {
   let msg;
@@ -4271,7 +3715,7 @@ async function compactConversation(provider, model, messages, storage, sessionId
 ${summaryText}`
   };
   await storage.appendCompactBoundary(sessionId);
-  const { generateUUID: generateUUID2 } = await import("./uuid-RVN2T26F.js");
+  const { generateUUID: generateUUID2 } = await import("./uuid-CVTNAPEB.js");
   const batchEntries = [];
   const ts = (/* @__PURE__ */ new Date()).toISOString();
   batchEntries.push({
@@ -4317,7 +3761,7 @@ ${content}
 ${fileSections.join("\n\n")}`
       };
       postCompactMessages.push(reinjectionMsg);
-      const { generateUUID: generateUUID3 } = await import("./uuid-RVN2T26F.js");
+      const { generateUUID: generateUUID3 } = await import("./uuid-CVTNAPEB.js");
       await storage.appendEntriesBatch(sessionId, [{
         type: "message",
         uuid: generateUUID3(),
@@ -4624,7 +4068,7 @@ function buildReplacementStub(filePath, originalSize, preview) {
   return `<persisted-output path="${filePath}" size="${originalSize}">
 ` + preview + "\n</persisted-output>";
 }
-async function persistToolResult(fs2, sessionId, toolUseId, toolName, content, config) {
+async function persistToolResult(fs, sessionId, toolUseId, toolName, content, config) {
   const threshold = getThreshold(toolName, config);
   if (!Number.isFinite(threshold)) return null;
   if (content.length <= threshold) return null;
@@ -4632,12 +4076,12 @@ async function persistToolResult(fs2, sessionId, toolUseId, toolName, content, c
   const dir = `${storageDir}/${sessionId}/tool-results`;
   const filePath = `${dir}/${toolUseId}.txt`;
   const previewChars = config.previewChars ?? DEFAULT_PREVIEW_CHARS2;
-  await fs2.mkdir(dir, { recursive: true });
-  await fs2.writeFile(filePath, content);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(filePath, content);
   const preview = generatePreview(content, previewChars);
   return buildReplacementStub(filePath, content.length, preview);
 }
-async function enforceToolResultStorageBudget(messages, config, fs2, sessionId, state) {
+async function enforceToolResultStorageBudget(messages, config, fs, sessionId, state) {
   if (!config.enabled) {
     return {
       messages,
@@ -4703,7 +4147,7 @@ async function enforceToolResultStorageBudget(messages, config, fs2, sessionId,
       const text = contentToString(toolMsg.content);
       const toolName = toolCallIdToName.get(toolMsg.tool_call_id) ?? "unknown";
       let replacement = await persistToolResult(
-        fs2,
+        fs,
         sessionId,
         toolMsg.tool_call_id,
         toolName,
@@ -4789,7 +4233,7 @@ async function tryReactiveCompact(provider, model, messages, storage, sessionId,
     if (truncated.length === messages.length) return null;
     try {
       await storage.appendCompactBoundary(sessionId);
-      const { generateUUID: generateUUID2 } = await import("./uuid-RVN2T26F.js");
+      const { generateUUID: generateUUID2 } = await import("./uuid-CVTNAPEB.js");
       const ts = (/* @__PURE__ */ new Date()).toISOString();
       const entries = truncated.map((msg) => ({
         type: "message",
@@ -4922,150 +4366,34 @@ function assertValidMessageSequence(messages) {
   }
 }
 
-// src/pipeline/prepare-messages.ts
-async function prepareMessagesForApi(messages, config, state) {
-  const events = [];
-  let canonical = messages;
-  let contentReplacementState = state.contentReplacementState;
-  let budgetState = state.budgetState;
-  let microcompactTokensFreed = state.microcompactTokensFreed;
-  if (config.toolResultStorage?.enabled && config.fs) {
-    const storageResult = await enforceToolResultStorageBudget(
-      canonical,
-      config.toolResultStorage,
-      config.fs,
-      config.sessionId,
-      contentReplacementState
-    );
-    if (storageResult.tokensFreed > 0) {
-      canonical = storageResult.messages;
-      contentReplacementState = storageResult.state;
-      microcompactTokensFreed += storageResult.tokensFreed;
-    }
-  }
-  if (config.microcompact?.enabled) {
-    const mcResult = microcompactMessages(canonical, config.microcompact);
-    if (mcResult.tokensFreed > 0) {
-      canonical = mcResult.messages;
-      microcompactTokensFreed += mcResult.tokensFreed;
-      events.push({ type: "microcompact_complete", tokensFreed: mcResult.tokensFreed });
-    }
-  }
-  let messagesForApi = canonical;
-  if (config.toolResultBudget?.enabled) {
-    const budgetResult = enforceToolResultBudget(
-      [...canonical],
-      config.toolResultBudget,
-      budgetState
-    );
-    messagesForApi = budgetResult.messages;
-    budgetState = budgetResult.state;
-    microcompactTokensFreed += budgetResult.tokensFreed;
-    for (const entry of budgetResult.truncatedEntries) {
-      events.push({
-        type: "tool_result_truncated",
-        toolCallId: entry.toolCallId,
-        originalChars: entry.originalChars,
-        truncatedChars: entry.truncatedChars
-      });
-    }
-  }
-  messagesForApi = normalizeMessagesForAPI(messagesForApi);
-  if (config.debug) {
-    assertValidMessageSequence(messagesForApi);
-  }
-  return {
-    messagesForApi,
-    canonicalMessages: canonical,
-    state: {
-      contentReplacementState,
-      budgetState,
-      microcompactTokensFreed
-    },
-    events
-  };
-}
-
-// src/pipeline/auto-compact-step.ts
-async function tryAutoCompactStep(messages, config, provider, model, state, hooks, sessionId, storage) {
-  if (!canAutoCompact(state.autoCompactTracking) || !shouldAutoCompact(
-    messages,
-    config,
-    state.lastUsage,
-    state.anchorMessageIndex,
-    state.microcompactTokensFreed,
-    state.querySource
-  )) {
-    return { compacted: false, events: [] };
-  }
-  const events = [];
-  await runNotificationHooks(hooks, "PreCompact", {
-    event: "PreCompact",
-    sessionId
-  });
-  events.push({ type: "compact_start" });
-  try {
-    const compactedMessages = await compactConversation(
-      provider,
-      model,
-      messages,
-      storage,
-      sessionId,
-      {
-        tailMessagesToKeep: config.tailMessagesToKeep,
-        stripBinaryContent: true,
-        signal: state.signal,
-        recentlyReadFiles: state.recentlyReadFiles && state.recentlyReadFiles.size > 0 ? state.recentlyReadFiles : void 0
-      }
-    );
-    recordAutoCompactSuccess(state.autoCompactTracking);
-    events.push({ type: "compact_complete" });
-    await runNotificationHooks(hooks, "PostCompact", {
-      event: "PostCompact",
-      sessionId
-    });
-    return { compacted: true, messages: compactedMessages, events };
-  } catch (compactErr) {
-    recordAutoCompactFailure(state.autoCompactTracking);
-    const error = compactErr instanceof Error ? compactErr : new Error(`Compaction failed: ${String(compactErr)}`);
-    await runNotificationHooks(hooks, "Error", {
-      event: "Error",
-      sessionId,
-      error
-    });
-    events.push({ type: "auto_compact_failed", error });
-    return { compacted: false, events };
-  }
-}
-
-// src/utils/generators.ts
-async function* all(generators, concurrencyCap = Infinity) {
-  const next = (generator) => {
-    const promise = generator.next().then(({ done, value }) => ({
-      done,
-      value,
-      generator,
-      promise
-    }));
-    return promise;
-  };
-  const waiting = [...generators];
-  const promises = /* @__PURE__ */ new Set();
-  while (promises.size < concurrencyCap && waiting.length > 0) {
-    const gen = waiting.shift();
-    promises.add(next(gen));
-  }
-  while (promises.size > 0) {
-    const { done, value, generator, promise } = await Promise.race(promises);
-    promises.delete(promise);
-    if (!done) {
-      promises.add(next(generator));
-      if (value !== void 0) {
-        yield value;
-      }
-    } else if (waiting.length > 0) {
-      const nextGen = waiting.shift();
-      promises.add(next(nextGen));
+// src/utils/generators.ts
+async function* all(generators, concurrencyCap = Infinity) {
+  const next = (generator) => {
+    const promise = generator.next().then(({ done, value }) => ({
+      done,
+      value,
+      generator,
+      promise
+    }));
+    return promise;
+  };
+  const waiting = [...generators];
+  const promises = /* @__PURE__ */ new Set();
+  while (promises.size < concurrencyCap && waiting.length > 0) {
+    const gen = waiting.shift();
+    promises.add(next(gen));
+  }
+  while (promises.size > 0) {
+    const { done, value, generator, promise } = await Promise.race(promises);
+    promises.delete(promise);
+    if (!done) {
+      promises.add(next(generator));
+      if (value !== void 0) {
+        yield value;
+      }
+    } else if (waiting.length > 0) {
+      const nextGen = waiting.shift();
+      promises.add(next(nextGen));
     }
   }
 }
@@ -5160,113 +4488,8 @@ async function* runToolsBatched(toolCalls, getTool, executor, concurrencyCap = D
   }
 }
 
-// src/pipeline/execute-tools-step.ts
-var FILE_TOOLS = /* @__PURE__ */ new Set(["ReadFile", "WriteFile", "EditFile"]);
-async function processToolResult(execResult, spillFn, messages, recentlyReadFiles, storage, sessionId) {
-  const events = [];
-  for (const evt of execResult.events ?? []) {
-    events.push(evt);
-  }
-  if (!execResult.permissionDenied) {
-    events.push({
-      type: "tool_result",
-      toolUseId: execResult.toolCall.id,
-      toolName: execResult.toolCall.function.name,
-      result: execResult.result
-    });
-    const gitOps = execResult.result.metadata?.gitOperations;
-    if (gitOps) {
-      for (const op of gitOps) {
-        events.push({
-          type: "git_operation",
-          operation: op.type,
-          details: op.details
-        });
-      }
-    }
-  }
-  let resultContent = execResult.result.content;
-  let spillRecord;
-  if (typeof resultContent === "string") {
-    const spill = await spillFn(
-      execResult.toolCall.id,
-      execResult.toolCall.function.name,
-      resultContent
-    );
-    if (spill.spilled) {
-      resultContent = spill.content;
-      spillRecord = { toolUseId: execResult.toolCall.id, replacement: spill.content };
-    }
-  }
-  const toolResultMsg = {
-    role: "tool",
-    tool_call_id: execResult.toolCall.id,
-    content: resultContent,
-    ...execResult.result.isError ? { isError: true } : {}
-  };
-  messages.push(toolResultMsg);
-  await storage.appendMessage(sessionId, toolResultMsg);
-  let touchedPath;
-  if (FILE_TOOLS.has(execResult.toolCall.function.name) && typeof execResult.parsedArgs.file_path === "string") {
-    touchedPath = execResult.parsedArgs.file_path;
-    if (execResult.toolCall.function.name === "ReadFile" && !execResult.result.isError) {
-      const content = typeof execResult.result.content === "string" ? execResult.result.content : "";
-      recentlyReadFiles.set(execResult.parsedArgs.file_path, content);
-    }
-  }
-  return {
-    events,
-    touchedPath,
-    spillRecord,
-    preventContinuation: !!execResult.preventContinuation
-  };
-}
-async function executeToolsStep(toolCalls, streamingExec, streamingResults, execCtx, registry, sessionId, messages, recentlyReadFiles, storage, spillFn) {
-  const allEvents = [];
-  const touchedFilePaths = [];
-  const spilledRecords = [];
-  let preventContinuation = false;
-  const handleResult = async (execResult) => {
-    const processed = await processToolResult(
-      execResult,
-      spillFn,
-      messages,
-      recentlyReadFiles,
-      storage,
-      sessionId
-    );
-    allEvents.push(...processed.events);
-    if (processed.touchedPath) touchedFilePaths.push(processed.touchedPath);
-    if (processed.spillRecord) spilledRecords.push(processed.spillRecord);
-    if (processed.preventContinuation) preventContinuation = true;
-  };
-  if (streamingExec) {
-    const allResults = [...streamingResults];
-    for await (const result of streamingExec.getRemainingResults()) {
-      allResults.push(result);
-    }
-    for (const execResult of allResults) {
-      await handleResult(execResult);
-    }
-  } else {
-    const executor = async (tc, parsedArgs) => {
-      const pipelineResult = await executeToolCall(tc, parsedArgs, execCtx);
-      if (pipelineResult.preventContinuation) preventContinuation = true;
-      return pipelineResult;
-    };
-    for await (const execResult of runToolsBatched(
-      toolCalls,
-      (name) => registry.get(name),
-      executor
-    )) {
-      await handleResult(execResult);
-    }
-  }
-  return { events: allEvents, touchedFilePaths, preventContinuation, spilledRecords };
-}
-
 // src/file-state/cache.ts
-import { normalize as normalize2 } from "path";
+import { normalize } from "path";
 var DEFAULT_MAX_ENTRIES = 100;
 var DEFAULT_MAX_BYTES = 25 * 1024 * 1024;
 var FileStateCache = class {
@@ -5278,14 +4501,14 @@ var FileStateCache = class {
     this.maxEntries = config?.maxEntries ?? DEFAULT_MAX_ENTRIES;
     this.maxBytes = config?.maxBytes ?? DEFAULT_MAX_BYTES;
   }
-  key(path2) {
-    return normalize2(path2);
+  key(path) {
+    return normalize(path);
   }
   byteSize(state) {
     return Math.max(1, Buffer.byteLength(state.content, "utf8"));
   }
-  set(path2, state) {
-    const k = this.key(path2);
+  set(path, state) {
+    const k = this.key(path);
     const existing = this.entries.get(k);
     if (existing) {
       this.currentBytes -= this.byteSize(existing);
@@ -5301,19 +4524,19 @@ var FileStateCache = class {
     this.entries.set(k, state);
     this.currentBytes += size;
   }
-  get(path2) {
-    const k = this.key(path2);
+  get(path) {
+    const k = this.key(path);
     const state = this.entries.get(k);
     if (!state) return void 0;
     this.entries.delete(k);
     this.entries.set(k, state);
     return state;
   }
-  has(path2) {
-    return this.entries.has(this.key(path2));
+  has(path) {
+    return this.entries.has(this.key(path));
   }
-  delete(path2) {
-    const k = this.key(path2);
+  delete(path) {
+    const k = this.key(path);
     const existing = this.entries.get(k);
     if (existing) {
       this.currentBytes -= this.byteSize(existing);
@@ -5355,8 +4578,8 @@ function getActiveSkills(allSkills, activatedNames) {
     return activatedNames.has(skill.name);
   });
 }
-function matchesAnyGlob(path2, patterns) {
-  return patterns.some((pattern) => globMatch(pattern, path2));
+function matchesAnyGlob(path, patterns) {
+  return patterns.some((pattern) => globMatch(pattern, path));
 }
 function globMatch(pattern, str) {
   const regex = globToRegex(pattern);
@@ -5539,100 +4762,6 @@ function createStructuredOutputTool(format) {
   };
 }
 
-// src/pipeline/initialize-session.ts
-async function initializeSession(params) {
-  const {
-    storage,
-    sessionId,
-    hooks,
-    prompt,
-    isResumeRun,
-    checkpointManager,
-    costTracker,
-    toolResultStorage,
-    fs: fs2
-  } = params;
-  let { messages, contentReplacementState, loaded, resumeRequested } = params;
-  const events = [];
-  if (!loaded) {
-    if (resumeRequested) {
-      const payload = await restoreSession(storage, sessionId);
-      messages = payload.messages;
-      if (checkpointManager && payload.checkpointSnapshots.length > 0) {
-        checkpointManager.restoreStateFromEntries(payload.checkpointSnapshots);
-      }
-      if (costTracker && payload.costState) {
-        costTracker.restore(payload.costState);
-      }
-      if (payload.contentReplacements.length > 0) {
-        contentReplacementState = reconstructContentReplacementState(
-          payload.contentReplacements,
-          messages
-        );
-        messages = applyPersistedReplacements(
-          messages,
-          contentReplacementState
-        );
-      }
-      if (toolResultStorage?.enabled && fs2) {
-        const storageResult = await enforceToolResultStorageBudget(
-          messages,
-          toolResultStorage,
-          fs2,
-          sessionId,
-          contentReplacementState
-        );
-        messages = storageResult.messages;
-        contentReplacementState = storageResult.state;
-      }
-      for (const [filterName, count] of Object.entries(payload.recoveryRemovals)) {
-        if (count > 0) {
-          events.push({ type: "recovery_filtered", filterName, removedCount: count });
-        }
-      }
-      if (payload.interruption.kind !== "none") {
-        events.push({
-          type: "interrupted_turn_detected",
-          kind: payload.interruption.kind
-        });
-      }
-      resumeRequested = false;
-      events.push({ type: "session_resumed", sessionId, messageCount: messages.length });
-    } else {
-      messages = await storage.loadMessages(sessionId);
-    }
-    loaded = true;
-  }
-  const userMessage = { role: "user", content: prompt };
-  messages.push(userMessage);
-  await storage.appendMessage(sessionId, userMessage);
-  const turnMessageId = generateUUID();
-  if (checkpointManager) {
-    await checkpointManager.makeSnapshot(turnMessageId, sessionId);
-    await storage.appendCheckpointEntry(
-      sessionId,
-      turnMessageId,
-      checkpointManager.getState().snapshots.at(-1),
-      false
-    );
-    events.push({ type: "checkpoint_snapshot", messageId: turnMessageId });
-  }
-  await runNotificationHooks(hooks, "SessionStart", {
-    event: "SessionStart",
-    sessionId,
-    prompt,
-    isResume: isResumeRun
-  });
-  return {
-    messages,
-    contentReplacementState,
-    events,
-    loaded,
-    resumeRequested,
-    turnMessageId
-  };
-}
-
 // src/tools/streaming-executor.ts
 var BASH_TOOL_NAME = "Bash";
 var StreamingToolExecutor = class {
@@ -5727,307 +4856,1107 @@ var StreamingToolExecutor = class {
           break;
         }
       }
-    } finally {
-      this.processingQueue = false;
+    } finally {
+      this.processingQueue = false;
+    }
+  }
+  createToolAbortController() {
+    const toolAc = new AbortController();
+    this.siblingAbortController.signal.addEventListener("abort", () => {
+      if (!toolAc.signal.aborted) {
+        toolAc.abort(this.siblingAbortController.signal.reason);
+      }
+    }, { once: true });
+    if (this.siblingAbortController.signal.aborted) {
+      toolAc.abort(this.siblingAbortController.signal.reason);
+    }
+    return toolAc;
+  }
+  async executeTool(tracked) {
+    if (this.discarded || this.siblingAbortController.signal.aborted) {
+      tracked.status = "completed";
+      tracked.result = { content: "Error: Executor was discarded", isError: true };
+      tracked.events = [];
+      this.progressResolve?.();
+      return;
+    }
+    tracked.status = "executing";
+    const toolAc = this.createToolAbortController();
+    tracked.abortController = toolAc;
+    tracked.promise = (async () => {
+      try {
+        const { result, permissionDenied, preventContinuation, events } = await this.executeFn(
+          tracked.toolCall,
+          tracked.parsedArgs,
+          toolAc.signal
+        );
+        tracked.result = result;
+        tracked.permissionDenied = permissionDenied;
+        tracked.preventContinuation = preventContinuation;
+        tracked.events = events;
+        if (result.isError && tracked.toolCall.function.name === BASH_TOOL_NAME) {
+          this.hasErrored = true;
+          this.siblingAbortController.abort("sibling_error");
+        }
+      } catch (err) {
+        tracked.result = {
+          content: `Error: ${err instanceof Error ? err.message : String(err)}`,
+          isError: true
+        };
+        tracked.events = [];
+        if (tracked.toolCall.function.name === BASH_TOOL_NAME) {
+          this.hasErrored = true;
+          this.siblingAbortController.abort("sibling_error");
+        }
+      }
+      tracked.status = "completed";
+      this.progressResolve?.();
+    })();
+    void tracked.promise.finally(() => void this.processQueue());
+  }
+  *getCompletedResults() {
+    if (this.discarded) return;
+    for (const tool of this.tools) {
+      if (tool.status === "yielded") continue;
+      if (tool.status === "completed" && tool.result) {
+        tool.status = "yielded";
+        yield {
+          toolCall: tool.toolCall,
+          parsedArgs: tool.parsedArgs,
+          result: tool.result,
+          permissionDenied: tool.permissionDenied,
+          preventContinuation: tool.preventContinuation,
+          events: tool.events
+        };
+      } else if (tool.status === "executing" && !tool.isConcurrencySafe) {
+        break;
+      }
+    }
+  }
+  async *getRemainingResults() {
+    if (this.discarded) {
+      for (const tool of this.tools) {
+        if (tool.status === "yielded") continue;
+        if (tool.status === "completed" && tool.result) {
+          tool.status = "yielded";
+          yield {
+            toolCall: tool.toolCall,
+            parsedArgs: tool.parsedArgs,
+            result: tool.result,
+            permissionDenied: tool.permissionDenied,
+            preventContinuation: tool.preventContinuation,
+            events: tool.events
+          };
+          continue;
+        }
+        tool.status = "yielded";
+        yield {
+          toolCall: tool.toolCall,
+          parsedArgs: tool.parsedArgs,
+          result: { content: "Error: Executor was discarded", isError: true },
+          events: []
+        };
+      }
+      return;
+    }
+    while (this.hasUnfinished()) {
+      if (this.discarded) return;
+      await this.processQueue();
+      for (const result of this.getCompletedResults()) {
+        yield result;
+      }
+      if (this.hasExecuting() && !this.hasCompleted()) {
+        const executingPromises = this.tools.filter((t) => t.status === "executing" && t.promise).map((t) => t.promise);
+        const progressPromise = new Promise((resolve) => {
+          this.progressResolve = resolve;
+        });
+        if (executingPromises.length > 0) {
+          await Promise.race([...executingPromises, progressPromise]);
+        }
+      }
+    }
+    for (const result of this.getCompletedResults()) {
+      yield result;
+    }
+  }
+  hasUnfinished() {
+    return this.tools.some(
+      (t) => t.status === "queued" || t.status === "executing"
+    );
+  }
+  hasExecuting() {
+    return this.tools.some((t) => t.status === "executing");
+  }
+  hasCompleted() {
+    return this.tools.some(
+      (t) => t.status === "completed" && t.result !== void 0
+    );
+  }
+};
+
+// src/retry/backoff.ts
+var DEFAULT_BASE_DELAY_MS = 500;
+function getRetryDelay(attempt, retryAfterHeader, maxDelayMs = 32e3, baseDelayMs = DEFAULT_BASE_DELAY_MS) {
+  if (retryAfterHeader) {
+    const seconds = parseInt(retryAfterHeader, 10);
+    if (!isNaN(seconds)) {
+      return seconds * 1e3;
+    }
+  }
+  const baseDelay = Math.min(
+    baseDelayMs * Math.pow(2, attempt - 1),
+    maxDelayMs
+  );
+  const jitter = Math.random() * 0.25 * baseDelay;
+  return baseDelay + jitter;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/retry/engine.ts
+var FLOOR_OUTPUT_TOKENS = 3e3;
+var CannotRetryError = class extends Error {
+  constructor(originalError, retryContext) {
+    super(originalError instanceof Error ? originalError.message : String(originalError));
+    this.originalError = originalError;
+    this.retryContext = retryContext;
+    this.name = "CannotRetryError";
+  }
+  originalError;
+  retryContext;
+};
+async function* withRetry(operation, options) {
+  const maxRetries = options.maxRetries ?? 10;
+  const baseDelayMs = options.baseDelayMs ?? 500;
+  const maxDelayMs = options.maxDelayMs ?? 32e3;
+  const maxConsecutiveOverloaded = options.maxConsecutiveOverloaded ?? 3;
+  const retryContext = {
+    attempt: 0,
+    model: options.model
+  };
+  let consecutiveOverloaded = 0;
+  let fallbackUsed = false;
+  let lastError;
+  let totalAttempts = 0;
+  for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
+    if (options.signal?.aborted) {
+      throw new DOMException("Aborted", "AbortError");
+    }
+    totalAttempts++;
+    retryContext.attempt = totalAttempts;
+    try {
+      const stream = operation(retryContext);
+      const iterator = toAsyncIterator(stream);
+      const first = await iterator.next();
+      if (first.done) {
+        throw new ChatStreamError("Provider returned empty stream", {
+          status: 502,
+          cause: new Error("empty_stream")
+        });
+      }
+      return prependChunk(first.value, iterator);
+    } catch (error) {
+      lastError = error;
+      const classified = classifyError(error);
+      if (classified.isContextOverflow && classified.contextOverflowData) {
+        const { inputTokens, contextLimit } = classified.contextOverflowData;
+        const safetyBuffer = 1e3;
+        const available = Math.max(0, contextLimit - inputTokens - safetyBuffer);
+        if (available < FLOOR_OUTPUT_TOKENS) {
+          throw new CannotRetryError(error, retryContext);
+        }
+        const minRequired = (options.thinkingBudget ?? 0) + 1;
+        retryContext.maxTokensOverride = Math.max(
+          FLOOR_OUTPUT_TOKENS,
+          available,
+          minRequired
+        );
+        continue;
+      }
+      if (classified.isOverloaded) {
+        consecutiveOverloaded++;
+        if (consecutiveOverloaded >= maxConsecutiveOverloaded && options.fallbackModel && !fallbackUsed) {
+          const previousModel = retryContext.model;
+          retryContext.model = options.fallbackModel;
+          consecutiveOverloaded = 0;
+          fallbackUsed = true;
+          yield {
+            type: "model_switch",
+            from: previousModel,
+            to: options.fallbackModel
+          };
+          yield {
+            type: "retry_attempt",
+            attempt: totalAttempts,
+            maxRetries,
+            delayMs: 0,
+            error: new Error(
+              `Model fallback: ${previousModel} \u2192 ${options.fallbackModel} after ${maxConsecutiveOverloaded} consecutive overloaded errors`
+            )
+          };
+          attempt = Math.max(attempt - Math.floor(maxRetries / 2), 1);
+          continue;
+        }
+      } else {
+        consecutiveOverloaded = 0;
+      }
+      if (!isRetryable(classified, options)) {
+        throw new CannotRetryError(error, retryContext);
+      }
+      if (totalAttempts > maxRetries) {
+        const exhaustedError = error instanceof Error ? error : new Error(String(error));
+        yield {
+          type: "retry_exhausted",
+          attempts: totalAttempts,
+          error: exhaustedError
+        };
+        throw new CannotRetryError(error, retryContext);
+      }
+      const delayMs = getRetryDelay(
+        attempt,
+        classified.retryAfter,
+        maxDelayMs,
+        baseDelayMs
+      );
+      const retryError = error instanceof Error ? error : new Error(String(error));
+      options.onRetry?.(totalAttempts, retryError, delayMs);
+      yield {
+        type: "retry_attempt",
+        attempt: totalAttempts,
+        maxRetries,
+        delayMs,
+        error: retryError
+      };
+      await sleep(delayMs, options.signal);
+    }
+  }
+  throw new CannotRetryError(lastError, retryContext);
+}
+function toAsyncIterator(iterable) {
+  return iterable[Symbol.asyncIterator]();
+}
+async function* prependChunk(first, rest) {
+  yield first;
+  let next = await rest.next();
+  while (!next.done) {
+    yield next.value;
+    next = await rest.next();
+  }
+}
+
+// src/providers/cache-safe-params.ts
+var cacheSafeParamsMap = /* @__PURE__ */ new Map();
+function saveCacheSafeParams(params, sessionId = "_default") {
+  if (params) {
+    cacheSafeParamsMap.set(sessionId, params);
+  } else {
+    cacheSafeParamsMap.delete(sessionId);
+  }
+}
+function getLastCacheSafeParams(sessionId = "_default") {
+  return cacheSafeParamsMap.get(sessionId) ?? null;
+}
+function createCacheSafeParams(opts) {
+  return {
+    systemPrompt: opts.systemPrompt,
+    model: opts.model,
+    tools: opts.tools,
+    thinking: opts.thinking
+  };
+}
+
+// src/memory/extraction.ts
+var MEMORY_TYPES = /* @__PURE__ */ new Set([
+  "user",
+  "project",
+  "feedback",
+  "reference"
+]);
+function summarizeRecentMessages(messages, maxMessages = 20) {
+  const recent = messages.slice(-maxMessages);
+  const lines = [];
+  for (const msg of recent) {
+    const role = msg.role.toUpperCase();
+    const text = typeof msg.content === "string" ? msg.content : "(non-text content)";
+    const truncated = text.length > 2e3 ? text.slice(0, 2e3) + "\u2026" : text;
+    lines.push(`[${role}] ${truncated}`);
+  }
+  return lines.join("\n\n");
+}
+async function extractMemories(llmProvider, model, messages, provider) {
+  const existingIndex = await provider.loadIndex();
+  const summary = summarizeRecentMessages(messages);
+  const prompt = buildExtractionPrompt(summary, existingIndex);
+  const extractionMessages = [
+    { role: "user", content: prompt }
+  ];
+  let responseText = "";
+  for await (const chunk of llmProvider.chat({
+    model,
+    messages: extractionMessages,
+    system: "You are a memory extraction assistant. Respond only with valid JSON.",
+    max_tokens: 4096
+  })) {
+    for (const choice of chunk.choices) {
+      if (choice.delta.content) {
+        responseText += choice.delta.content;
+      }
+    }
+  }
+  const parsed = parseExtractionResponse(responseText);
+  if (!parsed || parsed.memories.length === 0) {
+    return { created: [], updated: [], deleted: [] };
+  }
+  const result = {
+    created: [],
+    updated: [],
+    deleted: []
+  };
+  for (const action of parsed.memories) {
+    if (!MEMORY_TYPES.has(action.type)) continue;
+    if (action.action === "delete" && action.path) {
+      await provider.removeEntry(action.path);
+      result.deleted.push(action.path);
+    } else if (action.action === "update" && action.path) {
+      const entry = {
+        name: action.name,
+        description: action.description,
+        type: action.type,
+        content: action.content,
+        path: action.path,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await provider.saveEntry(entry);
+      result.updated.push(entry);
+    } else if (action.action === "create") {
+      const entry = {
+        name: action.name,
+        description: action.description,
+        type: action.type,
+        content: action.content,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await provider.saveEntry(entry);
+      result.created.push(entry);
+    }
+  }
+  return result;
+}
+function parseExtractionResponse(text) {
+  const trimmed = text.trim();
+  let jsonStr = trimmed;
+  if (jsonStr.startsWith("```")) {
+    const firstNewline = jsonStr.indexOf("\n");
+    jsonStr = jsonStr.slice(firstNewline + 1);
+    const lastFence = jsonStr.lastIndexOf("```");
+    if (lastFence !== -1) {
+      jsonStr = jsonStr.slice(0, lastFence);
+    }
+  }
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.memories)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/tools/execution-pipeline.ts
+async function executeToolCall(tc, parsedArgs, ctx) {
+  const {
+    registry,
+    toolCtx,
+    permCtx,
+    permHandler,
+    denialTracker,
+    hooks,
+    sessionId,
+    tracer,
+    parentSpan,
+    buildPermissionOpts
+  } = ctx;
+  let currentArgs = parsedArgs;
+  const events = [];
+  let preventContinuation = false;
+  try {
+    const toolDef = registry.get(tc.function.name);
+    if (toolDef?.inputSchema) {
+      const parsed = toolDef.inputSchema.safeParse(currentArgs);
+      if (!parsed.success) {
+        const { formatZodValidationError } = await import("./zod-VKURGPRT.js");
+        return {
+          toolCall: tc,
+          parsedArgs: currentArgs,
+          result: {
+            content: formatZodValidationError(tc.function.name, parsed.error),
+            isError: true
+          },
+          events
+        };
+      }
+      currentArgs = parsed.data;
+    }
+    if (toolDef?.validateInput) {
+      const validationError = await toolDef.validateInput(currentArgs, toolCtx);
+      if (validationError) {
+        return {
+          toolCall: tc,
+          parsedArgs: currentArgs,
+          result: {
+            content: `Validation error for ${tc.function.name}: ${validationError}`,
+            isError: true
+          },
+          events
+        };
+      }
+    }
+    if (hooks.length > 0) {
+      const hookOutput = await runPreToolUseHooks(hooks, {
+        event: "PreToolUse",
+        toolName: tc.function.name,
+        toolInput: currentArgs,
+        toolUseId: tc.id,
+        sessionId
+      });
+      if (hookOutput.decision === "deny") {
+        const msg = hookOutput.message ?? "Blocked by hook.";
+        return {
+          toolCall: tc,
+          parsedArgs: currentArgs,
+          result: { content: `Hook denied: ${msg}`, isError: true },
+          permissionDenied: true,
+          events
+        };
+      }
+      if (hookOutput.updatedInput) {
+        currentArgs = hookOutput.updatedInput;
+        if (permCtx && permCtx.workingDirectories.length > 0) {
+          const hookFilePath = typeof currentArgs.file_path === "string" ? currentArgs.file_path : typeof currentArgs.path === "string" ? currentArgs.path : void 0;
+          if (hookFilePath && !isPathInWorkingDirectories(hookFilePath, permCtx.workingDirectories)) {
+            return {
+              toolCall: tc,
+              parsedArgs: currentArgs,
+              result: {
+                content: `Permission denied: Hook-modified path "${hookFilePath}" is outside working directories.`,
+                isError: true
+              },
+              permissionDenied: true,
+              events
+            };
+          }
+        }
+      }
+      if (hookOutput.preventContinuation) {
+        preventContinuation = true;
+      }
+    }
+    if (permCtx) {
+      const tool = registry.get(tc.function.name);
+      if (tool) {
+        const decision = await resolvePermission(
+          tool,
+          currentArgs,
+          toolCtx,
+          permCtx,
+          buildPermissionOpts()
+        );
+        if (decision.behavior === "deny") {
+          if (decision.reason !== "classifier") {
+            denialTracker?.recordDenial();
+          }
+          events.push({
+            type: "permission_denied",
+            toolName: tc.function.name,
+            input: currentArgs,
+            message: decision.message
+          });
+          await runNotificationHooks(hooks, "PermissionDenied", {
+            event: "PermissionDenied",
+            sessionId,
+            toolName: tc.function.name,
+            input: currentArgs,
+            reason: decision.message
+          });
+          if (denialTracker?.shouldFallback().triggered) {
+            const state = denialTracker.getState();
+            events.push({
+              type: "denial_limit_exceeded",
+              consecutiveDenials: state.consecutiveDenials,
+              totalDenials: state.totalDenials
+            });
+            preventContinuation = true;
+          }
+          return {
+            toolCall: tc,
+            parsedArgs: currentArgs,
+            result: {
+              content: `Permission denied: ${decision.message}`,
+              isError: true
+            },
+            permissionDenied: true,
+            preventContinuation: preventContinuation || void 0,
+            events
+          };
+        }
+        if (decision.behavior === "ask") {
+          await runNotificationHooks(hooks, "PermissionRequest", {
+            event: "PermissionRequest",
+            sessionId,
+            toolName: tc.function.name,
+            input: currentArgs,
+            mode: permCtx.mode ?? "default"
+          });
+          events.push({
+            type: "permission_request",
+            toolName: tc.function.name,
+            input: currentArgs,
+            message: decision.message
+          });
+          if (permHandler) {
+            const signal = toolCtx.signal;
+            if (signal?.aborted) {
+              return {
+                toolCall: tc,
+                parsedArgs,
+                result: { content: "Error: Session aborted", isError: true },
+                permissionDenied: true,
+                events
+              };
+            }
+            const isReadOnly = resolveToolFlag(tool.isReadOnly, currentArgs);
+            const isDestructive = resolveToolFlag(tool.isDestructive, currentArgs);
+            const request = {
+              toolName: tc.function.name,
+              input: currentArgs,
+              message: decision.message,
+              suggestions: decision.suggestions,
+              isReadOnly,
+              isDestructive,
+              signal
+            };
+            const response = await (signal ? Promise.race([
+              permHandler(request),
+              new Promise((_, reject) => {
+                signal.addEventListener("abort", () => {
+                  reject(new DOMException("Permission prompt aborted", "AbortError"));
+                }, { once: true });
+              })
+            ]) : permHandler(request));
+            if (!response.allow) {
+              denialTracker?.recordDenial();
+              const feedback = response.feedback ?? "User denied permission.";
+              events.push({
+                type: "permission_denied",
+                toolName: tc.function.name,
+                input: currentArgs,
+                message: feedback
+              });
+              await runNotificationHooks(hooks, "PermissionDenied", {
+                event: "PermissionDenied",
+                sessionId,
+                toolName: tc.function.name,
+                input: currentArgs,
+                reason: feedback
+              });
+              if (denialTracker?.shouldFallback().triggered) {
+                const state = denialTracker.getState();
+                events.push({
+                  type: "denial_limit_exceeded",
+                  consecutiveDenials: state.consecutiveDenials,
+                  totalDenials: state.totalDenials
+                });
+                preventContinuation = true;
+              }
+              return {
+                toolCall: tc,
+                parsedArgs: currentArgs,
+                result: {
+                  content: `Permission denied: ${feedback}`,
+                  isError: true
+                },
+                permissionDenied: true,
+                preventContinuation: preventContinuation || void 0,
+                events
+              };
+            }
+            if (response.updatedInput) {
+              currentArgs = response.updatedInput;
+            }
+            if (response.addRules) {
+              permCtx.rules.push(...response.addRules);
+            }
+          } else {
+            denialTracker?.recordDenial();
+            events.push({
+              type: "permission_denied",
+              toolName: tc.function.name,
+              input: currentArgs,
+              message: "No permission handler configured."
+            });
+            await runNotificationHooks(hooks, "PermissionDenied", {
+              event: "PermissionDenied",
+              sessionId,
+              toolName: tc.function.name,
+              input: currentArgs,
+              reason: "No permission handler configured."
+            });
+            if (denialTracker?.shouldFallback().triggered) {
+              const state = denialTracker.getState();
+              events.push({
+                type: "denial_limit_exceeded",
+                consecutiveDenials: state.consecutiveDenials,
+                totalDenials: state.totalDenials
+              });
+              preventContinuation = true;
+            }
+            return {
+              toolCall: tc,
+              parsedArgs: currentArgs,
+              result: {
+                content: "Permission denied: No permission handler configured.",
+                isError: true
+              },
+              permissionDenied: true,
+              preventContinuation: preventContinuation || void 0,
+              events
+            };
+          }
+        }
+        denialTracker?.recordSuccess();
+        if (decision.behavior === "allow" && decision.updatedInput) {
+          currentArgs = decision.updatedInput;
+        }
+        events.push({
+          type: "permission_granted",
+          toolName: tc.function.name,
+          input: currentArgs
+        });
+      }
     }
-  }
-  createToolAbortController() {
-    const toolAc = new AbortController();
-    this.siblingAbortController.signal.addEventListener("abort", () => {
-      if (!toolAc.signal.aborted) {
-        toolAc.abort(this.siblingAbortController.signal.reason);
-      }
-    }, { once: true });
-    if (this.siblingAbortController.signal.aborted) {
-      toolAc.abort(this.siblingAbortController.signal.reason);
+    const toolSpan = tracer.startSpan("noumen.tool.execute", {
+      parent: parentSpan,
+      attributes: { "tool.name": tc.function.name, "tool.id": tc.id }
+    });
+    let result = await registry.execute(tc.function.name, currentArgs, toolCtx);
+    let resultText = contentToString(result.content);
+    if (ctx.maxResultChars && resultText.length > ctx.maxResultChars) {
+      const truncated = resultText.slice(0, ctx.maxResultChars);
+      const omitted = resultText.length - ctx.maxResultChars;
+      resultText = truncated + `
+
+[Result truncated: ${omitted} chars omitted]`;
+      result = { ...result, content: resultText };
     }
-    return toolAc;
-  }
-  async executeTool(tracked) {
-    if (this.discarded || this.siblingAbortController.signal.aborted) {
-      tracked.status = "completed";
-      tracked.result = { content: "Error: Executor was discarded", isError: true };
-      tracked.events = [];
-      this.progressResolve?.();
-      return;
+    toolSpan.setStatus(
+      result.isError ? SpanStatusCode.ERROR : SpanStatusCode.OK,
+      result.isError ? resultText : void 0
+    );
+    toolSpan.end();
+    if (hooks.length > 0) {
+      const postOutput = await runPostToolUseHooks(hooks, {
+        event: "PostToolUse",
+        toolName: tc.function.name,
+        toolInput: currentArgs,
+        toolUseId: tc.id,
+        toolOutput: resultText,
+        isError: result.isError ?? false,
+        sessionId
+      });
+      if (postOutput.updatedOutput !== void 0) {
+        result = { ...result, content: postOutput.updatedOutput };
+      }
+      if (postOutput.preventContinuation) {
+        preventContinuation = true;
+      }
+      if (result.isError) {
+        const failOutput = await runPostToolUseFailureHooks(hooks, {
+          event: "PostToolUseFailure",
+          toolName: tc.function.name,
+          toolInput: currentArgs,
+          toolUseId: tc.id,
+          toolOutput: contentToString(result.content),
+          errorMessage: contentToString(result.content),
+          sessionId
+        });
+        if (failOutput.updatedOutput !== void 0) {
+          result = { ...result, content: failOutput.updatedOutput };
+        }
+        if (failOutput.preventContinuation) {
+          preventContinuation = true;
+        }
+      }
     }
-    tracked.status = "executing";
-    const toolAc = this.createToolAbortController();
-    tracked.abortController = toolAc;
-    tracked.promise = (async () => {
+    return {
+      toolCall: tc,
+      parsedArgs: currentArgs,
+      result,
+      preventContinuation: preventContinuation || void 0,
+      events
+    };
+  } catch (execErr) {
+    const msg = execErr instanceof Error ? execErr.message : String(execErr);
+    const errorResult = { content: `Error executing tool: ${msg}`, isError: true };
+    if (hooks.length > 0) {
       try {
-        const { result, permissionDenied, preventContinuation, events } = await this.executeFn(
-          tracked.toolCall,
-          tracked.parsedArgs,
-          toolAc.signal
-        );
-        tracked.result = result;
-        tracked.permissionDenied = permissionDenied;
-        tracked.preventContinuation = preventContinuation;
-        tracked.events = events;
-        if (result.isError && tracked.toolCall.function.name === BASH_TOOL_NAME) {
-          this.hasErrored = true;
-          this.siblingAbortController.abort("sibling_error");
+        const failOutput = await runPostToolUseFailureHooks(hooks, {
+          event: "PostToolUseFailure",
+          toolName: tc.function.name,
+          toolInput: currentArgs,
+          toolUseId: tc.id,
+          toolOutput: errorResult.content,
+          errorMessage: msg,
+          sessionId
+        });
+        if (failOutput.updatedOutput !== void 0) {
+          errorResult.content = failOutput.updatedOutput;
         }
-      } catch (err) {
-        tracked.result = {
-          content: `Error: ${err instanceof Error ? err.message : String(err)}`,
-          isError: true
-        };
-        tracked.events = [];
-        if (tracked.toolCall.function.name === BASH_TOOL_NAME) {
-          this.hasErrored = true;
-          this.siblingAbortController.abort("sibling_error");
+        if (failOutput.preventContinuation) {
+          preventContinuation = true;
         }
+      } catch {
       }
-      tracked.status = "completed";
-      this.progressResolve?.();
-    })();
-    void tracked.promise.finally(() => void this.processQueue());
+    }
+    return {
+      toolCall: tc,
+      parsedArgs: currentArgs,
+      result: errorResult,
+      preventContinuation: preventContinuation || void 0,
+      events
+    };
   }
-  *getCompletedResults() {
-    if (this.discarded) return;
-    for (const tool of this.tools) {
-      if (tool.status === "yielded") continue;
-      if (tool.status === "completed" && tool.result) {
-        tool.status = "yielded";
-        yield {
-          toolCall: tool.toolCall,
-          parsedArgs: tool.parsedArgs,
-          result: tool.result,
-          permissionDenied: tool.permissionDenied,
-          preventContinuation: tool.preventContinuation,
-          events: tool.events
-        };
-      } else if (tool.status === "executing" && !tool.isConcurrencySafe) {
-        break;
-      }
+}
+
+// src/pipeline/prepare-messages.ts
+async function prepareMessagesForApi(messages, config, state) {
+  const events = [];
+  let canonical = messages;
+  let contentReplacementState = state.contentReplacementState;
+  let budgetState = state.budgetState;
+  let microcompactTokensFreed = state.microcompactTokensFreed;
+  if (config.toolResultStorage?.enabled && config.fs) {
+    const storageResult = await enforceToolResultStorageBudget(
+      canonical,
+      config.toolResultStorage,
+      config.fs,
+      config.sessionId,
+      contentReplacementState
+    );
+    if (storageResult.tokensFreed > 0) {
+      canonical = storageResult.messages;
+      contentReplacementState = storageResult.state;
+      microcompactTokensFreed += storageResult.tokensFreed;
     }
   }
-  async *getRemainingResults() {
-    if (this.discarded) {
-      for (const tool of this.tools) {
-        if (tool.status === "yielded") continue;
-        if (tool.status === "completed" && tool.result) {
-          tool.status = "yielded";
-          yield {
-            toolCall: tool.toolCall,
-            parsedArgs: tool.parsedArgs,
-            result: tool.result,
-            permissionDenied: tool.permissionDenied,
-            preventContinuation: tool.preventContinuation,
-            events: tool.events
-          };
-          continue;
-        }
-        tool.status = "yielded";
-        yield {
-          toolCall: tool.toolCall,
-          parsedArgs: tool.parsedArgs,
-          result: { content: "Error: Executor was discarded", isError: true },
-          events: []
-        };
-      }
-      return;
+  if (config.microcompact?.enabled) {
+    const mcResult = microcompactMessages(canonical, config.microcompact);
+    if (mcResult.tokensFreed > 0) {
+      canonical = mcResult.messages;
+      microcompactTokensFreed += mcResult.tokensFreed;
+      events.push({ type: "microcompact_complete", tokensFreed: mcResult.tokensFreed });
     }
-    while (this.hasUnfinished()) {
-      if (this.discarded) return;
-      await this.processQueue();
-      for (const result of this.getCompletedResults()) {
-        yield result;
+  }
+  let messagesForApi = canonical;
+  if (config.toolResultBudget?.enabled) {
+    const budgetResult = enforceToolResultBudget(
+      [...canonical],
+      config.toolResultBudget,
+      budgetState
+    );
+    messagesForApi = budgetResult.messages;
+    budgetState = budgetResult.state;
+    microcompactTokensFreed += budgetResult.tokensFreed;
+    for (const entry of budgetResult.truncatedEntries) {
+      events.push({
+        type: "tool_result_truncated",
+        toolCallId: entry.toolCallId,
+        originalChars: entry.originalChars,
+        truncatedChars: entry.truncatedChars
+      });
+    }
+  }
+  messagesForApi = normalizeMessagesForAPI(messagesForApi);
+  if (config.debug) {
+    assertValidMessageSequence(messagesForApi);
+  }
+  return {
+    messagesForApi,
+    canonicalMessages: canonical,
+    state: {
+      contentReplacementState,
+      budgetState,
+      microcompactTokensFreed
+    },
+    events
+  };
+}
+
+// src/pipeline/auto-compact-step.ts
+async function tryAutoCompactStep(messages, config, provider, model, state, hooks, sessionId, storage) {
+  if (!canAutoCompact(state.autoCompactTracking) || !shouldAutoCompact(
+    messages,
+    config,
+    state.lastUsage,
+    state.anchorMessageIndex,
+    state.microcompactTokensFreed,
+    state.querySource
+  )) {
+    return { compacted: false, events: [] };
+  }
+  const events = [];
+  await runNotificationHooks(hooks, "PreCompact", {
+    event: "PreCompact",
+    sessionId
+  });
+  events.push({ type: "compact_start" });
+  try {
+    const compactedMessages = await compactConversation(
+      provider,
+      model,
+      messages,
+      storage,
+      sessionId,
+      {
+        tailMessagesToKeep: config.tailMessagesToKeep,
+        stripBinaryContent: true,
+        signal: state.signal,
+        recentlyReadFiles: state.recentlyReadFiles && state.recentlyReadFiles.size > 0 ? state.recentlyReadFiles : void 0
       }
-      if (this.hasExecuting() && !this.hasCompleted()) {
-        const executingPromises = this.tools.filter((t) => t.status === "executing" && t.promise).map((t) => t.promise);
-        const progressPromise = new Promise((resolve3) => {
-          this.progressResolve = resolve3;
+    );
+    recordAutoCompactSuccess(state.autoCompactTracking);
+    events.push({ type: "compact_complete" });
+    await runNotificationHooks(hooks, "PostCompact", {
+      event: "PostCompact",
+      sessionId
+    });
+    return { compacted: true, messages: compactedMessages, events };
+  } catch (compactErr) {
+    recordAutoCompactFailure(state.autoCompactTracking);
+    const error = compactErr instanceof Error ? compactErr : new Error(`Compaction failed: ${String(compactErr)}`);
+    await runNotificationHooks(hooks, "Error", {
+      event: "Error",
+      sessionId,
+      error
+    });
+    events.push({ type: "auto_compact_failed", error });
+    return { compacted: false, events };
+  }
+}
+
+// src/pipeline/execute-tools-step.ts
+var FILE_TOOLS = /* @__PURE__ */ new Set(["ReadFile", "WriteFile", "EditFile"]);
+async function processToolResult(execResult, spillFn, messages, recentlyReadFiles, storage, sessionId) {
+  const events = [];
+  for (const evt of execResult.events ?? []) {
+    events.push(evt);
+  }
+  if (!execResult.permissionDenied) {
+    events.push({
+      type: "tool_result",
+      toolUseId: execResult.toolCall.id,
+      toolName: execResult.toolCall.function.name,
+      result: execResult.result
+    });
+    const gitOps = execResult.result.metadata?.gitOperations;
+    if (gitOps) {
+      for (const op of gitOps) {
+        events.push({
+          type: "git_operation",
+          operation: op.type,
+          details: op.details
         });
-        if (executingPromises.length > 0) {
-          await Promise.race([...executingPromises, progressPromise]);
-        }
       }
     }
-    for (const result of this.getCompletedResults()) {
-      yield result;
-    }
-  }
-  hasUnfinished() {
-    return this.tools.some(
-      (t) => t.status === "queued" || t.status === "executing"
-    );
-  }
-  hasExecuting() {
-    return this.tools.some((t) => t.status === "executing");
   }
-  hasCompleted() {
-    return this.tools.some(
-      (t) => t.status === "completed" && t.result !== void 0
+  let resultContent = execResult.result.content;
+  let spillRecord;
+  if (typeof resultContent === "string") {
+    const spill = await spillFn(
+      execResult.toolCall.id,
+      execResult.toolCall.function.name,
+      resultContent
     );
+    if (spill.spilled) {
+      resultContent = spill.content;
+      spillRecord = { toolUseId: execResult.toolCall.id, replacement: spill.content };
+    }
   }
-};
-
-// src/retry/backoff.ts
-var DEFAULT_BASE_DELAY_MS = 500;
-function getRetryDelay(attempt, retryAfterHeader, maxDelayMs = 32e3, baseDelayMs = DEFAULT_BASE_DELAY_MS) {
-  if (retryAfterHeader) {
-    const seconds = parseInt(retryAfterHeader, 10);
-    if (!isNaN(seconds)) {
-      return seconds * 1e3;
+  const toolResultMsg = {
+    role: "tool",
+    tool_call_id: execResult.toolCall.id,
+    content: resultContent,
+    ...execResult.result.isError ? { isError: true } : {}
+  };
+  messages.push(toolResultMsg);
+  await storage.appendMessage(sessionId, toolResultMsg);
+  let touchedPath;
+  if (FILE_TOOLS.has(execResult.toolCall.function.name) && typeof execResult.parsedArgs.file_path === "string") {
+    touchedPath = execResult.parsedArgs.file_path;
+    if (execResult.toolCall.function.name === "ReadFile" && !execResult.result.isError) {
+      const content = typeof execResult.result.content === "string" ? execResult.result.content : "";
+      recentlyReadFiles.set(execResult.parsedArgs.file_path, content);
     }
   }
-  const baseDelay = Math.min(
-    baseDelayMs * Math.pow(2, attempt - 1),
-    maxDelayMs
-  );
-  const jitter = Math.random() * 0.25 * baseDelay;
-  return baseDelay + jitter;
+  return {
+    events,
+    touchedPath,
+    spillRecord,
+    preventContinuation: !!execResult.preventContinuation
+  };
 }
-function sleep(ms, signal) {
-  return new Promise((resolve3, reject) => {
-    if (signal?.aborted) {
-      reject(new DOMException("Aborted", "AbortError"));
-      return;
+async function executeToolsStep(toolCalls, streamingExec, streamingResults, execCtx, registry, sessionId, messages, recentlyReadFiles, storage, spillFn) {
+  const allEvents = [];
+  const touchedFilePaths = [];
+  const spilledRecords = [];
+  let preventContinuation = false;
+  const handleResult = async (execResult) => {
+    const processed = await processToolResult(
+      execResult,
+      spillFn,
+      messages,
+      recentlyReadFiles,
+      storage,
+      sessionId
+    );
+    allEvents.push(...processed.events);
+    if (processed.touchedPath) touchedFilePaths.push(processed.touchedPath);
+    if (processed.spillRecord) spilledRecords.push(processed.spillRecord);
+    if (processed.preventContinuation) preventContinuation = true;
+  };
+  if (streamingExec) {
+    const allResults = [...streamingResults];
+    for await (const result of streamingExec.getRemainingResults()) {
+      allResults.push(result);
     }
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(new DOMException("Aborted", "AbortError"));
+    for (const execResult of allResults) {
+      await handleResult(execResult);
+    }
+  } else {
+    const executor = async (tc, parsedArgs) => {
+      const pipelineResult = await executeToolCall(tc, parsedArgs, execCtx);
+      if (pipelineResult.preventContinuation) preventContinuation = true;
+      return pipelineResult;
     };
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve3();
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
+    for await (const execResult of runToolsBatched(
+      toolCalls,
+      (name) => registry.get(name),
+      executor
+    )) {
+      await handleResult(execResult);
+    }
+  }
+  return { events: allEvents, touchedFilePaths, preventContinuation, spilledRecords };
 }
 
-// src/retry/engine.ts
-var FLOOR_OUTPUT_TOKENS = 3e3;
-var CannotRetryError = class extends Error {
-  constructor(originalError, retryContext) {
-    super(originalError instanceof Error ? originalError.message : String(originalError));
-    this.originalError = originalError;
-    this.retryContext = retryContext;
-    this.name = "CannotRetryError";
-  }
-  originalError;
-  retryContext;
-};
-async function* withRetry(operation, options) {
-  const maxRetries = options.maxRetries ?? 10;
-  const baseDelayMs = options.baseDelayMs ?? 500;
-  const maxDelayMs = options.maxDelayMs ?? 32e3;
-  const maxConsecutiveOverloaded = options.maxConsecutiveOverloaded ?? 3;
-  const retryContext = {
-    attempt: 0,
-    model: options.model
-  };
-  let consecutiveOverloaded = 0;
-  let fallbackUsed = false;
-  let lastError;
-  let totalAttempts = 0;
-  for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
-    if (options.signal?.aborted) {
-      throw new DOMException("Aborted", "AbortError");
-    }
-    totalAttempts++;
-    retryContext.attempt = totalAttempts;
-    try {
-      const stream = operation(retryContext);
-      const iterator = toAsyncIterator(stream);
-      const first = await iterator.next();
-      if (first.done) {
-        throw new ChatStreamError("Provider returned empty stream", {
-          status: 502,
-          cause: new Error("empty_stream")
-        });
+// src/pipeline/initialize-session.ts
+async function initializeSession(params) {
+  const {
+    storage,
+    sessionId,
+    hooks,
+    prompt,
+    isResumeRun,
+    checkpointManager,
+    costTracker,
+    toolResultStorage,
+    fs
+  } = params;
+  let { messages, contentReplacementState, loaded, resumeRequested } = params;
+  const events = [];
+  if (!loaded) {
+    if (resumeRequested) {
+      const payload = await restoreSession(storage, sessionId);
+      messages = payload.messages;
+      if (checkpointManager && payload.checkpointSnapshots.length > 0) {
+        checkpointManager.restoreStateFromEntries(payload.checkpointSnapshots);
+      }
+      if (costTracker && payload.costState) {
+        costTracker.restore(payload.costState);
+      }
+      if (payload.contentReplacements.length > 0) {
+        contentReplacementState = reconstructContentReplacementState(
+          payload.contentReplacements,
+          messages
+        );
+        messages = applyPersistedReplacements(
+          messages,
+          contentReplacementState
+        );
       }
-      return prependChunk(first.value, iterator);
-    } catch (error) {
-      lastError = error;
-      const classified = classifyError(error);
-      if (classified.isContextOverflow && classified.contextOverflowData) {
-        const { inputTokens, contextLimit } = classified.contextOverflowData;
-        const safetyBuffer = 1e3;
-        const available = Math.max(0, contextLimit - inputTokens - safetyBuffer);
-        if (available < FLOOR_OUTPUT_TOKENS) {
-          throw new CannotRetryError(error, retryContext);
-        }
-        const minRequired = (options.thinkingBudget ?? 0) + 1;
-        retryContext.maxTokensOverride = Math.max(
-          FLOOR_OUTPUT_TOKENS,
-          available,
-          minRequired
+      if (toolResultStorage?.enabled && fs) {
+        const storageResult = await enforceToolResultStorageBudget(
+          messages,
+          toolResultStorage,
+          fs,
+          sessionId,
+          contentReplacementState
         );
-        continue;
+        messages = storageResult.messages;
+        contentReplacementState = storageResult.state;
       }
-      if (classified.isOverloaded) {
-        consecutiveOverloaded++;
-        if (consecutiveOverloaded >= maxConsecutiveOverloaded && options.fallbackModel && !fallbackUsed) {
-          const previousModel = retryContext.model;
-          retryContext.model = options.fallbackModel;
-          consecutiveOverloaded = 0;
-          fallbackUsed = true;
-          yield {
-            type: "model_switch",
-            from: previousModel,
-            to: options.fallbackModel
-          };
-          yield {
-            type: "retry_attempt",
-            attempt: totalAttempts,
-            maxRetries,
-            delayMs: 0,
-            error: new Error(
-              `Model fallback: ${previousModel} \u2192 ${options.fallbackModel} after ${maxConsecutiveOverloaded} consecutive overloaded errors`
-            )
-          };
-          attempt = Math.max(attempt - Math.floor(maxRetries / 2), 1);
-          continue;
+      for (const [filterName, count] of Object.entries(payload.recoveryRemovals)) {
+        if (count > 0) {
+          events.push({ type: "recovery_filtered", filterName, removedCount: count });
         }
-      } else {
-        consecutiveOverloaded = 0;
-      }
-      if (!isRetryable(classified, options)) {
-        throw new CannotRetryError(error, retryContext);
       }
-      if (totalAttempts > maxRetries) {
-        const exhaustedError = error instanceof Error ? error : new Error(String(error));
-        yield {
-          type: "retry_exhausted",
-          attempts: totalAttempts,
-          error: exhaustedError
-        };
-        throw new CannotRetryError(error, retryContext);
+      if (payload.interruption.kind !== "none") {
+        events.push({
+          type: "interrupted_turn_detected",
+          kind: payload.interruption.kind
+        });
       }
-      const delayMs = getRetryDelay(
-        attempt,
-        classified.retryAfter,
-        maxDelayMs,
-        baseDelayMs
-      );
-      const retryError = error instanceof Error ? error : new Error(String(error));
-      options.onRetry?.(totalAttempts, retryError, delayMs);
-      yield {
-        type: "retry_attempt",
-        attempt: totalAttempts,
-        maxRetries,
-        delayMs,
-        error: retryError
-      };
-      await sleep(delayMs, options.signal);
+      resumeRequested = false;
+      events.push({ type: "session_resumed", sessionId, messageCount: messages.length });
+    } else {
+      messages = await storage.loadMessages(sessionId);
     }
+    loaded = true;
   }
-  throw new CannotRetryError(lastError, retryContext);
-}
-function toAsyncIterator(iterable) {
-  return iterable[Symbol.asyncIterator]();
-}
-async function* prependChunk(first, rest) {
-  yield first;
-  let next = await rest.next();
-  while (!next.done) {
-    yield next.value;
-    next = await rest.next();
+  const userMessage = { role: "user", content: prompt };
+  messages.push(userMessage);
+  await storage.appendMessage(sessionId, userMessage);
+  const turnMessageId = generateUUID();
+  if (checkpointManager) {
+    await checkpointManager.makeSnapshot(turnMessageId, sessionId);
+    await storage.appendCheckpointEntry(
+      sessionId,
+      turnMessageId,
+      checkpointManager.getState().snapshots.at(-1),
+      false
+    );
+    events.push({ type: "checkpoint_snapshot", messageId: turnMessageId });
   }
+  await runNotificationHooks(hooks, "SessionStart", {
+    event: "SessionStart",
+    sessionId,
+    prompt,
+    isResume: isResumeRun
+  });
+  return {
+    messages,
+    contentReplacementState,
+    events,
+    loaded,
+    resumeRequested,
+    turnMessageId
+  };
 }
 
 // src/pipeline/consume-stream.ts
@@ -6410,27 +6339,6 @@ async function tryReactiveCompactRecovery(input) {
   return { recovered: false, events };
 }
 
-// src/providers/cache-safe-params.ts
-var cacheSafeParamsMap = /* @__PURE__ */ new Map();
-function saveCacheSafeParams(params, sessionId = "_default") {
-  if (params) {
-    cacheSafeParamsMap.set(sessionId, params);
-  } else {
-    cacheSafeParamsMap.delete(sessionId);
-  }
-}
-function getLastCacheSafeParams(sessionId = "_default") {
-  return cacheSafeParamsMap.get(sessionId) ?? null;
-}
-function createCacheSafeParams(opts) {
-  return {
-    systemPrompt: opts.systemPrompt,
-    model: opts.model,
-    tools: opts.tools,
-    thinking: opts.thinking
-  };
-}
-
 // src/pipeline/provider-round.ts
 var MAX_CONSECUTIVE_MALFORMED = 5;
 async function* executeProviderRound(p) {
@@ -6992,112 +6900,13 @@ async function postToolStep(params) {
   await runNotificationHooks(hooks, "TurnEnd", { event: "TurnEnd", sessionId });
   return {
     events,
-    preventContinuation,
-    shouldBreak: false,
-    shouldContinue: true,
-    hasAttemptedReactiveCompactReset: true,
-    systemPrompt,
-    toolDefs
-  };
-}
-
-// src/memory/extraction.ts
-var MEMORY_TYPES = /* @__PURE__ */ new Set([
-  "user",
-  "project",
-  "feedback",
-  "reference"
-]);
-function summarizeRecentMessages(messages, maxMessages = 20) {
-  const recent = messages.slice(-maxMessages);
-  const lines = [];
-  for (const msg of recent) {
-    const role = msg.role.toUpperCase();
-    const text = typeof msg.content === "string" ? msg.content : "(non-text content)";
-    const truncated = text.length > 2e3 ? text.slice(0, 2e3) + "\u2026" : text;
-    lines.push(`[${role}] ${truncated}`);
-  }
-  return lines.join("\n\n");
-}
-async function extractMemories(llmProvider, model, messages, provider) {
-  const existingIndex = await provider.loadIndex();
-  const summary = summarizeRecentMessages(messages);
-  const prompt = buildExtractionPrompt(summary, existingIndex);
-  const extractionMessages = [
-    { role: "user", content: prompt }
-  ];
-  let responseText = "";
-  for await (const chunk of llmProvider.chat({
-    model,
-    messages: extractionMessages,
-    system: "You are a memory extraction assistant. Respond only with valid JSON.",
-    max_tokens: 4096
-  })) {
-    for (const choice of chunk.choices) {
-      if (choice.delta.content) {
-        responseText += choice.delta.content;
-      }
-    }
-  }
-  const parsed = parseExtractionResponse(responseText);
-  if (!parsed || parsed.memories.length === 0) {
-    return { created: [], updated: [], deleted: [] };
-  }
-  const result = {
-    created: [],
-    updated: [],
-    deleted: []
-  };
-  for (const action of parsed.memories) {
-    if (!MEMORY_TYPES.has(action.type)) continue;
-    if (action.action === "delete" && action.path) {
-      await provider.removeEntry(action.path);
-      result.deleted.push(action.path);
-    } else if (action.action === "update" && action.path) {
-      const entry = {
-        name: action.name,
-        description: action.description,
-        type: action.type,
-        content: action.content,
-        path: action.path,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await provider.saveEntry(entry);
-      result.updated.push(entry);
-    } else if (action.action === "create") {
-      const entry = {
-        name: action.name,
-        description: action.description,
-        type: action.type,
-        content: action.content,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await provider.saveEntry(entry);
-      result.created.push(entry);
-    }
-  }
-  return result;
-}
-function parseExtractionResponse(text) {
-  const trimmed = text.trim();
-  let jsonStr = trimmed;
-  if (jsonStr.startsWith("```")) {
-    const firstNewline = jsonStr.indexOf("\n");
-    jsonStr = jsonStr.slice(firstNewline + 1);
-    const lastFence = jsonStr.lastIndexOf("```");
-    if (lastFence !== -1) {
-      jsonStr = jsonStr.slice(0, lastFence);
-    }
-  }
-  try {
-    const parsed = JSON.parse(jsonStr);
-    if (parsed && typeof parsed === "object" && Array.isArray(parsed.memories)) {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
+    preventContinuation,
+    shouldBreak: false,
+    shouldContinue: true,
+    hasAttemptedReactiveCompactReset: true,
+    systemPrompt,
+    toolDefs
+  };
 }
 
 // src/pipeline/finalize-turn.ts
@@ -7257,7 +7066,8 @@ var Thread = class {
       this.permissionContext = {
         mode: config.permissions.mode ?? "default",
         rules: [...config.permissions.rules ?? []],
-        workingDirectories: [...config.permissions.workingDirectories ?? []]
+        workingDirectories: [...config.permissions.workingDirectories ?? []],
+        dotDirNames: config.dotDirResolver?.config.names
       };
       this.permissionHandler = config.permissions.handler ?? null;
       if (config.permissions.denialTracking) {
@@ -7389,7 +7199,8 @@ var Thread = class {
           toolCtx.cwd = newCwd;
         },
         fileStateCache: this.fileStateCache ?? void 0,
-        notifyHook: this.hooks.length > 0 ? (event, input) => runNotificationHooks(this.hooks, event, input) : void 0
+        notifyHook: this.hooks.length > 0 ? (event, input) => runNotificationHooks(this.hooks, event, input) : void 0,
+        dotDirResolver: this.config.dotDirResolver
       };
       const turnUsage = {
         prompt_tokens: 0,
@@ -7812,7 +7623,7 @@ var Thread = class {
     if (uuids.length === 0) return;
     await this.storage.appendSnipBoundary(this.sessionId, uuids);
     const entries = await this.storage.loadAllEntries(this.sessionId);
-    const { applySnipRemovals: applySnipRemovals2 } = await import("./history-snip-64GYP4ZL.js");
+    const { applySnipRemovals: applySnipRemovals2 } = await import("./history-snip-HAWNAYKY.js");
     let lastBoundaryIdx = -1;
     for (let i = entries.length - 1; i >= 0; i--) {
       if (entries[i].type === "compact-boundary") {
@@ -7869,16 +7680,16 @@ var Thread = class {
 };
 
 // src/skills/loader.ts
-async function loadSkills(fs2, paths) {
+async function loadSkills(fs, paths) {
   const skills = [];
   for (const skillPath of paths) {
     try {
-      const stat2 = await fs2.stat(skillPath);
-      if (stat2.isFile) {
-        const skill = await loadSkillFile(fs2, skillPath);
+      const stat = await fs.stat(skillPath);
+      if (stat.isFile) {
+        const skill = await loadSkillFile(fs, skillPath);
         if (skill) skills.push(skill);
-      } else if (stat2.isDirectory) {
-        const dirSkills = await loadSkillsFromDir(fs2, skillPath);
+      } else if (stat.isDirectory) {
+        const dirSkills = await loadSkillsFromDir(fs, skillPath);
         skills.push(...dirSkills);
       }
     } catch {
@@ -7886,9 +7697,9 @@ async function loadSkills(fs2, paths) {
   }
   return skills;
 }
-async function loadSkillFile(fs2, filePath) {
+async function loadSkillFile(fs, filePath) {
   try {
-    const raw = await fs2.readFile(filePath);
+    const raw = await fs.readFile(filePath);
     const { frontmatter, body } = parseFrontmatter(raw);
     const name = extractSkillName(filePath, body);
     const fmDescription = frontmatter.description;
@@ -7911,17 +7722,17 @@ async function loadSkillFile(fs2, filePath) {
     return null;
   }
 }
-async function loadSkillsFromDir(fs2, dirPath) {
+async function loadSkillsFromDir(fs, dirPath) {
   const skills = [];
   try {
-    const entries = await fs2.readdir(dirPath);
+    const entries = await fs.readdir(dirPath);
     for (const entry of entries) {
       if (entry.isFile && (entry.name === "SKILL.md" || entry.name.endsWith(".md"))) {
-        const skill = await loadSkillFile(fs2, entry.path);
+        const skill = await loadSkillFile(fs, entry.path);
         if (skill) skills.push(skill);
       } else if (entry.isDirectory) {
         const skillMdPath = `${entry.path}/SKILL.md`;
-        const skill = await loadSkillFile(fs2, skillMdPath);
+        const skill = await loadSkillFile(fs, skillMdPath);
         if (skill) skills.push(skill);
       }
     }
@@ -7950,16 +7761,41 @@ function extractDescription(content) {
   return void 0;
 }
 
+// src/retry/types.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 10,
+  baseDelayMs: 500,
+  maxDelayMs: 32e3,
+  retryableStatuses: [408, 409, 429, 500, 502, 503, 504, 529],
+  maxConsecutiveOverloaded: 3
+};
+
 // src/prompt/context.ts
 async function buildUserContext(opts) {
-  let skills = [];
+  const ordered = [];
+  if (opts.dotDirResolver) {
+    if (opts.homeDir) {
+      const homeDirs = opts.dotDirResolver.candidates(opts.homeDir).slice().reverse().map((d) => `${d}/skills`);
+      const homeSkills = await loadSkills(opts.fs, homeDirs);
+      ordered.push(...homeSkills);
+    }
+    if (opts.cwd) {
+      const ancestors = walkAncestors2(opts.cwd);
+      for (const ancestor of ancestors) {
+        const ancestorDirs = opts.dotDirResolver.candidates(ancestor).slice().reverse().map((d) => `${d}/skills`);
+        const ancestorSkills = await loadSkills(opts.fs, ancestorDirs);
+        ordered.push(...ancestorSkills);
+      }
+    }
+  }
   if (opts.skillsPaths && opts.skillsPaths.length > 0) {
     const loaded = await loadSkills(opts.fs, opts.skillsPaths);
-    skills.push(...loaded);
+    ordered.push(...loaded);
   }
   if (opts.inlineSkills) {
-    skills.push(...opts.inlineSkills);
+    ordered.push(...opts.inlineSkills);
   }
+  const skills = dedupeSkillsByName(ordered);
   const date = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
     weekday: "long",
     year: "numeric",
@@ -7968,15 +7804,23 @@ async function buildUserContext(opts) {
   });
   return { skills, date };
 }
-
-// src/retry/types.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 10,
-  baseDelayMs: 500,
-  maxDelayMs: 32e3,
-  retryableStatuses: [408, 409, 429, 500, 502, 503, 504, 529],
-  maxConsecutiveOverloaded: 3
-};
+function dedupeSkillsByName(skills) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    byName.set(skill.name, skill);
+  }
+  return Array.from(byName.values());
+}
+function walkAncestors2(cwd) {
+  const normalized = cwd.endsWith("/") && cwd.length > 1 ? cwd.slice(0, -1) : cwd;
+  const parts = normalized.split("/");
+  const dirs = [];
+  for (let i = 1; i <= parts.length; i++) {
+    const dir = parts.slice(0, i).join("/") || "/";
+    dirs.push(dir);
+  }
+  return dirs;
+}
 
 // src/diagnostics.ts
 async function timedCheck(fn, timeoutMs) {
@@ -8010,9 +7854,9 @@ async function checkProviderHealth(provider, model, timeoutMs) {
     return { ok: false, latencyMs: 0, error: formatDiagError(err), model };
   }
 }
-async function checkVirtualFs(fs2, timeoutMs) {
+async function checkVirtualFs(fs, timeoutMs) {
   try {
-    const { latencyMs } = await timedCheck(async () => fs2.exists("/"), timeoutMs);
+    const { latencyMs } = await timedCheck(async () => fs.exists("/"), timeoutMs);
     return { ok: true, latencyMs };
   } catch (err) {
     return { ok: false, latencyMs: 0, error: formatDiagError(err) };
@@ -8034,9 +7878,9 @@ async function checkVirtualComputer(computer, timeoutMs) {
 }
 async function checkSandboxRuntime() {
   try {
-    const { SandboxManager: SandboxManager2 } = await import("@anthropic-ai/sandbox-runtime");
-    const supported = SandboxManager2.isSupportedPlatform();
-    const deps = SandboxManager2.checkDependencies();
+    const { SandboxManager } = await import("@anthropic-ai/sandbox-runtime");
+    const supported = SandboxManager.isSupportedPlatform();
+    const deps = SandboxManager.checkDependencies();
     const hasErrors = deps.errors.length > 0;
     if (supported && !hasErrors) {
       return {
@@ -8101,11 +7945,16 @@ function resolveAgentConfig(input) {
   } else if (typeof input.retry === "object") {
     retryConfig = input.retry;
   }
+  const dotDirs = input.dotDirs ?? DEFAULT_DOT_DIRS;
+  const dotDirResolver = createDotDirResolver(dotDirs);
   let projectContextConfig;
   if (input.projectContext === true) {
-    projectContextConfig = { cwd: effectiveCwd };
+    projectContextConfig = { cwd: effectiveCwd, dotDirs };
   } else if (typeof input.projectContext === "object") {
-    projectContextConfig = input.projectContext;
+    projectContextConfig = {
+      ...input.projectContext,
+      dotDirs: input.projectContext.dotDirs ?? dotDirs
+    };
   }
   const mcpServerConfigs = input.mcpServers && Object.keys(input.mcpServers).length > 0 ? input.mcpServers : void 0;
   const lspConfigs = input.lsp && Object.keys(input.lsp).length > 0 ? input.lsp : void 0;
@@ -8114,7 +7963,9 @@ function resolveAgentConfig(input) {
     retryConfig,
     projectContextConfig,
     mcpServerConfigs,
-    lspConfigs
+    lspConfigs,
+    dotDirs,
+    dotDirResolver
   };
 }
 
@@ -8169,6 +8020,7 @@ var Agent = class {
   toolSearchEnabled;
   projectContextConfig;
   resolvedProjectContext = null;
+  dotDirResolver;
   checkpointManager = null;
   promptCachingConfig;
   fileStateCacheConfig;
@@ -8197,13 +8049,15 @@ var Agent = class {
       retry: opts.options?.retry,
       projectContext: opts.options?.projectContext,
       mcpServers: opts.options?.mcpServers,
-      lsp: opts.options?.lsp
+      lsp: opts.options?.lsp,
+      dotDirs: opts.options?.dotDirs
     });
-    const resolvedSandbox = opts.sandbox ?? UnsandboxedLocal({ cwd: resolved.effectiveCwd });
+    const resolvedSandbox = opts.sandbox;
     this.sandbox = resolvedSandbox;
     this.fs = resolvedSandbox.fs;
     this.computer = resolvedSandbox.computer;
-    this.sessionDir = opts.options?.sessionDir ?? ".noumen/sessions";
+    this.dotDirResolver = resolved.dotDirResolver;
+    this.sessionDir = opts.options?.sessionDir ?? `${resolved.dotDirResolver.writePath(resolved.effectiveCwd)}/sessions`;
     this.skills = opts.options?.skills ?? [];
     this.skillsPaths = opts.options?.skillsPaths ?? [];
     this.tools = opts.options?.tools ?? [];
@@ -8219,7 +8073,7 @@ var Agent = class {
     this.enableSubagents = opts.options?.enableSubagents ?? false;
     this.enableTasks = opts.options?.enableTasks ?? false;
     if (this.enableTasks) {
-      const tasksDir = opts.options?.tasksDir ?? ".noumen/tasks";
+      const tasksDir = opts.options?.tasksDir ?? `${this.dotDirResolver.writePath(resolved.effectiveCwd)}/tasks`;
       this.taskStore = new TaskStore(this.fs, tasksDir);
     }
     this.enablePlanMode = opts.options?.enablePlanMode ?? false;
@@ -8250,7 +8104,10 @@ var Agent = class {
     this.projectContextConfig = resolved.projectContextConfig;
     this.promptCachingConfig = opts.options?.promptCaching;
     this.fileStateCacheConfig = opts.options?.fileStateCache;
-    this.toolResultStorageConfig = opts.options?.toolResultStorage;
+    this.toolResultStorageConfig = opts.options?.toolResultStorage ? {
+      ...opts.options.toolResultStorage,
+      storageDir: opts.options.toolResultStorage.storageDir ?? `${this.dotDirResolver.writePath(resolved.effectiveCwd)}/tool-results`
+    } : void 0;
     this.historySnipConfig = opts.options?.historySnip;
     this.outputFormat = opts.options?.outputFormat;
     this.structuredOutputMode = opts.options?.structuredOutputMode;
@@ -8263,7 +8120,10 @@ var Agent = class {
     if (opts.options?.checkpoint?.enabled) {
       this.checkpointManager = new FileCheckpointManager(
         this.fs,
-        opts.options.checkpoint
+        {
+          ...opts.options.checkpoint,
+          backupDir: opts.options.checkpoint.backupDir ?? `${this.dotDirResolver.writePath(resolved.effectiveCwd)}/checkpoints`
+        }
       );
     }
   }
@@ -8271,8 +8131,8 @@ var Agent = class {
     if (this.resolvedProvider) return this.resolvedProvider;
     if (!this.providerPromise) {
       this.providerPromise = (async () => {
-        const { resolveProvider: resolveProvider2 } = await import("./resolve-6KUZNEYW.js");
-        return resolveProvider2(this.providerInput, { model: this.model });
+        const { resolveProvider } = await import("./resolve-AGQZFMKD.js");
+        return resolveProvider(this.providerInput, { model: this.model });
       })();
     }
     this.resolvedProvider = await this.providerPromise;
@@ -8288,10 +8148,14 @@ var Agent = class {
   }
   async getSkills() {
     if (this.resolvedSkills) return this.resolvedSkills;
+    const homeDir = process.env.HOME ?? process.env.USERPROFILE;
     const ctx = await buildUserContext({
       fs: this.fs,
       skillsPaths: this.skillsPaths,
-      inlineSkills: this.skills
+      inlineSkills: this.skills,
+      dotDirResolver: this.dotDirResolver,
+      cwd: this.cwd,
+      homeDir
     });
     this.resolvedSkills = ctx.skills;
     return this.resolvedSkills;
@@ -8350,7 +8214,8 @@ var Agent = class {
           historySnip: this.historySnipConfig,
           promptCachingEnabled: this.promptCachingConfig?.enabled ?? false,
           skipCacheWrite: true,
-          projectContext: this.resolvedProjectContext ?? void 0
+          projectContext: this.resolvedProjectContext ?? void 0,
+          dotDirResolver: this.dotDirResolver
         },
         { cwd: parentCwd }
       );
@@ -8412,6 +8277,7 @@ var Agent = class {
         promptCachingEnabled: this.promptCachingConfig?.enabled ?? false,
         mcpToolNames: this.mcpToolNames.size > 0 ? this.mcpToolNames : void 0,
         projectContext: this.resolvedProjectContext ?? void 0,
+        dotDirResolver: this.dotDirResolver,
         outputFormat: this.outputFormat,
         structuredOutputMode: this.structuredOutputMode
       },
@@ -8626,7 +8492,7 @@ var Agent = class {
     if (this.mcpServerConfigs && !this.mcpManager) {
       tasks.push(
         (async () => {
-          const { McpClientManager: McpMgr } = await import("./client-CRRO2376.js");
+          const { McpClientManager: McpMgr } = await import("./client-JJFLE6RT.js");
           this.mcpManager = new McpMgr(this.mcpServerConfigs, {
             tokenStorage: this.mcpTokenStorage,
             onAuthorizationUrl: this.mcpOnAuthorizationUrl
@@ -8636,7 +8502,7 @@ var Agent = class {
           this.mcpToolNames = new Set(this.mcpTools.map((t) => t.name));
           const needsAuth = this.mcpManager.getServersNeedingAuth();
           if (needsAuth.length > 0) {
-            const { createMcpAuthTool } = await import("./mcp-auth-AEI2R4ZC.js");
+            const { createMcpAuthTool } = await import("./mcp-auth-NOIQPF7W.js");
             this.mcpAuthTools = needsAuth.map(
               (name) => createMcpAuthTool(name, this.mcpManager)
             );
@@ -8647,8 +8513,8 @@ var Agent = class {
     if (this.lspConfigs && !this.lspManager) {
       tasks.push(
         (async () => {
-          const { LspServerManager } = await import("./manager-DLXK63XC.js");
-          const { lspTool } = await import("./lsp-PS3BWIHC.js");
+          const { LspServerManager } = await import("./manager-Z5EQ7YYV.js");
+          const { lspTool } = await import("./lsp-3APWNKB2.js");
           const rootUri = `file://${this.cwd}`;
           this.lspManager = new LspServerManager(this.lspConfigs, rootUri);
           this.lspToolRef = lspTool;
@@ -8684,30 +8550,20 @@ var Agent = class {
   // ---------------------------------------------------------------------------
   // Sandbox index — local host file mapping sessionId → sandboxId so we can
   // reconnect to auto-created containers on resume without accessing the
-  // (potentially unreachable) sandbox filesystem.
+  // (potentially unreachable) sandbox filesystem. The implementation is
+  // quarantined in `session/sandbox-index.ts` and lazy-loaded so that
+  // `node:fs/promises` + `node:path.resolve(cwd, ...)` don't appear in the
+  // Agent's static import graph — bundler dependency tracers (Next.js NFT,
+  // serverless-webpack, …) flag top-level dynamic path resolution as
+  // "whole project was traced unintentionally".
   // ---------------------------------------------------------------------------
-  get sandboxIndexPath() {
-    return nodePath.resolve(this.cwd, this.sessionDir, ".sandbox-index.json");
-  }
   async loadSandboxId(sessionId) {
-    try {
-      const content = await nodeFs.readFile(this.sandboxIndexPath, "utf-8");
-      const index = JSON.parse(content);
-      return index[sessionId];
-    } catch {
-      return void 0;
-    }
+    const { loadSandboxId } = await import("./sandbox-index-ODNREIFA.js");
+    return loadSandboxId(this.cwd, this.sessionDir, sessionId);
   }
   async storeSandboxId(sessionId, sandboxId) {
-    let index = {};
-    try {
-      const content = await nodeFs.readFile(this.sandboxIndexPath, "utf-8");
-      index = JSON.parse(content);
-    } catch {
-    }
-    index[sessionId] = sandboxId;
-    await nodeFs.mkdir(nodePath.dirname(this.sandboxIndexPath), { recursive: true });
-    await nodeFs.writeFile(this.sandboxIndexPath, JSON.stringify(index, null, 2));
+    const { storeSandboxId } = await import("./sandbox-index-ODNREIFA.js");
+    return storeSandboxId(this.cwd, this.sessionDir, sessionId, sandboxId);
   }
   /**
    * Disconnect all MCP clients. Call when done with this Agent instance.
@@ -8741,648 +8597,7 @@ var Agent = class {
   }
 };
 
-// src/presets.ts
-function codingAgent(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  return new Agent({
-    provider: opts.provider,
-    sandbox: opts.sandbox ?? UnsandboxedLocal({ cwd }),
-    options: {
-      cwd,
-      model: opts.model,
-      systemPrompt: opts.systemPrompt,
-      permissions: { mode: "default" },
-      autoCompact: true,
-      enableSubagents: true,
-      enableTasks: true,
-      enablePlanMode: true,
-      projectContext: { cwd },
-      costTracking: { enabled: true },
-      retry: true,
-      hooks: opts.hooks,
-      mcpServers: opts.mcpServers,
-      autoTitle: opts.autoTitle
-    }
-  });
-}
-function planningAgent(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  return new Agent({
-    provider: opts.provider,
-    sandbox: opts.sandbox ?? UnsandboxedLocal({ cwd }),
-    options: {
-      cwd,
-      model: opts.model,
-      systemPrompt: opts.systemPrompt,
-      permissions: { mode: "plan" },
-      autoCompact: true,
-      enableSubagents: false,
-      enableTasks: false,
-      enablePlanMode: true,
-      projectContext: { cwd },
-      costTracking: { enabled: true },
-      retry: true,
-      hooks: opts.hooks,
-      mcpServers: opts.mcpServers,
-      autoTitle: opts.autoTitle
-    }
-  });
-}
-function reviewAgent(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  return new Agent({
-    provider: opts.provider,
-    sandbox: opts.sandbox ?? UnsandboxedLocal({ cwd }),
-    options: {
-      cwd,
-      model: opts.model,
-      systemPrompt: opts.systemPrompt,
-      permissions: { mode: "plan" },
-      autoCompact: true,
-      enableSubagents: false,
-      enableTasks: false,
-      enablePlanMode: true,
-      projectContext: { cwd },
-      costTracking: { enabled: true },
-      retry: true,
-      hooks: opts.hooks,
-      mcpServers: opts.mcpServers,
-      autoTitle: opts.autoTitle,
-      webSearch: {
-        search: async (query) => {
-          try {
-            const res = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`);
-            if (!res.ok) return [];
-            return [{ title: query, url: res.url, snippet: `Search results for: ${query}` }];
-          } catch {
-            return [];
-          }
-        }
-      }
-    }
-  });
-}
-
-// src/swarm/mailbox.ts
-var Mailbox = class {
-  messages = [];
-  listeners = /* @__PURE__ */ new Map();
-  /**
-   * Send a message from one member to another.
-   */
-  send(from, to, content) {
-    const msg = {
-      from,
-      to,
-      content,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.messages.push(msg);
-    const handlers = this.listeners.get(to);
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(msg);
-      }
-    }
-  }
-  /**
-   * Broadcast a message to all members except the sender.
-   */
-  broadcast(from, content, memberNames) {
-    for (const name of memberNames) {
-      if (name !== from) {
-        this.send(from, name, content);
-      }
-    }
-  }
-  /**
-   * Get all messages sent to a specific member.
-   */
-  getMessagesFor(memberName) {
-    return this.messages.filter((m) => m.to === memberName);
-  }
-  /**
-   * Get all unread messages for a member since the last check.
-   */
-  getNewMessagesFor(memberName, since) {
-    return this.messages.filter(
-      (m) => m.to === memberName && m.timestamp > since
-    );
-  }
-  /**
-   * Register a listener for incoming messages to a member.
-   */
-  onMessage(memberName, handler) {
-    const existing = this.listeners.get(memberName) ?? [];
-    existing.push(handler);
-    this.listeners.set(memberName, existing);
-    return () => {
-      const handlers = this.listeners.get(memberName);
-      if (handlers) {
-        const idx = handlers.indexOf(handler);
-        if (idx !== -1) handlers.splice(idx, 1);
-      }
-    };
-  }
-  /**
-   * Get all messages in the mailbox.
-   */
-  getAllMessages() {
-    return [...this.messages];
-  }
-};
-
-// src/swarm/manager.ts
-var SwarmManager = class {
-  members = /* @__PURE__ */ new Map();
-  backend;
-  mailbox = new Mailbox();
-  config;
-  runningTasks = /* @__PURE__ */ new Map();
-  eventHandlers = [];
-  constructor(backend, config) {
-    this.backend = backend;
-    this.config = config ?? {};
-  }
-  /**
-   * Register a handler for swarm lifecycle events.
-   */
-  onEvent(handler) {
-    this.eventHandlers.push(handler);
-    return () => {
-      const idx = this.eventHandlers.indexOf(handler);
-      if (idx !== -1) this.eventHandlers.splice(idx, 1);
-    };
-  }
-  emit(event) {
-    for (const handler of this.eventHandlers) {
-      handler(event);
-    }
-  }
-  /**
-   * Spawn a new swarm member. Returns the member ID.
-   */
-  async spawn(config) {
-    const id = generateUUID();
-    const member = {
-      id,
-      name: config.name,
-      status: "pending"
-    };
-    this.members.set(id, member);
-    const maxConcurrent = this.config.maxConcurrent ?? 4;
-    const running = Array.from(this.members.values()).filter(
-      (m) => m.status === "running"
-    ).length;
-    if (running >= maxConcurrent) {
-      await this.waitForSlot(maxConcurrent);
-    }
-    member.status = "running";
-    this.emit({
-      type: "swarm_member_start",
-      memberId: id,
-      memberName: config.name
-    });
-    const task = this.runMember(config, member);
-    this.runningTasks.set(id, task);
-    return id;
-  }
-  async runMember(config, member) {
-    try {
-      const gen = this.backend.spawn(config, member);
-      let next = await gen.next();
-      while (!next.done) {
-        next = await gen.next();
-      }
-      member.result = next.value;
-      member.status = "completed";
-      this.emit({
-        type: "swarm_member_complete",
-        memberId: member.id,
-        memberName: member.name,
-        content: member.result
-      });
-    } catch (err) {
-      member.error = err instanceof Error ? err : new Error(String(err));
-      member.status = "failed";
-      this.emit({
-        type: "swarm_member_failed",
-        memberId: member.id,
-        memberName: member.name,
-        error: member.error
-      });
-    } finally {
-      this.runningTasks.delete(member.id);
-    }
-  }
-  /**
-   * Spawn multiple members concurrently. Returns their IDs.
-   */
-  async spawnAll(configs) {
-    const ids = [];
-    for (const config of configs) {
-      ids.push(await this.spawn(config));
-    }
-    return ids;
-  }
-  /**
-   * Send a message between swarm members.
-   */
-  sendMessage(from, to, content) {
-    this.mailbox.send(from, to, content);
-    this.emit({
-      type: "swarm_message",
-      memberId: to,
-      memberName: this.getMemberName(to),
-      content
-    });
-  }
-  /**
-   * Kill a running member.
-   */
-  async kill(memberId) {
-    const member = this.members.get(memberId);
-    if (!member || member.status !== "running") return;
-    await this.backend.kill(memberId);
-    member.status = "killed";
-    this.runningTasks.delete(memberId);
-  }
-  /**
-   * Wait for all running members to complete.
-   */
-  async waitForAll() {
-    while (this.runningTasks.size > 0) {
-      await Promise.race(this.runningTasks.values());
-    }
-  }
-  /**
-   * Get current swarm status.
-   */
-  getStatus() {
-    return {
-      members: Array.from(this.members.values()),
-      messages: this.mailbox.getAllMessages()
-    };
-  }
-  /**
-   * Get a specific member.
-   */
-  getMember(id) {
-    return this.members.get(id);
-  }
-  /**
-   * Get the mailbox for direct access.
-   */
-  getMailbox() {
-    return this.mailbox;
-  }
-  getMemberName(id) {
-    return this.members.get(id)?.name ?? id;
-  }
-  async waitForSlot(maxConcurrent) {
-    while (true) {
-      const running = Array.from(this.members.values()).filter(
-        (m) => m.status === "running"
-      ).length;
-      if (running < maxConcurrent) return;
-      if (this.runningTasks.size > 0) {
-        await Promise.race(this.runningTasks.values());
-      } else {
-        break;
-      }
-    }
-  }
-};
-
-// src/swarm/backends/in-process.ts
-var InProcessBackend = class {
-  threadConfig;
-  abortControllers = /* @__PURE__ */ new Map();
-  constructor(threadConfig) {
-    this.threadConfig = threadConfig;
-  }
-  async *spawn(config, member) {
-    const ac = new AbortController();
-    this.abortControllers.set(member.id, ac);
-    const childTools = config.allowedTools ? (this.threadConfig.tools ?? []).filter(
-      (t) => config.allowedTools.includes(t.name)
-    ) : this.threadConfig.tools;
-    const thread = new Thread(
-      {
-        ...this.threadConfig,
-        tools: childTools,
-        systemPrompt: config.systemPrompt,
-        model: config.model
-      },
-      { cwd: this.threadConfig.cwd }
-    );
-    member.sessionId = thread.sessionId;
-    let resultText = "";
-    for await (const event of thread.run(config.prompt, {
-      signal: ac.signal
-    })) {
-      yield event;
-      if (event.type === "message_complete" && event.message.content) {
-        resultText += event.message.content;
-      }
-    }
-    this.abortControllers.delete(member.id);
-    return resultText;
-  }
-  async kill(memberId) {
-    const ac = this.abortControllers.get(memberId);
-    if (ac) {
-      ac.abort();
-      this.abortControllers.delete(memberId);
-    }
-  }
-};
-
-// src/permissions/updates.ts
-function applyPermissionUpdate(ctx, update) {
-  switch (update.type) {
-    case "addRules":
-      ctx.rules.push(...update.rules);
-      break;
-    case "removeRules":
-      ctx.rules = ctx.rules.filter((r) => {
-        if (r.toolName !== update.toolName) return true;
-        if (update.behavior && r.behavior !== update.behavior) return true;
-        return false;
-      });
-      break;
-    case "setMode":
-      ctx.mode = update.mode;
-      break;
-    case "addDirectories":
-      for (const dir of update.directories) {
-        if (!ctx.workingDirectories.includes(dir)) {
-          ctx.workingDirectories.push(dir);
-        }
-      }
-      break;
-    case "removeDirectories":
-      ctx.workingDirectories = ctx.workingDirectories.filter(
-        (d) => !update.directories.includes(d)
-      );
-      break;
-  }
-  return ctx;
-}
-function applyPermissionUpdates(ctx, updates) {
-  for (const update of updates) {
-    applyPermissionUpdate(ctx, update);
-  }
-  return ctx;
-}
-
-// src/tracing/otel.ts
-var otelApi = null;
-var otelLoadFailed = false;
-async function loadOTelApi() {
-  if (otelApi) return otelApi;
-  if (otelLoadFailed) return null;
-  try {
-    otelApi = await import("@opentelemetry/api");
-    return otelApi;
-  } catch {
-    otelLoadFailed = true;
-    return null;
-  }
-}
-var OTelSpan = class {
-  name;
-  inner;
-  constructor(name, inner) {
-    this.name = name;
-    this.inner = inner;
-  }
-  setAttribute(key, value) {
-    this.inner.setAttribute(key, value);
-  }
-  addEvent(name, attributes) {
-    this.inner.addEvent(name, attributes);
-  }
-  setStatus(code, message) {
-    const otelCode = code === SpanStatusCode.ERROR ? 2 : 1;
-    this.inner.setStatus({ code: otelCode, message });
-  }
-  end() {
-    this.inner.end();
-  }
-  /** Access the underlying OTEL span for advanced use cases. */
-  getInnerSpan() {
-    return this.inner;
-  }
-};
-var OTelTracer = class _OTelTracer {
-  otelTracer;
-  api;
-  constructor(api, otelTracer) {
-    this.api = api;
-    this.otelTracer = otelTracer;
-  }
-  /**
-   * Create an `OTelTracer`. Falls back to `NoopTracer` if
-   * `@opentelemetry/api` is not available at runtime.
-   */
-  static async create(serviceName = "noumen", version) {
-    const api = await loadOTelApi();
-    if (!api) return new NoopTracer();
-    const tracer = api.trace.getTracer(serviceName, version);
-    return new _OTelTracer(api, tracer);
-  }
-  startSpan(name, options) {
-    const parentCtx = options?.parent instanceof OTelSpan ? this.api.trace.setSpan(this.api.context.active(), options.parent.getInnerSpan()) : this.api.context.active();
-    const otelSpan = this.otelTracer.startSpan(
-      name,
-      options?.attributes ? { attributes: options.attributes } : void 0,
-      parentCtx
-    );
-    return new OTelSpan(name, otelSpan);
-  }
-};
-
-// src/memory/file-provider.ts
-var INDEX_NAME = "MEMORY.md";
-var DEFAULT_MAX_LINES = 200;
-var DEFAULT_MAX_BYTES2 = 25e3;
-var MEMORY_TYPES2 = /* @__PURE__ */ new Set([
-  "user",
-  "project",
-  "feedback",
-  "reference"
-]);
-function parseFrontmatter2(raw) {
-  const trimmed = raw.trimStart();
-  if (!trimmed.startsWith("---")) {
-    return { rest: raw };
-  }
-  const endIdx = trimmed.indexOf("---", 3);
-  if (endIdx === -1) {
-    return { rest: raw };
-  }
-  const fmBlock = trimmed.slice(3, endIdx).trim();
-  const rest = trimmed.slice(endIdx + 3).trim();
-  let name;
-  let description;
-  let type;
-  for (const line of fmBlock.split("\n")) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1) continue;
-    const key = line.slice(0, colonIdx).trim();
-    const value = line.slice(colonIdx + 1).trim();
-    if (key === "name") name = value;
-    else if (key === "description") description = value;
-    else if (key === "type" && MEMORY_TYPES2.has(value)) type = value;
-  }
-  return { name, description, type, rest };
-}
-function serializeEntry(entry) {
-  const lines = [
-    "---",
-    `name: ${entry.name}`,
-    `description: ${entry.description}`,
-    `type: ${entry.type}`,
-    "---",
-    "",
-    entry.content
-  ];
-  return lines.join("\n");
-}
-function slugify(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 60);
-}
-function truncateIndex(raw, maxLines = DEFAULT_MAX_LINES, maxBytes = DEFAULT_MAX_BYTES2) {
-  const trimmed = raw.trim();
-  const contentLines = trimmed.split("\n");
-  const lineCount = contentLines.length;
-  const byteCount = trimmed.length;
-  const wasLineTruncated = lineCount > maxLines;
-  const wasByteTruncated = byteCount > maxBytes;
-  if (!wasLineTruncated && !wasByteTruncated) {
-    return { content: trimmed, lineCount, byteCount, wasLineTruncated, wasByteTruncated };
-  }
-  let truncated = wasLineTruncated ? contentLines.slice(0, maxLines).join("\n") : trimmed;
-  if (truncated.length > maxBytes) {
-    const cutAt = truncated.lastIndexOf("\n", maxBytes);
-    truncated = truncated.slice(0, cutAt > 0 ? cutAt : maxBytes);
-  }
-  const reason = wasByteTruncated && !wasLineTruncated ? `${byteCount} bytes (limit: ${maxBytes})` : wasLineTruncated && !wasByteTruncated ? `${lineCount} lines (limit: ${maxLines})` : `${lineCount} lines and ${byteCount} bytes`;
-  return {
-    content: truncated + `
-
-> WARNING: ${INDEX_NAME} is ${reason}. Only part of it was loaded. Keep index entries to one line under ~200 chars; move detail into topic files.`,
-    lineCount,
-    byteCount,
-    wasLineTruncated,
-    wasByteTruncated
-  };
-}
-var FileMemoryProvider = class {
-  fs;
-  dir;
-  maxIndexLines;
-  constructor(fs2, memoryDir, maxIndexLines = DEFAULT_MAX_LINES) {
-    this.fs = fs2;
-    this.dir = memoryDir.endsWith("/") ? memoryDir : memoryDir + "/";
-    this.maxIndexLines = maxIndexLines;
-  }
-  indexPath() {
-    return this.dir + INDEX_NAME;
-  }
-  async ensureDir() {
-    const exists = await this.fs.exists(this.dir);
-    if (!exists) {
-      await this.fs.mkdir(this.dir, { recursive: true });
-    }
-  }
-  async loadIndex() {
-    try {
-      const raw = await this.fs.readFile(this.indexPath());
-      return truncateIndex(raw, this.maxIndexLines).content;
-    } catch {
-      return "";
-    }
-  }
-  async loadEntry(path2) {
-    const fullPath = path2.startsWith(this.dir) ? path2 : this.dir + path2;
-    try {
-      const raw = await this.fs.readFile(fullPath);
-      const fm = parseFrontmatter2(raw);
-      const stat2 = await this.fs.stat(fullPath).catch(() => null);
-      return {
-        name: fm.name ?? pathToName(path2),
-        description: fm.description ?? "",
-        type: fm.type ?? "project",
-        content: fm.rest,
-        path: path2.startsWith(this.dir) ? path2.slice(this.dir.length) : path2,
-        updatedAt: stat2?.modifiedAt?.toISOString()
-      };
-    } catch {
-      return null;
-    }
-  }
-  async saveEntry(entry) {
-    await this.ensureDir();
-    const relativePath = entry.path ?? slugify(entry.name) + ".md";
-    const fullPath = this.dir + relativePath;
-    const content = serializeEntry({ ...entry, path: relativePath });
-    await this.fs.writeFile(fullPath, content);
-    await this.rebuildIndex();
-  }
-  async removeEntry(path2) {
-    const fullPath = path2.startsWith(this.dir) ? path2 : this.dir + path2;
-    try {
-      await this.fs.deleteFile(fullPath);
-    } catch {
-    }
-    await this.rebuildIndex();
-  }
-  async listEntries() {
-    try {
-      const files = await this.fs.readdir(this.dir);
-      const entries = [];
-      for (const file of files) {
-        if (!file.isFile || !file.name.endsWith(".md") || file.name === INDEX_NAME) continue;
-        const entry = await this.loadEntry(file.name);
-        if (entry) entries.push(entry);
-      }
-      return entries;
-    } catch {
-      return [];
-    }
-  }
-  async search(query) {
-    const entries = await this.listEntries();
-    const lower = query.toLowerCase();
-    return entries.filter(
-      (e) => e.name.toLowerCase().includes(lower) || e.description.toLowerCase().includes(lower) || e.content.toLowerCase().includes(lower)
-    );
-  }
-  async rebuildIndex() {
-    const entries = await this.listEntries();
-    const lines = [];
-    for (const entry of entries) {
-      const relativePath = entry.path ?? slugify(entry.name) + ".md";
-      const desc = entry.description ? ` \u2014 ${entry.description}` : "";
-      lines.push(`- [${entry.name}](${relativePath})${desc}`);
-    }
-    await this.ensureDir();
-    await this.fs.writeFile(this.indexPath(), lines.join("\n") + "\n");
-  }
-};
-function pathToName(p) {
-  const base = p.split("/").pop() ?? p;
-  return base.replace(/\.md$/i, "").replace(/[_-]/g, " ");
-}
-
 export {
-  LocalFs,
-  LocalComputer,
-  SandboxedLocalComputer,
-  UnsandboxedLocal,
-  LocalSandbox,
   DEFAULT_AUTO_TITLE_MAX_INPUT_CHARS,
   DEFAULT_AUTO_TITLE_SYSTEM_PROMPT,
   extractTitleSeedText,
@@ -9444,6 +8659,10 @@ export {
   tokenCountWithEstimation,
   groupMessagesByTurn,
   truncateHeadForPTLRetry,
+  registerContextWindows,
+  getContextWindowForModel,
+  getEffectiveContextWindow,
+  getAutoCompactThreshold,
   classifyError,
   isRetryable,
   compactConversation,
@@ -9488,17 +8707,6 @@ export {
   Thread,
   loadSkills,
   DEFAULT_RETRY_CONFIG,
-  Agent,
-  codingAgent,
-  planningAgent,
-  reviewAgent,
-  Mailbox,
-  SwarmManager,
-  InProcessBackend,
-  applyPermissionUpdate,
-  applyPermissionUpdates,
-  OTelTracer,
-  truncateIndex,
-  FileMemoryProvider
+  Agent
 };
-//# sourceMappingURL=chunk-6MMYCGJQ.js.map
+//# sourceMappingURL=chunk-5HY4IYNT.js.map