@cuylabs/agent-core 0.2.0 → 0.4.0

package/dist/index.js

@@ -1175,18 +1175,18 @@ var TurnChangeTracker = class {
     if (this.gitDetected !== null) {
       return this.gitDetected;
     }
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const proc = spawn("git", ["rev-parse", "--git-dir"], {
         cwd: this.config.cwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
-      proc.on("close", (code) => {
-        this.gitDetected = code === 0;
-        resolve5(this.gitDetected);
+      proc.on("close", (code2) => {
+        this.gitDetected = code2 === 0;
+        resolve6(this.gitDetected);
       });
       proc.on("error", () => {
         this.gitDetected = false;
-        resolve5(false);
+        resolve6(false);
       });
     });
   }
@@ -2655,14 +2655,14 @@ function calculateDelay(attempt, error, config) {
   return Math.round(cappedDelay);
 }
 async function sleep(ms, signal) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     if (signal?.aborted) {
       reject(new DOMException("Aborted", "AbortError"));
       return;
     }
     const timeoutId = setTimeout(() => {
       cleanup();
-      resolve5();
+      resolve6();
     }, ms);
     const abortHandler = () => {
       clearTimeout(timeoutId);
@@ -2720,7 +2720,7 @@ function shouldRetry(error, attempt, maxAttempts = DEFAULT_RETRY_CONFIG.maxAttem
 var OUTPUT_TOKEN_MAX = 32e3;
 var LLM;
 ((LLM2) => {
-  async function buildToolSet(tools, cwd, sessionID, messageID, abort, turnTracker, host) {
+  async function buildToolSet(tools, cwd, sessionID, messageID, abort, turnTracker, host, middleware) {
     const toolSet = {};
     for (const [id, info] of Object.entries(tools)) {
       const initialized = await info.init({ cwd });
@@ -2737,6 +2737,12 @@ var LLM;
             host,
             turnTracker
           };
+          if (middleware?.hasMiddleware) {
+            const decision = await middleware.runBeforeToolCall(id, params, ctx);
+            if (decision.action === "deny") {
+              return decision.reason ?? `Tool call denied: ${id}`;
+            }
+          }
           if (turnTracker && initialized.fileOps && shouldCaptureBaseline(initialized.fileOps)) {
             const paths = extractFilePathsFromArgs(
               params,
@@ -2747,6 +2753,10 @@ var LLM;
             }
           }
           const result = await initialized.execute(params, ctx);
+          if (middleware?.hasMiddleware) {
+            const transformed = await middleware.runAfterToolCall(id, params, result, ctx);
+            return transformed.output;
+          }
           return result.output;
         }
       });
@@ -2778,7 +2788,8 @@ var LLM;
       messageID,
       input.abort,
       input.turnTracker,
-      input.host
+      input.host,
+      input.middleware
     );
     const allTools = {
       ...toolSet,
@@ -3442,11 +3453,18 @@ var explore = {
 You are in **exploration mode**. Your goal is to thoroughly understand the content.
 
 Guidelines:
+- **Always start with glob or grep to discover correct paths** \u2014 never assume directory structure
 - Use search and read tools extensively to build understanding
 - Map out structures, dependencies, and patterns
 - Look for conventions, common patterns, and documentation
 - DO NOT modify anything \u2014 only read and analyse
-- Summarise findings clearly with references to specific locations`,
+- Summarise findings clearly with references to specific locations
+
+Error recovery:
+- If a tool returns an error (ENOENT, not found, etc.), try a different path or approach
+- Use glob with broader patterns to discover the correct location
+- Keep going until you have a thorough answer \u2014 do not give up after one failure
+- You have multiple steps available \u2014 use them all if needed`,
   temperature: 0.3,
   maxSteps: 30
 };
@@ -3536,12 +3554,61 @@ Guidelines:
   temperature: 0,
   maxSteps: 50
 };
+var code = {
+  name: "code",
+  description: "Full-power implementation mode for writing and modifying code",
+  systemPrompt: `{basePrompt}
+
+## IMPLEMENTATION MODE
+
+You are a focused **implementation agent**. Your goal is to complete the assigned task fully and correctly.
+
+Guidelines:
+- Read existing code first to understand context and conventions before making changes
+- Follow the project's existing patterns, naming conventions, and style
+- Make minimal, targeted changes \u2014 do not refactor unrelated code
+- Verify your work: re-read modified files, run tests or lint if available
+- If the task requires multiple files, handle them systematically one at a time
+
+Error recovery:
+- If a command fails, read the error output carefully and fix the root cause
+- If a test fails, read the failure details and iterate until it passes
+- If you cannot find a file, use glob or grep to discover the correct path
+- Keep iterating until the task is DONE \u2014 do not stop at a partial solution
+- You have many steps available \u2014 use them all if needed`,
+  temperature: 0,
+  maxSteps: 50
+};
+var watch = {
+  name: "watch",
+  description: "Process monitoring mode for running and watching long commands",
+  allowTools: ["bash*", "exec*", "run*", "read*", "grep*", "glob*", "list*", "find*"],
+  denyTools: ["write*", "edit*", "delete*", "remove*"],
+  systemPrompt: `{basePrompt}
+
+## WATCH MODE
+
+You are a **process monitor**. Your goal is to execute a command, observe its output, and report the result.
+
+Guidelines:
+- Run the command as given \u2014 do not modify or "improve" it
+- Wait for completion and capture the full output
+- Parse the output for success/failure status, error counts, warnings
+- Report a clear summary: what ran, whether it passed, key details
+- If the process fails, include the relevant error output verbatim
+- Do NOT attempt to fix issues \u2014 only observe and report`,
+  temperature: 0,
+  maxSteps: 10,
+  reasoningLevel: "low"
+};
 var Presets = {
   explore,
   plan,
   review,
   quick,
-  careful
+  careful,
+  code,
+  watch
 };
 function createPreset(options) {
   return {
@@ -3597,7 +3664,8 @@ var TEMPLATE_ANTHROPIC = `You are a capable AI assistant with access to tools.
 - Use the tools available to you to accomplish tasks
 - Choose the most appropriate tool for each step
 - Review tool output before proceeding to the next step
-- If a tool fails, try an alternative approach
+- If a tool fails, try an alternative approach \u2014 do not give up after one error
+- Keep iterating until the task is fully resolved or all options are exhausted
 </tool-usage>
 
 <communication>
@@ -3618,8 +3686,9 @@ var TEMPLATE_OPENAI = `You are a capable AI assistant with access to tools.
 ## Tool Usage
 1. Use the most appropriate tool for each step
 2. Review tool output before proceeding
-3. If a tool fails, try an alternative approach
+3. If a tool fails, try an alternative approach \u2014 do not give up after one error
 4. Combine tools effectively to accomplish complex tasks
+5. Keep iterating until the task is fully resolved or all options are exhausted
 
 ## Communication
 - Be direct and concise
@@ -3638,7 +3707,8 @@ var TEMPLATE_GOOGLE = `You are a capable AI assistant with access to tools.
 **Tool Usage:**
 - Choose the most appropriate tool for each step
 - Review tool output before proceeding
-- If a tool fails, try an alternative approach
+- If a tool fails, try an alternative approach \u2014 do not give up after one error
+- Keep iterating until the task is fully resolved or all options are exhausted
 
 **Communication:**
 - Be concise and direct
@@ -3651,6 +3721,8 @@ Principles:
 - Break complex tasks into smaller steps
 - Gather context and verify assumptions
 - Use tools effectively \u2014 choose the right one for each step
+- If a tool fails, try an alternative \u2014 do not give up after one error
+- Keep iterating until the task is fully resolved
 - Verify results after each action
 
 Communication:
@@ -3664,6 +3736,8 @@ Guidelines:
 - Break complex tasks into smaller, verifiable steps
 - Gather context and information before making decisions
 - Use the most appropriate tool for each step
+- If a tool fails, try an alternative \u2014 do not give up after one error
+- Keep iterating until the task is fully resolved or all options are exhausted
 - Verify results after each action
 - Be concise and direct in communication
 - Proactively mention potential issues or risks`;
@@ -3869,6 +3943,577 @@ function formatInstructions(files, basePath) {
   return blocks.join("\n");
 }
 
+// src/skill/discovery.ts
+import { stat as stat5, readdir as readdir3, access as access2 } from "fs/promises";
+import { join as join5, resolve as resolve4, dirname as dirname3, sep as sep2 } from "path";
+import { homedir as homedir4 } from "os";
+
+// src/skill/loader.ts
+import { readFile as readFile4, stat as stat4, readdir as readdir2 } from "fs/promises";
+import { join as join4, relative as relative2, extname } from "path";
+var SKILL_FILENAME = "SKILL.md";
+var DEFAULT_SKILL_MAX_SIZE = 102400;
+var RESOURCE_DIRS = {
+  scripts: "script",
+  references: "reference",
+  assets: "asset",
+  examples: "example"
+};
+function parseFrontmatter(raw) {
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { data: {}, body: raw };
+  }
+  const endIndex = trimmed.indexOf("\n---", 3);
+  if (endIndex === -1) {
+    return { data: {}, body: raw };
+  }
+  const yamlBlock = trimmed.slice(4, endIndex).trim();
+  const body = trimmed.slice(endIndex + 4).trim();
+  const data = {};
+  const lines = yamlBlock.split("\n");
+  let currentKey = null;
+  let continuationValue = "";
+  for (const line of lines) {
+    if (line.trimStart().startsWith("#") || line.trim() === "") continue;
+    const kvMatch = line.match(/^(\w[\w-]*)\s*:\s*(.*)/);
+    if (kvMatch) {
+      if (currentKey && continuationValue) {
+        data[currentKey] = parseFrontmatterValue(continuationValue.trim());
+        continuationValue = "";
+      }
+      const key = kvMatch[1];
+      const rawValue = kvMatch[2].trim();
+      if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+        data[key] = rawValue.slice(1, -1).split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+        currentKey = null;
+      } else if (rawValue === "" || rawValue === "|" || rawValue === ">") {
+        currentKey = key;
+        continuationValue = "";
+      } else {
+        data[key] = parseFrontmatterValue(rawValue);
+        currentKey = null;
+      }
+    } else if (currentKey) {
+      continuationValue += (continuationValue ? "\n" : "") + line.trim();
+    } else if (line.trimStart().startsWith("- ")) {
+      const lastKey = Object.keys(data).length > 0 ? Object.keys(data)[Object.keys(data).length - 1] : null;
+      if (lastKey) {
+        const existing = data[lastKey];
+        const item = line.trimStart().slice(2).trim();
+        if (Array.isArray(existing)) {
+          existing.push(item);
+        } else {
+          data[lastKey] = [item];
+        }
+      }
+    }
+  }
+  if (currentKey && continuationValue) {
+    data[currentKey] = parseFrontmatterValue(continuationValue.trim());
+  }
+  return { data, body };
+}
+function parseFrontmatterValue(raw) {
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (/^\d+(\.\d+)?$/.test(raw)) return Number(raw);
+  if (raw === "null" || raw === "~") return null;
+  return raw;
+}
+async function loadSkillMetadata(filePath, scope, source, maxSize = DEFAULT_SKILL_MAX_SIZE) {
+  try {
+    const info = await stat4(filePath);
+    if (!info.isFile() || info.size > maxSize) return null;
+    const raw = await readFile4(filePath, "utf-8");
+    const { data } = parseFrontmatter(raw);
+    const name = typeof data.name === "string" ? data.name.trim() : null;
+    const description = typeof data.description === "string" ? data.description.trim() : null;
+    if (!name || !description) return null;
+    const baseDir = join4(filePath, "..");
+    return {
+      name,
+      description,
+      version: typeof data.version === "string" ? data.version : void 0,
+      scope,
+      source,
+      filePath,
+      baseDir,
+      tags: Array.isArray(data.tags) ? data.tags.map(String) : void 0,
+      dependencies: Array.isArray(data.dependencies) ? data.dependencies.map(String) : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function loadSkillContent(metadata) {
+  const raw = await readFile4(metadata.filePath, "utf-8");
+  const { body } = parseFrontmatter(raw);
+  const resources = await scanSkillResources(metadata.baseDir);
+  return {
+    ...metadata,
+    body,
+    resources
+  };
+}
+async function loadResourceContent(resource) {
+  return readFile4(resource.absolutePath, "utf-8");
+}
+async function scanSkillResources(baseDir) {
+  const resources = [];
+  for (const [dirName, resourceType] of Object.entries(RESOURCE_DIRS)) {
+    const dirPath = join4(baseDir, dirName);
+    try {
+      const info = await stat4(dirPath);
+      if (!info.isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    await collectFiles(dirPath, baseDir, resourceType, resources);
+  }
+  return resources;
+}
+async function collectFiles(dirPath, baseDir, type, resources, maxDepth = 3, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return;
+  try {
+    const entries = await readdir2(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const fullPath = join4(dirPath, entry.name);
+      if (entry.isFile()) {
+        resources.push({
+          relativePath: relative2(baseDir, fullPath),
+          type,
+          absolutePath: fullPath
+        });
+      } else if (entry.isDirectory()) {
+        await collectFiles(fullPath, baseDir, type, resources, maxDepth, currentDepth + 1);
+      }
+    }
+  } catch {
+  }
+}
+function inferResourceType(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  if ([".sh", ".bash", ".py", ".rb", ".js", ".ts"].includes(ext)) {
+    return "script";
+  }
+  if ([".md", ".txt", ".rst", ".adoc"].includes(ext)) {
+    return "reference";
+  }
+  if ([".json", ".yaml", ".yml", ".toml", ".xml", ".html", ".css"].includes(ext)) {
+    return "asset";
+  }
+  return "reference";
+}
+
+// src/skill/discovery.ts
+var DEFAULT_EXTERNAL_DIRS = [".agents", ".claude"];
+var DEFAULT_MAX_SCAN_DEPTH = 4;
+var MAX_SKILLS_PER_ROOT = 500;
+async function discoverSkills(cwd, config) {
+  const startTime = Date.now();
+  const resolvedCwd = resolve4(cwd);
+  const errors = [];
+  let dirsScanned = 0;
+  const externalDirs = config?.externalDirs ?? DEFAULT_EXTERNAL_DIRS;
+  const maxDepth = config?.maxScanDepth ?? DEFAULT_MAX_SCAN_DEPTH;
+  const maxFileSize = config?.maxFileSize ?? DEFAULT_SKILL_MAX_SIZE;
+  const roots = [];
+  if (config?.roots) {
+    for (const root of config.roots) {
+      const absRoot = resolve4(resolvedCwd, root);
+      roots.push({ path: absRoot, scope: "global", source: { type: "local", root: absRoot } });
+    }
+  }
+  const home = homedir4();
+  for (const dir of externalDirs) {
+    const skillsDir = join5(home, dir, "skills");
+    if (await dirExists(skillsDir)) {
+      roots.push({
+        path: skillsDir,
+        scope: "user",
+        source: { type: "local", root: join5(home, dir) }
+      });
+    }
+  }
+  const gitRoot = await findGitRoot2(resolvedCwd);
+  if (gitRoot) {
+    const dirsInPath = dirsBetween(gitRoot, resolvedCwd);
+    for (const dir of dirsInPath) {
+      for (const extDir of externalDirs) {
+        const skillsDir = join5(dir, extDir, "skills");
+        if (await dirExists(skillsDir)) {
+          roots.push({
+            path: skillsDir,
+            scope: "project",
+            source: { type: "local", root: join5(dir, extDir) }
+          });
+        }
+      }
+    }
+  } else {
+    for (const extDir of externalDirs) {
+      const skillsDir = join5(resolvedCwd, extDir, "skills");
+      if (await dirExists(skillsDir)) {
+        roots.push({
+          path: skillsDir,
+          scope: "project",
+          source: { type: "local", root: join5(resolvedCwd, extDir) }
+        });
+      }
+    }
+  }
+  const allSkills = [];
+  for (const root of roots) {
+    const result = await scanRoot(root, maxDepth, maxFileSize);
+    allSkills.push(...result.skills);
+    errors.push(...result.errors);
+    dirsScanned += result.dirsScanned;
+  }
+  const deduped = deduplicateSkills(allSkills);
+  return {
+    skills: deduped,
+    errors,
+    dirsScanned,
+    durationMs: Date.now() - startTime
+  };
+}
+async function scanRoot(root, maxDepth, maxFileSize) {
+  const skills = [];
+  const errors = [];
+  let dirsScanned = 0;
+  const queue = [[root.path, 0]];
+  while (queue.length > 0 && skills.length < MAX_SKILLS_PER_ROOT) {
+    const [dirPath, depth] = queue.shift();
+    if (depth > maxDepth) continue;
+    dirsScanned++;
+    try {
+      const entries = await readdir3(dirPath, { withFileTypes: true });
+      const hasSkillFile = entries.some(
+        (e) => e.isFile() && e.name === SKILL_FILENAME
+      );
+      if (hasSkillFile) {
+        const filePath = join5(dirPath, SKILL_FILENAME);
+        const metadata = await loadSkillMetadata(
+          filePath,
+          root.scope,
+          root.source,
+          maxFileSize
+        );
+        if (metadata) {
+          skills.push(metadata);
+        } else {
+          errors.push({
+            path: filePath,
+            reason: "Invalid or incomplete frontmatter (name and description required)"
+          });
+        }
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build") {
+          continue;
+        }
+        queue.push([join5(dirPath, entry.name), depth + 1]);
+      }
+    } catch (err) {
+      errors.push({
+        path: dirPath,
+        reason: `Cannot read directory: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  return { skills, errors, dirsScanned };
+}
+var SCOPE_PRIORITY = {
+  project: 0,
+  user: 1,
+  global: 2,
+  builtin: 3
+};
+function deduplicateSkills(skills) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const existing = byName.get(skill.name);
+    if (!existing) {
+      byName.set(skill.name, skill);
+      continue;
+    }
+    const existingPriority = SCOPE_PRIORITY[existing.scope];
+    const newPriority = SCOPE_PRIORITY[skill.scope];
+    if (newPriority < existingPriority) {
+      byName.set(skill.name, skill);
+    } else if (newPriority === existingPriority) {
+      byName.set(skill.name, skill);
+    }
+  }
+  return Array.from(byName.values()).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+}
+async function dirExists(path2) {
+  try {
+    const info = await stat5(path2);
+    return info.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function findGitRoot2(startDir) {
+  let dir = resolve4(startDir);
+  const root = sep2 === "/" ? "/" : dir.slice(0, 3);
+  while (dir !== root) {
+    try {
+      await access2(join5(dir, ".git"));
+      return dir;
+    } catch {
+      const parent = dirname3(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return void 0;
+}
+function dirsBetween(from, to) {
+  const fromResolved = resolve4(from);
+  const toResolved = resolve4(to);
+  if (!toResolved.startsWith(fromResolved)) return [fromResolved];
+  const dirs = [];
+  let current = toResolved;
+  while (current.startsWith(fromResolved)) {
+    dirs.push(current);
+    const parent = dirname3(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  dirs.reverse();
+  return dirs;
+}
+
+// src/skill/registry.ts
+var SkillRegistry = class {
+  /** All discovered skill metadata indexed by name */
+  skills;
+  /** Cached full content for skills that have been loaded */
+  contentCache;
+  /** Discovery metadata */
+  discoveryResult;
+  constructor(discoveryResult) {
+    this.discoveryResult = discoveryResult;
+    this.skills = /* @__PURE__ */ new Map();
+    this.contentCache = /* @__PURE__ */ new Map();
+    for (const skill of discoveryResult.skills) {
+      this.skills.set(skill.name, skill);
+    }
+  }
+  // ==========================================================================
+  // Lookup
+  // ==========================================================================
+  /** Get a skill's metadata by name. Returns undefined if not found. */
+  get(name) {
+    return this.skills.get(name);
+  }
+  /** Check if a skill exists by name. */
+  has(name) {
+    return this.skills.has(name);
+  }
+  /** Get all skill metadata entries. */
+  list() {
+    return Array.from(this.skills.values());
+  }
+  /** Number of registered skills. */
+  get size() {
+    return this.skills.size;
+  }
+  /** Skill names as an array. */
+  get names() {
+    return Array.from(this.skills.keys());
+  }
+  // ==========================================================================
+  // Content Loading (L2 + L3)
+  // ==========================================================================
+  /**
+   * Load a skill's full content (L2: body + resource listing).
+   *
+   * Results are cached — subsequent calls return the cached content
+   * without re-reading the filesystem.
+   *
+   * @param name Skill name
+   * @returns Full skill content, or null if the skill doesn't exist
+   */
+  async loadContent(name) {
+    const cached = this.contentCache.get(name);
+    if (cached) return cached;
+    const metadata = this.skills.get(name);
+    if (!metadata) return null;
+    const content = await loadSkillContent(metadata);
+    this.contentCache.set(name, content);
+    return content;
+  }
+  /**
+   * Load a specific bundled resource from a skill (L3).
+   *
+   * The skill's content must be loaded first (via `loadContent`)
+   * so the resource listing is available.
+   *
+   * @param skillName  Skill name
+   * @param relativePath  Relative path to the resource within the skill dir
+   * @returns Resource file content as UTF-8 string
+   * @throws If the skill or resource doesn't exist
+   */
+  async loadResource(skillName, relativePath) {
+    const content = await this.loadContent(skillName);
+    if (!content) {
+      throw new Error(`Skill not found: "${skillName}"`);
+    }
+    const resource = content.resources.find(
+      (r) => r.relativePath === relativePath
+    );
+    if (!resource) {
+      const available = content.resources.map((r) => r.relativePath).join(", ");
+      throw new Error(
+        `Resource "${relativePath}" not found in skill "${skillName}". Available: ${available || "(none)"}`
+      );
+    }
+    return loadResourceContent(resource);
+  }
+  /**
+   * Get the list of resources for a loaded skill.
+   *
+   * @param name Skill name
+   * @returns Resource list, or empty array if skill isn't loaded yet
+   */
+  getResources(name) {
+    return this.contentCache.get(name)?.resources ?? [];
+  }
+  // ==========================================================================
+  // Prompt Summary (L1 — always in system prompt)
+  // ==========================================================================
+  /**
+   * Format a summary of all available skills for injection into the system prompt.
+   *
+   * This is the L1 layer — the agent sees names and descriptions of all
+   * available skills, enabling it to decide which to activate via tool calls.
+   *
+   * The output format uses XML tags (consistent with the instruction format
+   * in `formatInstructions`) for clear delineation in the prompt.
+   *
+   * Returns empty string if no skills are available.
+   *
+   * @example Output:
+   * ```xml
+   * <available-skills>
+   *
+   * You have access to the following skills. To activate a skill and load its
+   * full instructions, call the `skill` tool with the skill's name.
+   *
+   * <skill name="testing" scope="project">
+   * Write comprehensive test suites with vitest, covering unit, integration,
+   * and snapshot testing patterns.
+   * </skill>
+   *
+   * <skill name="frontend-design" scope="user">
+   * Create distinctive, production-grade frontend interfaces with high design quality.
+   * </skill>
+   *
+   * </available-skills>
+   * ```
+   */
+  formatSummary() {
+    if (this.skills.size === 0) return "";
+    const lines = [];
+    lines.push("<available-skills>");
+    lines.push("");
+    lines.push(
+      "You have access to the following skills. To activate a skill and load its full instructions, call the `skill` tool with the skill's name. Only load a skill when the current task matches its description."
+    );
+    for (const skill of this.skills.values()) {
+      lines.push("");
+      lines.push(`<skill name="${skill.name}" scope="${skill.scope}">`);
+      lines.push(skill.description);
+      if (skill.dependencies && skill.dependencies.length > 0) {
+        lines.push(`Depends on: ${skill.dependencies.join(", ")}`);
+      }
+      lines.push("</skill>");
+    }
+    lines.push("");
+    lines.push("</available-skills>");
+    return lines.join("\n");
+  }
+  /**
+   * Format the full content of a loaded skill for a tool response.
+   *
+   * Wraps the skill body in XML with metadata, and lists bundled resources
+   * so the agent knows what's available at L3.
+   *
+   * @param content Previously loaded skill content
+   * @returns Formatted string for tool response
+   */
+  formatContent(content) {
+    const lines = [];
+    lines.push(`<skill-content name="${content.name}">`);
+    lines.push("");
+    lines.push(content.body);
+    if (content.resources.length > 0) {
+      lines.push("");
+      lines.push("<bundled-resources>");
+      lines.push(
+        "This skill includes the following bundled files. To read one, call the `skill_resource` tool with the skill name and relative path."
+      );
+      lines.push("");
+      const byType = /* @__PURE__ */ new Map();
+      for (const r of content.resources) {
+        const list = byType.get(r.type) ?? [];
+        list.push(r);
+        byType.set(r.type, list);
+      }
+      for (const [type, resources] of byType) {
+        lines.push(`  ${type}s:`);
+        for (const r of resources) {
+          lines.push(`    - ${r.relativePath}`);
+        }
+      }
+      lines.push("</bundled-resources>");
+    }
+    if (content.dependencies && content.dependencies.length > 0) {
+      lines.push("");
+      lines.push(
+        `<dependencies>This skill works best when combined with: ${content.dependencies.join(", ")}</dependencies>`
+      );
+    }
+    lines.push("");
+    lines.push("</skill-content>");
+    return lines.join("\n");
+  }
+  // ==========================================================================
+  // Cache Management
+  // ==========================================================================
+  /** Clear the content cache, forcing reloads on next access. */
+  clearContentCache() {
+    this.contentCache.clear();
+  }
+  /** Check if a skill's content has been loaded and cached. */
+  isContentLoaded(name) {
+    return this.contentCache.has(name);
+  }
+};
+async function createSkillRegistry(cwd, config) {
+  const result = await discoverSkills(cwd, config);
+  return new SkillRegistry(result);
+}
+function emptySkillRegistry() {
+  return new SkillRegistry({
+    skills: [],
+    errors: [],
+    dirsScanned: 0,
+    durationMs: 0
+  });
+}
+
 // src/prompt/builder.ts
 var PRIORITY_BASE = 10;
 var PRIORITY_ENVIRONMENT = 20;
@@ -3884,6 +4529,8 @@ var PromptBuilder = class {
   envCache;
   /** Cached instruction files */
   instructionCache;
+  /** Cached skill registry */
+  skillRegistryCache;
   constructor(config) {
     this.config = {
       includeEnvironment: true,
@@ -3910,9 +4557,10 @@ var PromptBuilder = class {
    * with the configured separator.
    *
    * @param context - Build context with cwd, model, and optional override
+   * @param middleware - Optional middleware runner to collect dynamic sections from
    * @returns The composed system prompt string
    */
-  async build(context) {
+  async build(context, middleware) {
     const sections = [];
     const family = this.config.modelFamily ?? detectModelFamily(context.model);
     const templateContent = this.config.baseTemplate ?? getTemplate(family);
@@ -3942,9 +4590,25 @@ var PromptBuilder = class {
         });
       }
     }
+    if (this.config.skills) {
+      const registry = await this.getSkillRegistry(context.cwd);
+      const summary = registry.formatSummary();
+      if (summary.length > 0) {
+        sections.push({
+          id: "skills",
+          label: "Available Skills",
+          content: summary,
+          priority: PRIORITY_SKILLS
+        });
+      }
+    }
     for (const section of this.customSections.values()) {
       sections.push(section);
     }
+    if (middleware?.hasMiddleware) {
+      const mwSections = middleware.collectPromptSections(context);
+      sections.push(...mwSections);
+    }
     if (context.override) {
       sections.push({
         id: "override",
@@ -4031,6 +4695,29 @@ var PromptBuilder = class {
   clearCache() {
     this.envCache = void 0;
     this.instructionCache = void 0;
+    this.skillRegistryCache = void 0;
+  }
+  /**
+   * Get the skill registry for the current working directory.
+   *
+   * Runs skill discovery on first call and caches the result.
+   * Consumers can use this to get the registry for creating skill tools.
+   *
+   * @param cwd Working directory for skill discovery
+   * @returns The skill registry (may be empty if no skills config)
+   */
+  async getSkillRegistry(cwd) {
+    if (this.skillRegistryCache && this.skillRegistryCache.cwd === cwd) {
+      return this.skillRegistryCache.registry;
+    }
+    if (!this.config.skills) {
+      const registry2 = emptySkillRegistry();
+      this.skillRegistryCache = { cwd, registry: registry2 };
+      return registry2;
+    }
+    const registry = await createSkillRegistry(cwd, this.config.skills);
+    this.skillRegistryCache = { cwd, registry };
+    return registry;
   }
   // ============================================================================
   // Introspection
@@ -4324,7 +5011,7 @@ function localHost(defaultCwd) {
         PAGER: "cat",
         GIT_PAGER: "cat"
       };
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         let stdout = "";
         let stderr = "";
         let timedOut = false;
@@ -4354,12 +5041,12 @@ function localHost(defaultCwd) {
           if (child.pid) killProcessTree(child.pid);
         };
         options?.signal?.addEventListener("abort", onAbort, { once: true });
-        child.on("close", (code) => {
+        child.on("close", (code2) => {
           if (settled) return;
           settled = true;
           if (timer) clearTimeout(timer);
           options?.signal?.removeEventListener("abort", onAbort);
-          resolve5({ stdout, stderr, exitCode: code, timedOut });
+          resolve6({ stdout, stderr, exitCode: code2, timedOut });
         });
         child.on("error", (err) => {
           if (settled) return;
@@ -4390,7 +5077,7 @@ async function containerExec(container, docker, command, options = {}) {
   const stream = await exec.start({});
   let timedOut = false;
   let aborted = false;
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     docker.modem.demuxStream(
@@ -4433,7 +5120,7 @@ async function containerExec(container, docker, command, options = {}) {
       options.signal?.removeEventListener("abort", onAbort);
       try {
         const info = await exec.inspect();
-        resolve5({
+        resolve6({
           stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
           stderr: Buffer.concat(stderrChunks).toString("utf-8"),
           exitCode: timedOut || aborted ? null : info.ExitCode ?? 0,
@@ -4447,7 +5134,7 @@ async function containerExec(container, docker, command, options = {}) {
       if (timer) clearTimeout(timer);
       options.signal?.removeEventListener("abort", onAbort);
       if (timedOut || aborted) {
-        resolve5({
+        resolve6({
           stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
           stderr: Buffer.concat(stderrChunks).toString("utf-8"),
           exitCode: null,
@@ -4595,11 +5282,180 @@ function resolvePath(p, defaultWorkdir) {
   return base + p;
 }
 
+// src/middleware/runner.ts
+var MiddlewareRunner = class {
+  stack;
+  constructor(middleware = []) {
+    this.stack = Object.freeze([...middleware]);
+  }
+  /** Number of registered middleware */
+  get count() {
+    return this.stack.length;
+  }
+  /** Whether any middleware is registered */
+  get hasMiddleware() {
+    return this.stack.length > 0;
+  }
+  /** Get the middleware list (for fork inheritance) */
+  getMiddleware() {
+    return this.stack;
+  }
+  // --------------------------------------------------------------------------
+  // beforeToolCall — array order, first "deny" wins
+  // --------------------------------------------------------------------------
+  /**
+   * Run all `beforeToolCall` hooks in order.
+   *
+   * Returns `{ action: "allow" }` if all middleware allow (or have no hook).
+   * Returns `{ action: "deny", reason }` on first denial — remaining
+   * middleware are skipped.
+   */
+  async runBeforeToolCall(tool2, args, ctx) {
+    for (const mw of this.stack) {
+      if (!mw.beforeToolCall) continue;
+      try {
+        const decision = await mw.beforeToolCall(tool2, args, ctx);
+        if (decision.action === "deny") {
+          return decision;
+        }
+      } catch (err) {
+        return {
+          action: "deny",
+          reason: `Middleware "${mw.name}" error: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    }
+    return { action: "allow" };
+  }
+  // --------------------------------------------------------------------------
+  // afterToolCall — reverse order (innermost first)
+  // --------------------------------------------------------------------------
+  /**
+   * Run all `afterToolCall` hooks in reverse order.
+   *
+   * Each hook receives the result from the previous hook (or the
+   * original tool result for the first hook). Errors are caught
+   * and logged — the original result passes through.
+   */
+  async runAfterToolCall(tool2, args, result, ctx) {
+    let current = result;
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const mw = this.stack[i];
+      if (!mw.afterToolCall) continue;
+      try {
+        current = await mw.afterToolCall(tool2, args, current, ctx);
+      } catch (err) {
+        console.warn(
+          `[middleware] "${mw.name}" afterToolCall error:`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+    return current;
+  }
+  // --------------------------------------------------------------------------
+  // promptSections — all run, results merged
+  // --------------------------------------------------------------------------
+  /**
+   * Collect prompt sections from all middleware.
+   *
+   * Returns a flat array of sections. Each middleware can return a single
+   * section, an array of sections, or undefined/empty.
+   */
+  collectPromptSections(ctx) {
+    const sections = [];
+    for (const mw of this.stack) {
+      if (!mw.promptSections) continue;
+      try {
+        const result = mw.promptSections(ctx);
+        if (!result) continue;
+        if (Array.isArray(result)) {
+          sections.push(...result);
+        } else {
+          sections.push(result);
+        }
+      } catch (err) {
+        console.warn(
+          `[middleware] "${mw.name}" promptSections error:`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+    return sections;
+  }
+  // --------------------------------------------------------------------------
+  // onEvent — fire-and-forget, all run
+  // --------------------------------------------------------------------------
+  /**
+   * Broadcast an event to all middleware observers.
+   *
+   * Non-blocking — errors are caught and logged. This never
+   * slows down the streaming pipeline.
+   */
+  emitEvent(event) {
+    for (const mw of this.stack) {
+      if (!mw.onEvent) continue;
+      try {
+        mw.onEvent(event);
+      } catch {
+      }
+    }
+  }
+  // --------------------------------------------------------------------------
+  // onChatStart — array order, sequential
+  // --------------------------------------------------------------------------
+  /**
+   * Run all `onChatStart` hooks in order.
+   *
+   * Errors are caught and logged — a broken logger should not
+   * prevent the chat from starting.
+   */
+  async runChatStart(sessionId, message) {
+    for (const mw of this.stack) {
+      if (!mw.onChatStart) continue;
+      try {
+        await mw.onChatStart(sessionId, message);
+      } catch (err) {
+        console.warn(
+          `[middleware] "${mw.name}" onChatStart error:`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+  }
+  // --------------------------------------------------------------------------
+  // onChatEnd — array order, sequential
+  // --------------------------------------------------------------------------
+  /**
+   * Run all `onChatEnd` hooks in order.
+   *
+   * Always called, even when the stream errored. Errors in handlers
+   * are caught and logged.
+   */
+  async runChatEnd(sessionId, result) {
+    for (const mw of this.stack) {
+      if (!mw.onChatEnd) continue;
+      try {
+        await mw.onChatEnd(sessionId, result);
+      } catch (err) {
+        console.warn(
+          `[middleware] "${mw.name}" onChatEnd error:`,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+  }
+};
+
 // src/agent.ts
 var DEFAULT_SYSTEM_PROMPT = `You are a capable AI assistant with access to tools.
+
 Think step by step about what you need to do.
 Use the available tools to accomplish tasks.
-Verify your results after each action.`;
+Verify your results after each action.
+
+If a tool fails, try an alternative approach \u2014 do not give up after a single error.
+Keep working until the task is fully resolved or you have exhausted all options.`;
 var DEFAULT_MAX_STEPS = 50;
 var DEFAULT_MAX_TOKENS = 32e3;
 var DEFAULT_CUSTOM_STREAM_MODELS = [
@@ -4676,6 +5532,8 @@ var Agent = class _Agent {
   interventionCtrl;
   /** Execution environment for tool operations */
   host;
+  /** Middleware runner for lifecycle hooks */
+  middlewareRunner;
   constructor(config) {
     if (config.prompt !== void 0) {
       this.promptBuilder = createPromptBuilder(config.prompt);
@@ -4741,6 +5599,7 @@ var Agent = class _Agent {
     this.mcpManager = config.mcp;
     this.interventionCtrl = new InterventionController();
     this.host = config.host ?? localHost(this.config.cwd);
+    this.middlewareRunner = new MiddlewareRunner(config.middleware);
     if (config.prompt !== void 0) {
       this.config.prompt = config.prompt;
     }
@@ -4932,7 +5791,12 @@ var Agent = class _Agent {
     const mcpTools = await this.ensureMCPConnected();
     this.state.isStreaming = true;
     const prevOnApplied = this.interventionCtrl.onApplied;
+    let chatUsage;
+    let chatError;
     try {
+      if (this.middlewareRunner.hasMiddleware) {
+        await this.middlewareRunner.runChatStart(sessionId, message);
+      }
       let systemPrompts;
       if (this.promptBuilder) {
         const composedPrompt = await this.promptBuilder.build({
@@ -4941,7 +5805,7 @@ var Agent = class _Agent {
           toolNames: Array.from(this.tools.keys()),
           override: options?.system,
           sessionId
-        });
+        }, this.middlewareRunner);
         systemPrompts = [composedPrompt];
       } else {
         systemPrompts = [this.config.systemPrompt];
@@ -4972,7 +5836,9 @@ var Agent = class _Agent {
         turnTracker: this.turnTracker,
         // Pass intervention controller for mid-turn message injection.
         // Only effective when using the standard AI SDK path (not custom providers).
-        intervention: this.interventionCtrl
+        intervention: this.interventionCtrl,
+        // Pass middleware runner for tool lifecycle hooks
+        middleware: this.middlewareRunner
       });
       const eventQueue = [];
       let resolveNext = null;
@@ -5005,6 +5871,7 @@ var Agent = class _Agent {
         onContextOverflow: async (_tokens, _limit) => {
         },
         onEvent: async (event) => {
+          this.middlewareRunner.emitEvent(event);
           eventQueue.push(event);
           if (resolveNext) {
             resolveNext();
@@ -5097,8 +5964,8 @@ var Agent = class _Agent {
           }
         }
         if (!streamDone) {
-          await new Promise((resolve5) => {
-            resolveNext = resolve5;
+          await new Promise((resolve6) => {
+            resolveNext = resolve6;
           });
         }
       }
@@ -5146,10 +6013,20 @@ var Agent = class _Agent {
           deletions: turnSummary.deletions
         };
       }
+      chatUsage = result?.usage;
       yield { type: "complete", usage: result?.usage };
+    } catch (err) {
+      chatError = err instanceof Error ? err : new Error(String(err));
+      throw err;
     } finally {
       this.state.isStreaming = false;
       this.interventionCtrl.onApplied = prevOnApplied;
+      if (this.middlewareRunner.hasMiddleware) {
+        await this.middlewareRunner.runChatEnd(sessionId, {
+          usage: chatUsage,
+          error: chatError
+        });
+      }
     }
   }
   /**
@@ -5598,7 +6475,9 @@ var Agent = class _Agent {
       compaction: this.config.compaction,
       contextWindow: this.config.contextWindow,
       // Share MCP manager (connections are shared)
-      mcp: this.mcpManager
+      mcp: this.mcpManager,
+      // Middleware: explicit override > additional appended > inherit parent's
+      middleware: effectiveOptions.middleware ?? (effectiveOptions.additionalMiddleware ? [...this.middlewareRunner.getMiddleware(), ...effectiveOptions.additionalMiddleware] : [...this.middlewareRunner.getMiddleware()])
     });
   }
   /**
@@ -5710,12 +6589,22 @@ var Agent = class _Agent {
 // src/safety/approval.ts
 var DEFAULT_TOOL_RISKS = {
   // Safe - read-only operations
+  read: "safe",
   read_file: "safe",
   grep: "safe",
   glob: "safe",
   list_dir: "safe",
+  // Safe - sub-agent delegation (sub-agent's own tools go through approval)
+  invoke_agent: "safe",
+  wait_agent: "safe",
+  close_agent: "safe",
+  // Safe - skill loading (read-only knowledge retrieval)
+  skill: "safe",
+  skill_resource: "safe",
   // Moderate - file modifications
+  write: "moderate",
   write_file: "moderate",
+  edit: "moderate",
   edit_file: "moderate",
   create_file: "moderate",
   // Dangerous - system commands, deletions
@@ -5736,9 +6625,10 @@ function matchPattern(pattern, value) {
 function extractPatterns(tool2, args) {
   if (!args || typeof args !== "object") return [tool2];
   const a = args;
-  if ("path" in a && typeof a.path === "string") {
-    const dir = a.path.substring(0, a.path.lastIndexOf("/") + 1);
-    return [dir ? `${dir}*` : a.path];
+  if ("path" in a && typeof a.path === "string" || "filePath" in a && typeof a.filePath === "string") {
+    const p = a.path ?? a.filePath;
+    const dir = p.substring(0, p.lastIndexOf("/") + 1);
+    return [dir ? `${dir}*` : p];
   }
   if ("command" in a && typeof a.command === "string") {
     const cmd = a.command.split(/\s+/)[0];
@@ -5753,13 +6643,16 @@ function describeOperation(tool2, args) {
   if (!args || typeof args !== "object") return `Execute ${tool2}`;
   const a = args;
   switch (tool2) {
+    case "read":
     case "read_file":
-      return `Read file: ${a.path}`;
+      return `Read file: ${a.path ?? a.filePath}`;
+    case "write":
     case "write_file":
     case "create_file":
-      return `Write file: ${a.path}`;
+      return `Write file: ${a.path ?? a.filePath}`;
+    case "edit":
     case "edit_file":
-      return `Edit file: ${a.path}`;
+      return `Edit file: ${a.path ?? a.filePath}`;
     case "delete_file":
     case "remove":
       return `Delete: ${a.path}`;
@@ -5843,9 +6736,9 @@ function createApprovalHandler(config = {}) {
       timestamp: Date.now()
     };
     const action = await Promise.race([
-      new Promise((resolve5, reject) => {
-        pending.set(id, { resolve: resolve5, reject });
-        onRequest(request2).then(resolve5).catch(reject).finally(() => pending.delete(id));
+      new Promise((resolve6, reject) => {
+        pending.set(id, { resolve: resolve6, reject });
+        onRequest(request2).then(resolve6).catch(reject).finally(() => pending.delete(id));
       }),
       new Promise((_, reject) => {
         setTimeout(() => {
@@ -5892,12 +6785,12 @@ function createApprovalHandler(config = {}) {
 
 // src/tracking/checkpoint.ts
 import { spawn as spawn3 } from "child_process";
-import { mkdir as mkdir3, unlink as unlink3, readFile as readFile4, writeFile as writeFile3, access as access2, rm } from "fs/promises";
-import { join as join4, relative as relative2, resolve as resolve4, dirname as dirname3 } from "path";
+import { mkdir as mkdir3, unlink as unlink3, readFile as readFile5, writeFile as writeFile3, access as access3, rm } from "fs/promises";
+import { join as join6, relative as relative3, resolve as resolve5, dirname as dirname4 } from "path";
 import { createHash as createHash2 } from "crypto";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 async function git(gitDir, workTree, args, _options = {}) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const fullArgs = ["--git-dir", gitDir, "--work-tree", workTree, ...args];
     const proc = spawn3("git", fullArgs, {
       cwd: workTree,
@@ -5916,12 +6809,12 @@ async function git(gitDir, workTree, args, _options = {}) {
     proc.stderr.on("data", (data) => {
       stderr += data.toString();
     });
-    proc.on("close", (code) => {
-      const exitCode = code ?? 0;
-      resolve5({ stdout: stdout.trim(), stderr: stderr.trim(), exitCode });
+    proc.on("close", (code2) => {
+      const exitCode = code2 ?? 0;
+      resolve6({ stdout: stdout.trim(), stderr: stderr.trim(), exitCode });
     });
     proc.on("error", (err) => {
-      resolve5({ stdout: "", stderr: err.message, exitCode: 1 });
+      resolve6({ stdout: "", stderr: err.message, exitCode: 1 });
     });
   });
 }
@@ -5930,11 +6823,11 @@ function projectId(workDir) {
 }
 function defaultStorageDir(workDir) {
   const id = projectId(workDir);
-  return join4(homedir4(), ".cuylabs", "checkpoints", id);
+  return join6(homedir5(), ".cuylabs", "checkpoints", id);
 }
 async function readCheckpointLog(logPath) {
   try {
-    const content = await readFile4(logPath, "utf-8");
+    const content = await readFile5(logPath, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     return lines.map((line) => {
       const entry = JSON.parse(line);
@@ -5952,9 +6845,9 @@ async function appendCheckpointLog(logPath, checkpoint) {
     ...checkpoint,
     createdAt: checkpoint.createdAt.toISOString()
   }) + "\n";
-  await mkdir3(dirname3(logPath), { recursive: true });
+  await mkdir3(dirname4(logPath), { recursive: true });
   try {
-    const existing = await readFile4(logPath, "utf-8");
+    const existing = await readFile5(logPath, "utf-8");
     await writeFile3(logPath, existing + line);
   } catch {
     await writeFile3(logPath, line);
@@ -5962,7 +6855,7 @@ async function appendCheckpointLog(logPath, checkpoint) {
 }
 async function removeFromLog(logPath, checkpointId) {
   try {
-    const content = await readFile4(logPath, "utf-8");
+    const content = await readFile5(logPath, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     const filtered = lines.filter((line) => {
       const entry = JSON.parse(line);
@@ -5973,10 +6866,10 @@ async function removeFromLog(logPath, checkpointId) {
   }
 }
 async function createCheckpointManager(config) {
-  const workDir = resolve4(config.workDir);
+  const workDir = resolve5(config.workDir);
   const storageDir = config.storageDir ?? defaultStorageDir(workDir);
-  const gitDir = join4(storageDir, "git");
-  const logPath = join4(storageDir, "checkpoints.jsonl");
+  const gitDir = join6(storageDir, "git");
+  const logPath = join6(storageDir, "checkpoints.jsonl");
   const state = {
     config: {
       workDir,
@@ -5992,23 +6885,23 @@ async function createCheckpointManager(config) {
   async function initialize() {
     if (state.initialized) return;
     await mkdir3(gitDir, { recursive: true });
-    const headPath = join4(gitDir, "HEAD");
+    const headPath = join6(gitDir, "HEAD");
     let needsInit = false;
     try {
-      await access2(headPath);
+      await access3(headPath);
     } catch {
       needsInit = true;
     }
     if (needsInit) {
-      const initResult = await new Promise((resolve5) => {
+      const initResult = await new Promise((resolve6) => {
         const proc = spawn3("git", ["init", "--bare"], {
           cwd: gitDir,
           stdio: ["pipe", "pipe", "pipe"]
         });
         let stderr = "";
         proc.stderr.on("data", (d) => stderr += d.toString());
-        proc.on("close", (code) => resolve5({ exitCode: code ?? 0, stderr }));
-        proc.on("error", (err) => resolve5({ exitCode: 1, stderr: err.message }));
+        proc.on("close", (code2) => resolve6({ exitCode: code2 ?? 0, stderr }));
+        proc.on("error", (err) => resolve6({ exitCode: 1, stderr: err.message }));
       });
       if (initResult.exitCode !== 0) {
         throw new Error(`Failed to init checkpoint repo: ${initResult.stderr}`);
@@ -6062,7 +6955,7 @@ async function createCheckpointManager(config) {
       const changes = await manager.changes(checkpointId);
       for (const change of changes.files) {
         if (change.type === "added") {
-          const filePath = join4(workDir, change.path);
+          const filePath = join6(workDir, change.path);
           try {
             await unlink3(filePath);
           } catch {
@@ -6108,12 +7001,12 @@ async function createCheckpointManager(config) {
     async undoFiles(checkpointId, files) {
       await initialize();
       for (const file of files) {
-        const relativePath = relative2(workDir, resolve4(workDir, file));
+        const relativePath = relative3(workDir, resolve5(workDir, file));
         const result = await git(gitDir, workDir, ["checkout", checkpointId, "--", relativePath]);
         if (result.exitCode !== 0) {
           const lsResult = await git(gitDir, workDir, ["ls-tree", checkpointId, "--", relativePath]);
           if (!lsResult.stdout.trim()) {
-            const filePath = join4(workDir, relativePath);
+            const filePath = join6(workDir, relativePath);
             try {
               await unlink3(filePath);
             } catch {
@@ -6147,7 +7040,7 @@ async function createCheckpointManager(config) {
     },
     async getFileAt(checkpointId, filePath) {
       await initialize();
-      const relativePath = relative2(workDir, resolve4(workDir, filePath));
+      const relativePath = relative3(workDir, resolve5(workDir, filePath));
       const result = await git(gitDir, workDir, ["show", `${checkpointId}:${relativePath}`]);
       if (result.exitCode !== 0) return null;
       return result.stdout;
@@ -6169,6 +7062,23 @@ async function clearCheckpoints(workDir) {
   }
 }
 
+// src/middleware/approval.ts
+function approvalMiddleware(config = {}) {
+  const handler = createApprovalHandler(config);
+  return {
+    name: "approval",
+    async beforeToolCall(tool2, args, ctx) {
+      try {
+        await handler.request(ctx.sessionID, tool2, args, config.customRisks);
+        return { action: "allow" };
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : `Approval denied: ${tool2}`;
+        return { action: "deny", reason };
+      }
+    }
+  };
+}
+
 // src/mcp.ts
 var mcpModule;
 var stdioModule;
@@ -6432,6 +7342,583 @@ function sseServer(url, options) {
   };
 }
 
+// src/builtins/skill/tools.ts
+import { z } from "zod";
+function createSkillTool(registry) {
+  return Tool.define("skill", () => {
+    const skills = registry.list();
+    const skillList = skills.length > 0 ? skills.map((s) => `  - "${s.name}": ${s.description}`).join("\n") : "  (no skills available)";
+    return {
+      description: `Load a skill's full instructions to gain specialized knowledge for a task.
+
+Available skills:
+${skillList}
+
+Only load a skill when the current task clearly matches its description. Skills provide detailed workflows, reference material, and scripts.`,
+      parameters: z.object({
+        name: z.string().describe("The name of the skill to load (must match one of the available skills)")
+      }),
+      execute: async ({ name }) => {
+        const content = await registry.loadContent(name);
+        if (!content) {
+          const available = registry.names.join(", ");
+          return {
+            title: `Skill not found: ${name}`,
+            output: `No skill named "${name}" exists.
+
+Available skills: ${available || "(none)"}`,
+            metadata: {}
+          };
+        }
+        const formatted = registry.formatContent(content);
+        let depNote = "";
+        if (content.dependencies && content.dependencies.length > 0) {
+          const unloaded = content.dependencies.filter(
+            (dep) => registry.has(dep) && !registry.isContentLoaded(dep)
+          );
+          if (unloaded.length > 0) {
+            depNote = `
+
+Note: This skill works best with these additional skills: ${unloaded.join(", ")}. Consider loading them if relevant.`;
+          }
+        }
+        return {
+          title: `Loaded skill: ${content.name}`,
+          output: formatted + depNote,
+          metadata: {}
+        };
+      }
+    };
+  });
+}
+function createSkillResourceTool(registry) {
+  return Tool.define("skill_resource", {
+    description: "Read a specific file bundled with a skill (scripts, references, examples, assets). The skill must be loaded first via the `skill` tool to see available resources.",
+    parameters: z.object({
+      skill: z.string().describe("The skill name"),
+      path: z.string().describe("Relative path to the resource file within the skill")
+    }),
+    execute: async ({ skill, path: path2 }) => {
+      try {
+        const content = await registry.loadResource(skill, path2);
+        return {
+          title: `${skill}/${path2}`,
+          output: content,
+          metadata: {}
+        };
+      } catch (err) {
+        return {
+          title: `Error reading resource`,
+          output: err instanceof Error ? err.message : String(err),
+          metadata: {}
+        };
+      }
+    }
+  });
+}
+function createSkillTools(registry) {
+  if (registry.size === 0) return [];
+  return [
+    createSkillTool(registry),
+    createSkillResourceTool(registry)
+  ];
+}
+
+// src/sub-agent/types.ts
+var DEFAULT_MAX_CONCURRENT = 6;
+var DEFAULT_MAX_SPAWN_DEPTH = 2;
+var DEFAULT_SESSION_TITLE_PREFIX = "Sub-agent";
+
+// src/sub-agent/tracker.ts
+var SubAgentTracker = class {
+  /** Active sub-agent handles by ID */
+  handles = /* @__PURE__ */ new Map();
+  /** Maximum concurrent sub-agents */
+  maxConcurrent;
+  /** Maximum nesting depth */
+  maxDepth;
+  /** Current depth in the spawn hierarchy */
+  currentDepth;
+  constructor(config) {
+    this.maxConcurrent = config?.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+    this.maxDepth = config?.maxDepth ?? DEFAULT_MAX_SPAWN_DEPTH;
+    this.currentDepth = config?.currentDepth ?? 0;
+  }
+  // ==========================================================================
+  // Slot Management
+  // ==========================================================================
+  /** Number of currently active (running) sub-agents */
+  get activeCount() {
+    let count = 0;
+    for (const handle of this.handles.values()) {
+      if (handle.status.state === "running") count++;
+    }
+    return count;
+  }
+  /** Total tracked handles (including completed) */
+  get totalCount() {
+    return this.handles.size;
+  }
+  /**
+   * Check if a new sub-agent can be spawned.
+   * Returns an error message if not, undefined if OK.
+   */
+  canSpawn() {
+    if (this.currentDepth >= this.maxDepth) {
+      return `Sub-agent depth limit reached (current: ${this.currentDepth}, max: ${this.maxDepth}). Complete the task yourself instead of delegating further.`;
+    }
+    if (this.activeCount >= this.maxConcurrent) {
+      return `Maximum concurrent sub-agents reached (${this.maxConcurrent}). Wait for an existing sub-agent to complete before spawning a new one.`;
+    }
+    return void 0;
+  }
+  /** Whether the current depth allows further spawning */
+  get canNest() {
+    return this.currentDepth + 1 < this.maxDepth;
+  }
+  // ==========================================================================
+  // Handle Management
+  // ==========================================================================
+  /** Register a new sub-agent handle */
+  register(handle) {
+    this.handles.set(handle.id, handle);
+  }
+  /** Get a handle by ID */
+  get(id) {
+    return this.handles.get(id);
+  }
+  /** Update a handle's status */
+  updateStatus(id, status) {
+    const handle = this.handles.get(id);
+    if (handle) {
+      handle.status = status;
+    }
+  }
+  /** Get all handles */
+  list() {
+    return Array.from(this.handles.values());
+  }
+  /** Get all running handles */
+  running() {
+    return this.list().filter((h) => h.status.state === "running");
+  }
+  /** Get all completed handles */
+  completed() {
+    return this.list().filter((h) => h.status.state === "completed");
+  }
+  /**
+   * Cancel a running sub-agent.
+   * Signals the abort controller and updates status.
+   */
+  cancel(id) {
+    const handle = this.handles.get(id);
+    if (!handle || handle.status.state !== "running") return false;
+    handle.abort.abort();
+    handle.status = { state: "cancelled" };
+    return true;
+  }
+  /**
+   * Cancel all running sub-agents.
+   */
+  cancelAll() {
+    for (const handle of this.handles.values()) {
+      if (handle.status.state === "running") {
+        handle.abort.abort();
+        handle.status = { state: "cancelled" };
+      }
+    }
+  }
+  /**
+   * Wait for a specific sub-agent to complete.
+   * Returns the result or throws if not found.
+   */
+  async wait(id, timeoutMs) {
+    const handle = this.handles.get(id);
+    if (!handle) {
+      throw new Error(`Sub-agent not found: "${id}"`);
+    }
+    if (handle.status.state === "completed") {
+      return {
+        response: handle.status.response,
+        sessionId: handle.sessionId,
+        usage: handle.status.usage,
+        toolCalls: []
+      };
+    }
+    if (handle.status.state !== "running") {
+      throw new Error(
+        `Sub-agent "${id}" is in state "${handle.status.state}" and cannot be waited on.`
+      );
+    }
+    if (timeoutMs !== void 0 && timeoutMs > 0) {
+      const timeout = new Promise(
+        (_, reject) => setTimeout(
+          () => reject(new Error(`Timed out waiting for sub-agent "${id}" after ${timeoutMs}ms`)),
+          timeoutMs
+        )
+      );
+      return Promise.race([handle.promise, timeout]);
+    }
+    return handle.promise;
+  }
+  /**
+   * Wait for any one of the given sub-agents to complete.
+   * Returns the first result.
+   */
+  async waitAny(ids, timeoutMs) {
+    const handles = ids.map((id) => this.handles.get(id)).filter((h) => h !== void 0);
+    if (handles.length === 0) {
+      throw new Error(`No sub-agents found for IDs: ${ids.join(", ")}`);
+    }
+    for (const handle of handles) {
+      if (handle.status.state === "completed") {
+        return {
+          id: handle.id,
+          result: {
+            response: handle.status.response,
+            sessionId: handle.sessionId,
+            usage: handle.status.usage,
+            toolCalls: []
+          }
+        };
+      }
+    }
+    const races = handles.filter((h) => h.status.state === "running").map(
+      (h) => h.promise.then((result) => ({ id: h.id, result }))
+    );
+    if (races.length === 0) {
+      throw new Error("No running sub-agents to wait on.");
+    }
+    if (timeoutMs !== void 0 && timeoutMs > 0) {
+      const timeout = new Promise(
+        (resolve6) => setTimeout(() => resolve6({ timedOut: true }), timeoutMs)
+      );
+      return Promise.race([...races, timeout]);
+    }
+    return Promise.race(races);
+  }
+  /**
+   * Create a child tracker configuration for a nested sub-agent.
+   * Increments the depth counter.
+   */
+  childConfig() {
+    return {
+      maxConcurrent: this.maxConcurrent,
+      maxDepth: this.maxDepth,
+      currentDepth: this.currentDepth + 1
+    };
+  }
+};
+
+// src/builtins/sub-agent/tools.ts
+import { z as z2 } from "zod";
+var agentCounter = 0;
+function generateAgentId(profileName) {
+  return `${profileName}-${++agentCounter}-${Date.now().toString(36)}`;
+}
+function createInvokeAgentTool(parent, config, tracker) {
+  const isAsync = config.async ?? false;
+  const titlePrefix = config.sessionTitlePrefix ?? DEFAULT_SESSION_TITLE_PREFIX;
+  return Tool.define("invoke_agent", () => {
+    const profileList = config.profiles.map((p) => `  - "${p.name}": ${p.description}`).join("\n");
+    const validNames = config.profiles.map((p) => p.name);
+    const modeNote = isAsync ? "Returns an agent ID immediately. Use `wait_agent` to collect the result." : "Blocks until the sub-agent completes and returns the result directly.";
+    return {
+      description: `Delegate a focused task to a specialized sub-agent.
+
+Available agent types:
+${profileList}
+
+${modeNote}
+
+Guidelines:
+- Use sub-agents for well-scoped, independent tasks
+- Provide clear, self-contained instructions \u2014 the sub-agent has a fresh context
+- Include any relevant file paths, function names, or context the sub-agent needs
+- Mention the working directory structure if known (e.g. "code is in packages/agent-core/src")
+- For parallel work, invoke multiple agents before waiting for results
+- Sub-agents will retry on errors and explore alternatives \u2014 they are resilient`,
+      parameters: z2.object({
+        agent_type: z2.string().describe(
+          `The type of specialized agent to use. Must be one of: ${validNames.join(", ")}`
+        ),
+        task: z2.string().describe(
+          "A detailed, self-contained description of the task. Include all context the sub-agent needs."
+        ),
+        title: z2.string().optional().describe("Short title for tracking (3-5 words)")
+      }),
+      execute: async (params, ctx) => {
+        const profile = config.profiles.find((p) => p.name === params.agent_type);
+        if (!profile) {
+          return {
+            title: "Invalid agent type",
+            output: `Unknown agent type "${params.agent_type}".
+
+Available types: ${validNames.join(", ")}`,
+            metadata: {}
+          };
+        }
+        const spawnError = tracker.canSpawn();
+        if (spawnError) {
+          return {
+            title: "Cannot spawn sub-agent",
+            output: spawnError,
+            metadata: {}
+          };
+        }
+        const child = buildChildAgent(parent, profile);
+        const taskTitle = params.title ?? `${titlePrefix}: ${profile.name}`;
+        if (isAsync) {
+          return runAsync(child, profile, params.task, taskTitle, { sessionId: ctx.sessionID, abort: ctx.abort }, tracker);
+        } else {
+          return runSync(child, profile, params.task, taskTitle, { sessionId: ctx.sessionID, abort: ctx.abort });
+        }
+      }
+    };
+  });
+}
+async function runSync(child, profile, task, title, ctx) {
+  try {
+    const result = await child.run({
+      parentSessionId: ctx.sessionId,
+      message: task,
+      title,
+      abort: ctx.abort
+    });
+    const usageLine = result.usage ? `
+Tokens: ${result.usage.inputTokens} in / ${result.usage.outputTokens} out` : "";
+    const toolsLine = result.toolCalls.length > 0 ? `
+Tool calls: ${result.toolCalls.map((t) => t.name).join(", ")}` : "";
+    return {
+      title: `${profile.name} completed`,
+      output: `<agent_result agent="${profile.name}" session="${result.sessionId}">
+` + result.response + `
+</agent_result>` + usageLine + toolsLine,
+      metadata: {
+        sessionId: result.sessionId,
+        profile: profile.name,
+        toolCalls: result.toolCalls.length
+      }
+    };
+  } catch (err) {
+    return {
+      title: `${profile.name} failed`,
+      output: `Sub-agent "${profile.name}" encountered an error:
+` + (err instanceof Error ? err.message : String(err)) + `
+
+Consider handling the task directly.`,
+      metadata: { profile: profile.name, error: true }
+    };
+  }
+}
+async function runAsync(child, profile, task, title, ctx, tracker) {
+  const id = generateAgentId(profile.name);
+  const sessionId = ctx.sessionId ? `${ctx.sessionId}:sub:${id}` : `sub:${id}`;
+  const abortController = new AbortController();
+  if (ctx.abort) {
+    ctx.abort.addEventListener("abort", () => abortController.abort(), { once: true });
+  }
+  const promise = child.run({
+    parentSessionId: ctx.sessionId,
+    message: task,
+    title,
+    abort: abortController.signal
+  }).then((result) => {
+    const completed = {
+      response: result.response,
+      sessionId: result.sessionId,
+      usage: {
+        inputTokens: result.usage?.inputTokens ?? 0,
+        outputTokens: result.usage?.outputTokens ?? 0,
+        totalTokens: result.usage?.totalTokens ?? 0
+      },
+      toolCalls: result.toolCalls
+    };
+    tracker.updateStatus(id, {
+      state: "completed",
+      response: result.response,
+      usage: completed.usage
+    });
+    return completed;
+  }).catch((err) => {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    tracker.updateStatus(id, { state: "errored", error: errorMsg });
+    throw err;
+  });
+  const handle = {
+    id,
+    name: profile.name,
+    sessionId,
+    status: { state: "running" },
+    promise,
+    abort: abortController
+  };
+  tracker.register(handle);
+  return {
+    title: `Spawned ${profile.name}`,
+    output: `Sub-agent spawned successfully.
+
+Agent ID: ${id}
+Type: ${profile.name}
+Session: ${sessionId}
+
+Use \`wait_agent\` with this ID to collect the result when ready.`,
+    metadata: {
+      agentId: id,
+      profile: profile.name,
+      sessionId
+    }
+  };
+}
+function createWaitAgentTool(tracker) {
+  return Tool.define("wait_agent", {
+    description: "Wait for one or more sub-agents to complete and return their results. When multiple IDs are provided, returns whichever finishes first. Use a timeout to avoid blocking indefinitely.",
+    parameters: z2.object({
+      ids: z2.array(z2.string()).min(1).describe("Agent IDs to wait on (from invoke_agent)"),
+      timeout_ms: z2.number().optional().describe("Timeout in milliseconds (default: 60000, max: 600000)")
+    }),
+    execute: async (params) => {
+      const timeoutMs = Math.min(params.timeout_ms ?? 6e4, 6e5);
+      const missing = params.ids.filter((id) => !tracker.get(id));
+      if (missing.length > 0) {
+        return {
+          title: "Agent(s) not found",
+          output: `Unknown agent IDs: ${missing.join(", ")}`,
+          metadata: {}
+        };
+      }
+      try {
+        if (params.ids.length === 1) {
+          const result = await tracker.wait(params.ids[0], timeoutMs);
+          return formatWaitResult(params.ids[0], result, tracker);
+        } else {
+          const outcome = await tracker.waitAny(params.ids, timeoutMs);
+          if ("timedOut" in outcome) {
+            const running = params.ids.map((id) => tracker.get(id)).filter((h) => h?.status.state === "running").map((h) => h.id);
+            return {
+              title: "Wait timed out",
+              output: `Timed out after ${timeoutMs}ms. Still running: ${running.join(", ")}.
+
+Call \`wait_agent\` again to continue waiting, or \`close_agent\` to cancel.`,
+              metadata: { timedOut: true }
+            };
+          }
+          return formatWaitResult(outcome.id, outcome.result, tracker);
+        }
+      } catch (err) {
+        return {
+          title: "Wait failed",
+          output: err instanceof Error ? err.message : String(err),
+          metadata: { error: true }
+        };
+      }
+    }
+  });
+}
+function formatWaitResult(id, result, tracker) {
+  const handle = tracker.get(id);
+  const profileName = handle?.name ?? "agent";
+  const usageLine = result.usage ? `
+Tokens: ${result.usage.inputTokens} in / ${result.usage.outputTokens} out` : "";
+  const toolsLine = result.toolCalls.length > 0 ? `
+Tool calls: ${result.toolCalls.map((t) => t.name).join(", ")}` : "";
+  const stillRunning = tracker.running().filter((h) => h.id !== id);
+  const runningNote = stillRunning.length > 0 ? `
+
+Still running: ${stillRunning.map((h) => `${h.id} (${h.name})`).join(", ")}` : "";
+  return {
+    title: `${profileName} completed`,
+    output: `<agent_result agent="${profileName}" id="${id}" session="${result.sessionId}">
+` + result.response + `
+</agent_result>` + usageLine + toolsLine + runningNote,
+    metadata: {
+      agentId: id,
+      profile: profileName,
+      sessionId: result.sessionId,
+      toolCalls: result.toolCalls.length
+    }
+  };
+}
+function createCloseAgentTool(tracker) {
+  return Tool.define("close_agent", {
+    description: "Cancel a running sub-agent. Use when the result is no longer needed or the sub-agent is taking too long.",
+    parameters: z2.object({
+      id: z2.string().describe("Agent ID to cancel (from invoke_agent)")
+    }),
+    execute: async (params) => {
+      const handle = tracker.get(params.id);
+      if (!handle) {
+        return {
+          title: "Agent not found",
+          output: `No sub-agent with ID "${params.id}".`,
+          metadata: {}
+        };
+      }
+      if (handle.status.state !== "running") {
+        return {
+          title: `Agent already ${handle.status.state}`,
+          output: `Sub-agent "${params.id}" is already ${handle.status.state}. ` + (handle.status.state === "completed" ? "Use `wait_agent` to retrieve its result." : "No action taken."),
+          metadata: { state: handle.status.state }
+        };
+      }
+      tracker.cancel(params.id);
+      return {
+        title: `Cancelled ${handle.name}`,
+        output: `Sub-agent "${params.id}" (${handle.name}) has been cancelled.`,
+        metadata: {
+          agentId: params.id,
+          profile: handle.name
+        }
+      };
+    }
+  });
+}
+function buildChildAgent(parent, profile) {
+  const forkOptions = {};
+  if (profile.preset) {
+    forkOptions.preset = profile.preset;
+  }
+  if (profile.systemPrompt) {
+    forkOptions.systemPrompt = profile.systemPrompt;
+  }
+  if (profile.model) {
+    forkOptions.model = profile.model;
+  }
+  if (profile.maxSteps) {
+    forkOptions.maxSteps = profile.maxSteps;
+  }
+  if (profile.additionalMiddleware) {
+    forkOptions.additionalMiddleware = profile.additionalMiddleware;
+  }
+  const child = parent.fork(forkOptions);
+  if (profile.additionalTools && profile.additionalTools.length > 0) {
+    const currentTools = child.getTools();
+    return parent.fork({
+      ...forkOptions,
+      tools: [...currentTools, ...profile.additionalTools]
+    });
+  }
+  return child;
+}
+function createSubAgentTools(parent, config) {
+  if (config.profiles.length === 0) {
+    return [];
+  }
+  const currentDepth = config.currentDepth ?? 0;
+  const maxDepth = config.maxDepth ?? DEFAULT_MAX_SPAWN_DEPTH;
+  if (currentDepth >= maxDepth) {
+    return [];
+  }
+  const tracker = new SubAgentTracker(config);
+  const tools = [];
+  tools.push(createInvokeAgentTool(parent, config, tracker));
+  if (config.async) {
+    tools.push(createWaitAgentTool(tracker));
+    tools.push(createCloseAgentTool(tracker));
+  }
+  return tools;
+}
+
 // src/models/resolver.ts
 function parseKey(input) {
   const [engineId, ...rest] = input.split("/");
@@ -6551,10 +8038,16 @@ export {
   ContextManager,
   ContextOverflowError,
   DEFAULT_CONTEXT_LIMITS,
+  DEFAULT_EXTERNAL_DIRS,
   DEFAULT_INSTRUCTION_PATTERNS,
+  DEFAULT_MAX_CONCURRENT,
   DEFAULT_MAX_DEPTH,
   DEFAULT_MAX_FILE_SIZE,
+  DEFAULT_MAX_SCAN_DEPTH,
+  DEFAULT_MAX_SPAWN_DEPTH,
   DEFAULT_RETRY_CONFIG,
+  DEFAULT_SESSION_TITLE_PREFIX,
+  DEFAULT_SKILL_MAX_SIZE,
   DoomLoopError,
   FileStorage,
   InterventionController,
@@ -6563,6 +8056,7 @@ export {
   MAX_BYTES,
   MAX_LINES,
   MemoryStorage,
+  MiddlewareRunner,
   ModelCapabilityResolver,
   OUTPUT_TOKEN_MAX,
   PRIORITY_BASE,
@@ -6573,14 +8067,18 @@ export {
   PRIORITY_SKILLS,
   Presets,
   PromptBuilder,
+  SKILL_FILENAME,
   STORAGE_VERSION,
   SessionManager,
+  SkillRegistry,
+  SubAgentTracker,
   TRUNCATE_DIR,
   TRUNCATE_GLOB,
   Tool,
   ToolRegistry,
   TurnChangeTracker,
   applyPreset,
+  approvalMiddleware,
   buildMessagesFromEntries,
   buildReasoningOptions,
   buildReasoningOptionsSync,
@@ -6597,6 +8095,11 @@ export {
   createResolver,
   createRetryHandler,
   createRetryState,
+  createSkillRegistry,
+  createSkillResourceTool,
+  createSkillTool,
+  createSkillTools,
+  createSubAgentTools,
   createTurnTracker,
   defaultRegistry,
   defineServer,
@@ -6604,7 +8107,9 @@ export {
   deserializeMessage,
   detectModelFamily,
   discoverInstructions,
+  discoverSkills,
   dockerHost,
+  emptySkillRegistry,
   estimateConversationTokens,
   estimateMessageTokens,
   estimateTokens,
@@ -6634,12 +8139,17 @@ export {
   getTemplate,
   getToolRisk,
   httpServer,
+  inferResourceType,
   isContextOverflowing,
   isRetryable,
   isRetryableCategory,
   loadGlobalInstructions,
+  loadResourceContent,
+  loadSkillContent,
+  loadSkillMetadata,
   localHost,
   mergePresets,
+  parseFrontmatter,
   parseJSONL,
   processStream,
   pruneContext,