@polka-codes/core 0.9.81 → 0.9.83

package/dist/index.js

@@ -139,6 +139,15 @@ var ruleSchema = z.union([
     branch: z.string().optional()
   }).strict()
 ]);
+var providerConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  defaultModel: z.string().optional(),
+  defaultParameters: z.record(z.string(), z.any()).optional(),
+  location: z.string().optional(),
+  project: z.string().optional(),
+  keyFile: z.string().optional(),
+  baseUrl: z.string().optional()
+});
 var providerModelSchema = z.object({
   provider: z.string().optional(),
   model: z.string().optional(),
@@ -146,6 +155,53 @@ var providerModelSchema = z.object({
   budget: z.number().positive().optional(),
   rules: z.array(ruleSchema).optional().or(z.string()).optional()
 });
+var scriptSchema = z.union([
+  // Type 1: Simple shell command (backward compatible)
+  z.string(),
+  // Type 2: Object with command and description (backward compatible)
+  z.object({
+    command: z.string(),
+    description: z.string()
+  }).strict(),
+  // Type 3: Reference to dynamic workflow YAML
+  z.object({
+    workflow: z.string(),
+    // Path to .yml workflow file
+    description: z.string().optional(),
+    input: z.record(z.string(), z.any()).optional()
+    // Default workflow input
+  }).strict(),
+  // Type 4: TypeScript script file (NEW)
+  z.object({
+    script: z.string(),
+    // Path to .ts file
+    description: z.string().optional(),
+    permissions: z.object({
+      fs: z.enum(["read", "write", "none"]).optional(),
+      network: z.boolean().optional(),
+      subprocess: z.boolean().optional()
+    }).optional(),
+    timeout: z.number().int().positive().max(36e5).optional(),
+    // Max 1 hour in milliseconds
+    memory: z.number().int().positive().min(64).max(8192).optional()
+    // 64MB-8GB in MB
+  }).strict()
+]);
+var mcpServerConfigSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  tools: z.record(
+    z.string(),
+    z.boolean().or(
+      z.object({
+        provider: z.string().optional(),
+        model: z.string().optional(),
+        parameters: z.record(z.string(), z.unknown()).optional()
+      }).strict()
+    )
+  ).optional()
+}).strict();
 var configSchema = z.object({
   prices: z.record(
     z.string(),
@@ -161,17 +217,7 @@ var configSchema = z.object({
       })
     )
   ).optional(),
-  providers: z.record(
-    z.string(),
-    z.object({
-      apiKey: z.string().optional(),
-      defaultModel: z.string().optional(),
-      defaultParameters: z.record(z.string(), z.any()).optional(),
-      location: z.string().optional(),
-      project: z.string().optional(),
-      keyFile: z.string().optional()
-    })
-  ).optional(),
+  providers: z.record(z.string(), providerConfigSchema).optional(),
   defaultProvider: z.string().optional(),
   defaultModel: z.string().optional(),
   defaultParameters: z.record(z.string(), z.any()).optional(),
@@ -180,34 +226,690 @@ var configSchema = z.object({
   retryCount: z.number().int().min(0).optional(),
   requestTimeoutSeconds: z.number().int().positive().optional(),
   summaryThreshold: z.number().int().positive().optional(),
-  scripts: z.record(
-    z.string(),
-    z.string().or(
-      z.object({
-        command: z.string(),
-        description: z.string()
-      })
-    )
-  ).optional(),
+  scripts: z.record(z.string(), scriptSchema).optional(),
   commands: z.record(z.string(), providerModelSchema).optional(),
   tools: z.object({
     search: providerModelSchema.or(z.boolean()).optional()
   }).optional(),
+  mcpServers: z.record(z.string(), mcpServerConfigSchema).optional(),
   rules: z.array(ruleSchema).optional().or(z.string()).optional(),
   excludeFiles: z.array(z.string()).optional()
 }).strict().nullish();
 
-// src/tools/askFollowupQuestion.ts
+// src/fs/node-provider.ts
+import { existsSync } from "fs";
+import { readdir, readFile, stat } from "fs/promises";
+import { join, normalize } from "path";
+var NodeFileSystemProvider = class {
+  constructor(_options = {}) {
+    this._options = _options;
+  }
+  exists(path) {
+    return existsSync(path);
+  }
+  async readdir(path) {
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.map((entry) => ({
+      name: entry.name,
+      isDirectory: entry.isDirectory(),
+      isFile: entry.isFile()
+    }));
+  }
+  async readFile(path) {
+    return readFile(path, "utf-8");
+  }
+  async readFileAsBuffer(path) {
+    const buffer = await readFile(path);
+    return new Uint8Array(buffer);
+  }
+  async stat(path) {
+    const stats = await stat(path);
+    return {
+      size: stats.size,
+      isDirectory: stats.isDirectory(),
+      isFile: stats.isFile()
+    };
+  }
+  join(...paths) {
+    return join(...paths);
+  }
+  normalize(path) {
+    return normalize(path);
+  }
+};
+
+// src/skills/constants.ts
+var SKILL_LIMITS = {
+  MAX_FILE_SIZE: 1024 * 1024,
+  // 1MB per file
+  MAX_SKILL_SIZE: 10 * 1024 * 1024,
+  // 10MB total
+  MAX_DEPTH: 10,
+  // Maximum directory recursion depth
+  MAX_FILES: 500,
+  // Maximum files to load per skill
+  MIN_DESCRIPTION_LENGTH: 20,
+  // Minimum description length
+  MAX_DESCRIPTION_LENGTH: 1024,
+  // Maximum description length
+  MAX_NAME_LENGTH: 64
+  // Maximum skill name length
+};
+var IGNORED_DIRECTORIES = [
+  ".git",
+  "node_modules",
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  "coverage",
+  ".cache",
+  ".vscode",
+  ".idea",
+  "tmp",
+  "temp",
+  ".DS_Store"
+];
+var SUSPICIOUS_PATTERNS = [
+  /<script[^>]*>[\s\S]*?<\/script>/i,
+  // Script tags (with dotAll for multiline)
+  /javascript:/i,
+  // JavaScript URLs
+  /on\w+\s*=/i
+  // Event handlers (onclick, onload, etc.)
+];
+var SKILL_ERROR_MESSAGES = {
+  MISSING_FRONTMATTER: "SKILL.md must begin with YAML frontmatter enclosed in ---",
+  FRONTMATTER_INVALID: "Invalid frontmatter: {message}",
+  SKILL_NOT_FOUND: "Skill not found",
+  CONTEXT_NOT_INITIALIZED: "Skill context not initialized"
+};
+var SOURCE_ICONS = {
+  project: "\u{1F4C1}",
+  personal: "\u{1F3E0}",
+  plugin: "\u{1F50C}"
+};
+
+// src/skills/discovery.ts
+import { homedir } from "os";
+import { parse } from "yaml";
+import { ZodError } from "zod";
+
+// src/skills/types.ts
 import { z as z2 } from "zod";
-var questionObject = z2.object({
-  prompt: z2.string().describe("The text of the question.").meta({ usageValue: "question text here" }),
-  options: z2.array(z2.string()).default([]).describe("Ordered list of suggested answers (omit if none).").meta({ usageValue: "suggested answer here" })
+var skillMetadataSchema = z2.object({
+  name: z2.string().regex(/^[a-z0-9-]+$/, "Skill name must be lowercase letters, numbers, and hyphens").max(64, "Skill name must be at most 64 characters"),
+  description: z2.string().max(1024, "Description must be at most 1024 characters"),
+  allowedTools: z2.array(z2.string()).optional()
+});
+var SkillDiscoveryError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "SkillDiscoveryError";
+  }
+};
+var SkillValidationError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "SkillValidationError";
+  }
+};
+
+// src/skills/discovery.ts
+var BINARY_EXTENSIONS = [
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".dat",
+  ".db",
+  ".sqlite",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot"
+];
+function isBinaryFile(filename) {
+  const ext = filename.toLowerCase().slice(filename.lastIndexOf("."));
+  return BINARY_EXTENSIONS.includes(ext);
+}
+function isBinaryContent(buffer) {
+  const checkLength = Math.min(buffer.length, 8192);
+  for (let i = 0; i < checkLength; i++) {
+    if (buffer[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+async function tryReadTextFile(filePath, fs) {
+  try {
+    const buffer = await fs.readFileAsBuffer(filePath);
+    if (isBinaryContent(buffer)) {
+      return null;
+    }
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    } catch (_decodeError) {
+      return null;
+    }
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && (error.code === "EINVAL" || error.code === "EISDIR")) {
+      return null;
+    }
+    throw error;
+  }
+}
+var SkillDiscoveryService = class {
+  fs;
+  personalSkillsDir;
+  projectSkillsDir;
+  pluginSkillsDirs;
+  constructor(options) {
+    this.fs = options.fs ?? new NodeFileSystemProvider();
+    this.personalSkillsDir = options.personalSkillsDir ?? this.fs.join(homedir(), ".claude", "skills");
+    this.projectSkillsDir = this.fs.join(options.cwd, ".claude", "skills");
+    this.pluginSkillsDirs = options.pluginSkillsDirs ?? [];
+  }
+  /**
+   * Discover all available skills from all sources
+   * Removes duplicates (project skills take priority over personal/plugin)
+   */
+  async discoverAll() {
+    const skills = [];
+    const results = await Promise.allSettled([
+      this.discoverInDirectory(this.projectSkillsDir, "project"),
+      this.discoverInDirectory(this.personalSkillsDir, "personal"),
+      this.discoverPlugins()
+    ]);
+    const projectSkills = results[0].status === "fulfilled" ? results[0].value : [];
+    const personalSkills = results[1].status === "fulfilled" ? results[1].value : [];
+    const pluginSkills = results[2].status === "fulfilled" ? results[2].value : [];
+    if (results[0].status === "rejected") {
+      console.warn(`Failed to load project skills: ${results[0].reason}`);
+    }
+    if (results[1].status === "rejected") {
+      console.warn(`Failed to load personal skills: ${results[1].reason}`);
+    }
+    if (results[2].status === "rejected") {
+      console.warn(`Failed to load plugin skills: ${results[2].reason}`);
+    }
+    const seenNames = /* @__PURE__ */ new Set();
+    const allSkills = [...projectSkills, ...personalSkills, ...pluginSkills];
+    for (const skill of allSkills) {
+      if (!seenNames.has(skill.metadata.name)) {
+        seenNames.add(skill.metadata.name);
+        skills.push(skill);
+      }
+    }
+    return skills;
+  }
+  /**
+   * Discover skills in a specific directory
+   */
+  async discoverInDirectory(dir, source) {
+    const exists = typeof this.fs.exists === "boolean" ? this.fs.exists(dir) : await this.fs.exists(dir);
+    if (!exists) {
+      return [];
+    }
+    const skills = [];
+    const entries = await this.fs.readdir(dir);
+    for (const entry of entries) {
+      if (!entry.isDirectory) {
+        continue;
+      }
+      const skillPath = this.fs.join(dir, entry.name);
+      const skillMdPath = this.fs.join(skillPath, "SKILL.md");
+      const skillMdExists = typeof this.fs.exists === "boolean" ? this.fs.exists(skillMdPath) : await this.fs.exists(skillMdPath);
+      if (!skillMdExists) {
+        continue;
+      }
+      try {
+        const content = await this.fs.readFile(skillMdPath);
+        const { metadata } = this.parseSkillMd(content);
+        skills.push({
+          metadata,
+          path: skillPath,
+          source
+        });
+      } catch (error) {
+        let message = "Unknown error";
+        let path = skillPath;
+        if (error instanceof SkillDiscoveryError) {
+          message = error.message;
+          path = error.path;
+        } else if (error instanceof ZodError) {
+          message = error.issues[0]?.message ?? "Invalid skill metadata";
+        } else if (error instanceof Error) {
+          message = error.message;
+        }
+        console.warn(`Warning: Failed to load skill at ${path}: ${message}`);
+      }
+    }
+    return skills;
+  }
+  /**
+   * Discover skills from plugin directories (node_modules)
+   */
+  async discoverPlugins() {
+    const skills = [];
+    for (const pluginDir of this.pluginSkillsDirs) {
+      const exists = typeof this.fs.exists === "boolean" ? this.fs.exists(pluginDir) : await this.fs.exists(pluginDir);
+      if (!exists) {
+        continue;
+      }
+      const pluginSkills = await this.discoverInDirectory(pluginDir, "plugin");
+      skills.push(...pluginSkills);
+    }
+    return skills;
+  }
+  /**
+   * Load a single skill from its directory
+   */
+  async loadSkill(skillPath, source) {
+    const skillMdPath = this.fs.join(skillPath, "SKILL.md");
+    const skillMdExists = typeof this.fs.exists === "boolean" ? this.fs.exists(skillMdPath) : await this.fs.exists(skillMdPath);
+    if (!skillMdExists) {
+      throw new SkillDiscoveryError("SKILL.md not found", skillPath);
+    }
+    const content = await this.fs.readFile(skillMdPath);
+    const { metadata, content: instructions } = this.parseSkillMd(content);
+    const files = /* @__PURE__ */ new Map();
+    let totalSize = 0;
+    const entries = await this.fs.readdir(skillPath);
+    for (const entry of entries) {
+      if (entry.name === "SKILL.md") {
+        continue;
+      }
+      const filePath = this.fs.join(skillPath, entry.name);
+      if (entry.isFile) {
+        if (isBinaryFile(entry.name)) {
+          continue;
+        }
+        const fileStats = await this.fs.stat(filePath);
+        const fileSize = fileStats.size;
+        if (fileSize > SKILL_LIMITS.MAX_FILE_SIZE) {
+          throw new SkillDiscoveryError(`File size exceeds limit (${fileSize} > ${SKILL_LIMITS.MAX_FILE_SIZE}): ${entry.name}`, skillPath);
+        }
+        if (totalSize + fileSize > SKILL_LIMITS.MAX_SKILL_SIZE) {
+          throw new SkillDiscoveryError(
+            `Total skill size exceeds limit (${totalSize + fileSize} > ${SKILL_LIMITS.MAX_SKILL_SIZE}): ${skillPath}`,
+            skillPath
+          );
+        }
+        const fileContent = await tryReadTextFile(filePath, this.fs);
+        if (fileContent === null) {
+          continue;
+        }
+        totalSize += fileSize;
+        files.set(entry.name, fileContent);
+      } else if (entry.isDirectory) {
+        totalSize = await this.loadDirectoryFiles(filePath, entry.name, files, 0, totalSize);
+      }
+    }
+    return {
+      metadata,
+      content: instructions,
+      files,
+      path: skillPath,
+      source
+    };
+  }
+  /**
+   * Parse SKILL.md content and extract frontmatter
+   */
+  parseSkillMd(content) {
+    const frontmatterRegex = /^---\r?\n([\s\S]+?)\r?\n---\r?\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match || match.length < 3) {
+      throw new SkillDiscoveryError(SKILL_ERROR_MESSAGES.MISSING_FRONTMATTER, "");
+    }
+    const frontmatter = match[1] ?? "";
+    const instructions = match[2] ?? "";
+    const metadata = this.parseMetadata(frontmatter);
+    return { metadata, content: instructions };
+  }
+  /**
+   * Parse and validate YAML frontmatter
+   */
+  parseMetadata(frontmatter) {
+    const parsed = parse(frontmatter);
+    return skillMetadataSchema.parse(parsed);
+  }
+  /**
+   * Recursively load files from a directory into the files map
+   * @returns The total size of all files loaded (in bytes)
+   */
+  async loadDirectoryFiles(dirPath, prefix, files, depth = 0, currentTotal = 0) {
+    const { MAX_DEPTH, MAX_FILES } = SKILL_LIMITS;
+    let totalSize = currentTotal;
+    if (depth > MAX_DEPTH) {
+      return totalSize;
+    }
+    if (files.size >= MAX_FILES) {
+      return totalSize;
+    }
+    const currentDirName = prefix.split("/").pop() ?? prefix;
+    if (IGNORED_DIRECTORIES.includes(currentDirName)) {
+      return totalSize;
+    }
+    const entries = await this.fs.readdir(dirPath);
+    for (const entry of entries) {
+      if (files.size >= MAX_FILES) {
+        break;
+      }
+      const filePath = this.fs.join(dirPath, entry.name);
+      const key = `${prefix}/${entry.name}`.replace(/\/+/g, "/");
+      if (entry.isFile) {
+        if (isBinaryFile(entry.name)) {
+          continue;
+        }
+        const fileStats = await this.fs.stat(filePath);
+        const fileSize = fileStats.size;
+        if (fileSize > SKILL_LIMITS.MAX_FILE_SIZE) {
+          throw new SkillDiscoveryError(`File size exceeds limit (${fileSize} > ${SKILL_LIMITS.MAX_FILE_SIZE}): ${key}`, dirPath);
+        }
+        if (totalSize + fileSize > SKILL_LIMITS.MAX_SKILL_SIZE) {
+          throw new SkillDiscoveryError(
+            `Total skill size exceeds limit (${totalSize + fileSize} > ${SKILL_LIMITS.MAX_SKILL_SIZE}): ${dirPath}`,
+            dirPath
+          );
+        }
+        const content = await tryReadTextFile(filePath, this.fs);
+        if (content === null) {
+          continue;
+        }
+        totalSize += fileSize;
+        files.set(key, content);
+      } else if (entry.isDirectory) {
+        if (IGNORED_DIRECTORIES.includes(entry.name)) {
+          continue;
+        }
+        totalSize = await this.loadDirectoryFiles(filePath, key, files, depth + 1, totalSize);
+      }
+    }
+    return totalSize;
+  }
+  /**
+   * Create an initial skill context object
+   */
+  async createContext() {
+    const availableSkills = await this.discoverAll();
+    return {
+      activeSkill: null,
+      availableSkills,
+      skillLoadingHistory: [],
+      loadSkill: async (name) => {
+        const ref = availableSkills.find((s) => s.metadata.name === name);
+        if (!ref) return null;
+        return this.loadSkill(ref.path, ref.source);
+      }
+    };
+  }
+};
+
+// src/skills/validation.ts
+import { join as join2, normalize as normalize2 } from "path";
+function validateSkillSecurity(skill) {
+  const { MAX_FILE_SIZE, MAX_SKILL_SIZE } = SKILL_LIMITS;
+  let totalSize = 0;
+  const contentSize = Buffer.byteLength(skill.content, "utf8");
+  if (contentSize > MAX_FILE_SIZE) {
+    throw new SkillValidationError(`SKILL.md content exceeds size limit (${contentSize} > ${MAX_FILE_SIZE})`, join2(skill.path, "SKILL.md"));
+  }
+  totalSize += contentSize;
+  for (const [filename, content] of skill.files) {
+    const fileSize = Buffer.byteLength(content, "utf8");
+    if (fileSize > MAX_FILE_SIZE) {
+      throw new SkillValidationError(`File ${filename} exceeds size limit (${fileSize} > ${MAX_FILE_SIZE})`, join2(skill.path, filename));
+    }
+    totalSize += fileSize;
+  }
+  if (totalSize > MAX_SKILL_SIZE) {
+    throw new SkillValidationError(`Skill total size exceeds limit (${totalSize} > ${MAX_SKILL_SIZE})`, skill.path);
+  }
+  validateContentSecurity(skill.content, skill.path);
+  for (const [filename, content] of skill.files) {
+    validateContentSecurity(content, join2(skill.path, filename));
+  }
+}
+function validateContentSecurity(content, path) {
+  for (const pattern of SUSPICIOUS_PATTERNS) {
+    if (pattern.test(content)) {
+      throw new SkillValidationError("Suspicious content detected", path);
+    }
+  }
+}
+function validateSkillReferences(skill) {
+  const warnings = [];
+  const externalRefs = skill.content.match(/https?:\/\/[^\s\])]+/g) || [];
+  if (externalRefs.length > 0 && !skill.metadata.description.toLowerCase().includes("external")) {
+    warnings.push(
+      `Skill '${skill.metadata.name}' contains external references. Consider adding 'external' to description for transparency.`
+    );
+  }
+  const codeBlocks = skill.content.match(/```[\s\S]*?```/g) || [];
+  for (const block of codeBlocks) {
+    const pathsInCode = block.match(/\/[a-zA-Z][\w./-]*/g) || [];
+    for (const path of pathsInCode) {
+      if (!path.startsWith("/dev") && !path.startsWith("/proc") && !path.startsWith("/sys") && !path.startsWith("//")) {
+        warnings.push(`Skill '${skill.metadata.name}' contains possible absolute path '${path}'. Use relative paths instead.`);
+      }
+    }
+  }
+  const linkRegex = /\[[^\]]+\]\(([^)]+(?:\s+[^)]+)*)\)/g;
+  let match;
+  match = linkRegex.exec(skill.content);
+  while (match !== null) {
+    const filepath = match[1];
+    match = linkRegex.exec(skill.content);
+    if (filepath.startsWith("http://") || filepath.startsWith("https://") || filepath.startsWith("#")) {
+      continue;
+    }
+    const normalizedPath = normalize2(filepath).replace(/^\.?\//, "").replace(/\\/g, "/");
+    if (!skill.files.has(normalizedPath)) {
+      warnings.push(`Referenced file not found: ${filepath}`);
+    }
+  }
+  return warnings;
+}
+function validateSkillMetadata(skill) {
+  const errors = [];
+  if (skill.metadata.description.length < 20) {
+    errors.push(`Description too short: ${skill.metadata.description.length} < 20`);
+  }
+  return errors;
+}
+function getSkillStats(skill) {
+  let totalSize = Buffer.byteLength(skill.content, "utf8");
+  let largestFile = { name: "SKILL.md", size: totalSize };
+  let fileCount = 1;
+  for (const [name, content] of skill.files) {
+    const size = Buffer.byteLength(content, "utf8");
+    totalSize += size;
+    fileCount++;
+    if (size > largestFile.size) {
+      largestFile = { name, size };
+    }
+  }
+  return {
+    totalSize,
+    fileCount,
+    largestFile
+  };
+}
+
+// src/skills/tools/listSkills.ts
+import { z as z3 } from "zod";
+var ListSkillsInputSchema = z3.object({
+  filter: z3.string().optional().describe("Optional filter string to match against skill names and descriptions")
+});
+var ListSkillsOutputSchema = z3.object({
+  skills: z3.array(
+    z3.object({
+      name: z3.string(),
+      description: z3.string(),
+      source: z3.enum(["personal", "project", "plugin"])
+    })
+  ),
+  total: z3.number()
+});
+async function listSkills(input, context) {
+  const { filter } = input;
+  let skills = context.availableSkills;
+  if (filter) {
+    const filterLower = filter.toLowerCase();
+    skills = skills.filter((s) => s.metadata.name.includes(filterLower) || s.metadata.description.toLowerCase().includes(filterLower));
+  }
+  return {
+    skills: skills.map((s) => ({
+      name: s.metadata.name,
+      description: s.metadata.description,
+      source: s.source
+    })),
+    total: skills.length
+  };
+}
+var listSkillsToolInfo = {
+  name: "listSkills",
+  description: "List all available skills with their descriptions. Use this to discover what specialized capabilities are available.",
+  parameters: ListSkillsInputSchema,
+  returns: ListSkillsOutputSchema
+};
+
+// src/skills/tools/loadSkill.ts
+import { z as z4 } from "zod";
+var LoadSkillInputSchema = z4.object({
+  skillName: z4.string().describe("The name of the skill to load")
+});
+var LoadSkillOutputSchema = z4.object({
+  success: z4.boolean(),
+  skill: z4.object({
+    name: z4.string(),
+    description: z4.string(),
+    content: z4.string(),
+    availableFiles: z4.array(z4.string())
+  }).optional(),
+  error: z4.string().optional(),
+  warnings: z4.array(z4.string()).optional()
+});
+async function loadSkill(input, context) {
+  const { skillName } = input;
+  const skillRef = context.availableSkills.find((s) => s.metadata.name === skillName);
+  if (!skillRef) {
+    return {
+      success: false,
+      error: `Skill '${skillName}' not found`
+    };
+  }
+  try {
+    const skill = await context.loadSkill(skillName);
+    if (!skill) {
+      return {
+        success: false,
+        error: `Failed to load skill '${skillName}'`
+      };
+    }
+    validateSkillSecurity(skill);
+    const warnings = validateSkillReferences(skill);
+    context.activeSkill = skill;
+    context.skillLoadingHistory.push(skillName);
+    return {
+      success: true,
+      skill: {
+        name: skill.metadata.name,
+        description: skill.metadata.description,
+        content: skill.content,
+        availableFiles: Array.from(skill.files.keys())
+      },
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to load skill '${skillName}': ${message}`
+    };
+  }
+}
+var loadSkillToolInfo = {
+  name: "loadSkill",
+  description: "Load a skill by name to access its instructions and resources. Use this when you need specialized knowledge or capabilities for a specific task.",
+  parameters: LoadSkillInputSchema,
+  returns: LoadSkillOutputSchema
+};
+
+// src/skills/tools/readSkillFile.ts
+import { z as z5 } from "zod";
+var ReadSkillFileInputSchema = z5.object({
+  skillName: z5.string().describe("The name of the skill"),
+  filename: z5.string().describe('The name of the file to read (e.g., "reference.md", "scripts/helper.py")')
+});
+var ReadSkillFileOutputSchema = z5.object({
+  success: z5.boolean(),
+  content: z5.string().optional(),
+  error: z5.string().optional()
+});
+async function readSkillFile(input, context) {
+  const { skillName, filename } = input;
+  let skill = context.activeSkill && context.activeSkill.metadata.name === skillName ? context.activeSkill : null;
+  if (!skill) {
+    try {
+      skill = await context.loadSkill(skillName);
+    } catch (_error) {
+    }
+  }
+  if (!skill) {
+    return {
+      success: false,
+      error: `Skill '${skillName}' not found or could not be loaded. Use loadSkill first.`
+    };
+  }
+  if (!skill.files.has(filename)) {
+    const availableFiles = Array.from(skill.files.keys()).sort();
+    return {
+      success: false,
+      error: `File '${filename}' not found in skill '${skillName}'. Available files: ${availableFiles.join(", ") || "none"}`
+    };
+  }
+  const content = skill.files.get(filename);
+  return {
+    success: true,
+    content
+  };
+}
+var readSkillFileToolInfo = {
+  name: "readSkillFile",
+  description: "Read a supporting file from a skill. Use this to access reference documentation, examples, scripts, or templates bundled with a skill. First use loadSkill to see available files, then use this tool to read specific files.",
+  parameters: ReadSkillFileInputSchema,
+  returns: ReadSkillFileOutputSchema
+};
+
+// src/tools/askFollowupQuestion.ts
+import { z as z6 } from "zod";
+var questionObject = z6.object({
+  prompt: z6.string().describe("The text of the question.").meta({ usageValue: "question text here" }),
+  options: z6.array(z6.string()).default([]).describe("Ordered list of suggested answers (omit if none).").meta({ usageValue: "suggested answer here" })
 });
 var toolInfo = {
   name: "askFollowupQuestion",
   description: "Call this when vital details are missing. Pose each follow-up as one direct, unambiguous question. If it speeds the reply, add up to five short, mutually-exclusive answer options. Group any related questions in the same call to avoid a back-and-forth chain.",
-  parameters: z2.object({
-    questions: z2.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
+  parameters: z6.object({
+    questions: z6.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
   }).meta({
     examples: [
       {
@@ -295,20 +997,41 @@ var askFollowupQuestion_default = {
 };
 
 // src/tools/executeCommand.ts
-import { z as z3 } from "zod";
+import { z as z7 } from "zod";
+
+// src/tools/utils.ts
+function createProviderError(action) {
+  return {
+    success: false,
+    message: {
+      type: "error-text",
+      value: `Not possible to ${action}.`
+    }
+  };
+}
+function preprocessBoolean(val) {
+  return typeof val === "string" ? val.toLowerCase() === "true" : val;
+}
+function createFileElement(tagName, path, content, attrs) {
+  const allAttrs = { path, ...attrs };
+  const attrStr = Object.entries(allAttrs).map(([k, v]) => ` ${k}="${v}"`).join("");
+  if (content === void 0) {
+    return `<${tagName}${attrStr} />`;
+  }
+  const isEmpty = content.trim().length === 0;
+  if (isEmpty) {
+    return `<${tagName}${attrStr} is_empty="true" />`;
+  }
+  return `<${tagName}${attrStr}>${content}</${tagName}>`;
+}
+
+// src/tools/executeCommand.ts
 var toolInfo2 = {
   name: "executeCommand",
   description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.",
-  parameters: z3.object({
-    command: z3.string().describe("The exact command to run  (valid for the current OS). It must be correctly formatted and free of harmful instructions.").meta({ usageValue: "your-command-here" }),
-    requiresApproval: z3.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z3.boolean().optional().default(false)).describe(
+  parameters: z7.object({
+    command: z7.string().describe("The exact command to run  (valid for the current OS). It must be correctly formatted and free of harmful instructions.").meta({ usageValue: "your-command-here" }),
+    requiresApproval: z7.preprocess(preprocessBoolean, z7.boolean().optional().default(false)).describe(
       "Set to `true` for commands that install/uninstall software, modify or delete files, change system settings, perform network operations, or have other side effects. Use `false` for safe, read-only, or purely local development actions (e.g., listing files, make a build, running tests)."
     ).meta({ usageValue: "true | false" })
   }).meta({
@@ -325,13 +1048,7 @@ var toolInfo2 = {
 };
 var handler2 = async (provider, args) => {
   if (!provider.executeCommand) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to execute command. Abort."
-      }
-    };
+    return createProviderError("execute command. Abort");
   }
   const { command, requiresApproval } = toolInfo2.parameters.parse(args);
   try {
@@ -385,16 +1102,16 @@ var executeCommand_default = {
 };
 
 // src/tools/fetchUrl.ts
-import { z as z4 } from "zod";
+import { z as z8 } from "zod";
 var toolInfo3 = {
   name: "fetchUrl",
   description: "Fetch the content located at one or more HTTP(S) URLs and return it in Markdown format. This works for standard web pages as well as raw files (e.g. README.md, source code) hosted on platforms like GitHub.",
-  parameters: z4.object({
-    url: z4.preprocess((val) => {
+  parameters: z8.object({
+    url: z8.preprocess((val) => {
       if (!val) return [];
       const values = Array.isArray(val) ? val : [val];
       return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
-    }, z4.array(z4.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
+    }, z8.array(z8.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
   }).meta({
     examples: [
       {
@@ -463,29 +1180,15 @@ var fetchUrl_default = {
 };
 
 // src/tools/listFiles.ts
-import { z as z5 } from "zod";
+import { z as z9 } from "zod";
 var toolInfo4 = {
   name: "listFiles",
   description: "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.",
-  parameters: z5.object({
-    path: z5.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
-    maxCount: z5.coerce.number().optional().default(2e3).describe("The maximum number of files to list. Default to 2000").meta({ usageValue: "Maximum number of files to list (optional)" }),
-    recursive: z5.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z5.boolean().optional().default(true)).describe("Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.").meta({ usageValue: "true or false (optional)" }),
-    includeIgnored: z5.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z5.boolean().optional().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
+  parameters: z9.object({
+    path: z9.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
+    maxCount: z9.coerce.number().optional().default(2e3).describe("The maximum number of files to list. Default to 2000").meta({ usageValue: "Maximum number of files to list (optional)" }),
+    recursive: z9.preprocess(preprocessBoolean, z9.boolean().optional().default(true)).describe("Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.").meta({ usageValue: "true or false (optional)" }),
+    includeIgnored: z9.preprocess(preprocessBoolean, z9.boolean().optional().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
   }).meta({
     examples: [
       {
@@ -500,13 +1203,7 @@ var toolInfo4 = {
 };
 var handler4 = async (provider, args) => {
   if (!provider.listFiles) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to list files."
-      }
-    };
+    return createProviderError("list files");
   }
   const { path, maxCount, recursive, includeIgnored } = toolInfo4.parameters.parse(args);
   const [files, limitReached] = await provider.listFiles(path, recursive, maxCount, includeIgnored);
@@ -589,12 +1286,12 @@ var MockProvider = class {
 };
 
 // src/tools/readBinaryFile.ts
-import { z as z6 } from "zod";
+import { z as z10 } from "zod";
 var toolInfo5 = {
   name: "readBinaryFile",
   description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.",
-  parameters: z6.object({
-    url: z6.string().describe("The URL or local path of the file to read.")
+  parameters: z10.object({
+    url: z10.string().describe("The URL or local path of the file to read.")
   })
 };
 var handler5 = async (provider, args) => {
@@ -641,24 +1338,17 @@ var readBinaryFile_default = {
 };
 
 // src/tools/readFile.ts
-import { z as z7 } from "zod";
+import { z as z11 } from "zod";
 var toolInfo6 = {
   name: "readFile",
   description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.",
-  parameters: z7.object({
-    path: z7.preprocess((val) => {
+  parameters: z11.object({
+    path: z11.preprocess((val) => {
       if (!val) return [];
       const values = Array.isArray(val) ? val : [val];
       return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
-    }, z7.array(z7.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
-    includeIgnored: z7.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z7.boolean().nullish().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
+    }, z11.array(z11.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
+    includeIgnored: z11.preprocess(preprocessBoolean, z11.boolean().nullish().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
   }).meta({
     examples: [
       {
@@ -678,27 +1368,16 @@ var toolInfo6 = {
 };
 var handler6 = async (provider, args) => {
   if (!provider.readFile) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to read file."
-      }
-    };
+    return createProviderError("read file");
   }
   const { path: paths, includeIgnored } = toolInfo6.parameters.parse(args);
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path, includeIgnored ?? false);
     if (!fileContent) {
-      resp.push(`<read_file_file_content path="${path}" file_not_found="true" />`);
+      resp.push(createFileElement("read_file_file_content", path, void 0, { file_not_found: "true" }));
     } else {
-      const isEmpty = fileContent.trim().length === 0;
-      if (isEmpty) {
-        resp.push(`<read_file_file_content path="${path}" is_empty="true" />`);
-      } else {
-        resp.push(`<read_file_file_content path="${path}">${fileContent}</read_file_file_content>`);
-      }
+      resp.push(createFileElement("read_file_file_content", path, fileContent));
     }
   }
   return {
@@ -715,12 +1394,12 @@ var readFile_default = {
 };
 
 // src/tools/removeFile.ts
-import { z as z8 } from "zod";
+import { z as z12 } from "zod";
 var toolInfo7 = {
   name: "removeFile",
   description: "Request to remove a file at the specified path.",
-  parameters: z8.object({
-    path: z8.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
+  parameters: z12.object({
+    path: z12.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
   }).meta({
     examples: [
       {
@@ -734,13 +1413,7 @@ var toolInfo7 = {
 };
 var handler7 = async (provider, args) => {
   if (!provider.removeFile) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to remove file."
-      }
-    };
+    return createProviderError("remove file");
   }
   const parsed = toolInfo7.parameters.safeParse(args);
   if (!parsed.success) {
@@ -768,13 +1441,13 @@ var removeFile_default = {
 };
 
 // src/tools/renameFile.ts
-import { z as z9 } from "zod";
+import { z as z13 } from "zod";
 var toolInfo8 = {
   name: "renameFile",
   description: "Request to rename a file from source path to target path.",
-  parameters: z9.object({
-    source_path: z9.string().describe("The current path of the file").meta({ usageValue: "Source file path here" }),
-    target_path: z9.string().describe("The new path for the file").meta({ usageValue: "Target file path here" })
+  parameters: z13.object({
+    source_path: z13.string().describe("The current path of the file").meta({ usageValue: "Source file path here" }),
+    target_path: z13.string().describe("The new path for the file").meta({ usageValue: "Target file path here" })
   }).meta({
     examples: [
       {
@@ -813,7 +1486,7 @@ var renameFile_default = {
 };
 
 // src/tools/replaceInFile.ts
-import { z as z10 } from "zod";
+import { z as z14 } from "zod";
 
 // src/tools/utils/replaceInFile.ts
 var replaceInFile = (fileContent, diff) => {
@@ -856,10 +1529,27 @@ var replaceInFile = (fileContent, diff) => {
         }
         runningIndex++;
       }
-      const strippedSearch = trimmedSearch.replace(/\s+/g, "");
-      const endPos = actualPos;
-      const startPos = endPos - strippedSearch.length;
-      return content.slice(0, startPos) + replace + content.slice(endPos);
+      const searchWords = trimmedSearch.replace(/\s+/g, " ").split(" ").filter((w) => w.length > 0);
+      let matchStartPos = -1;
+      let matchEndPos = -1;
+      if (searchWords.length > 0) {
+        const firstWordPos = content.indexOf(searchWords[0], offset);
+        if (firstWordPos !== -1) {
+          matchStartPos = firstWordPos;
+          matchEndPos = firstWordPos + searchWords[0].length;
+          for (let i = 1; i < searchWords.length; i++) {
+            const nextWordPos = content.indexOf(searchWords[i], matchEndPos);
+            if (nextWordPos === -1 || nextWordPos > matchEndPos + 100) {
+              matchStartPos = -1;
+              break;
+            }
+            matchEndPos = nextWordPos + searchWords[i].length;
+          }
+        }
+      }
+      if (matchStartPos !== -1 && matchEndPos !== -1) {
+        return content.slice(0, matchStartPos) + replace + content.slice(matchEndPos);
+      }
     }
     return null;
   };
@@ -893,9 +1583,9 @@ var replaceInFile = (fileContent, diff) => {
 var toolInfo9 = {
   name: "replaceInFile",
   description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
-  parameters: z10.object({
-    path: z10.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
-    diff: z10.string().describe(
+  parameters: z14.object({
+    path: z14.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
+    diff: z14.string().describe(
       `One or more SEARCH/REPLACE blocks following this exact format:
 \`\`\`
 <<<<<<< SEARCH
@@ -1081,12 +1771,12 @@ var replaceInFile_default = {
 };
 
 // src/tools/search.ts
-import { z as z11 } from "zod";
+import { z as z15 } from "zod";
 var toolInfo10 = {
   name: "search",
   description: "Search the web for information using Google Search. Use this tool to find current information, facts, news, documentation, or research that is not available in your training data. Returns comprehensive search results with relevant content extracted from the web.",
-  parameters: z11.object({
-    query: z11.string().describe("The query to search for").meta({ usageValue: "Your search query here" })
+  parameters: z15.object({
+    query: z15.string().describe("The query to search for").meta({ usageValue: "Your search query here" })
   }).meta({
     examples: [
       {
@@ -1136,18 +1826,18 @@ var search_default = {
 };
 
 // src/tools/searchFiles.ts
-import { z as z12 } from "zod";
+import { z as z16 } from "zod";
 var toolInfo11 = {
   name: "searchFiles",
   description: "Request to perform a regex search across files in a specified directory, outputting context-rich results that include surrounding lines. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.",
-  parameters: z12.object({
-    path: z12.string().describe(
+  parameters: z16.object({
+    path: z16.string().describe(
       "The path of the directory to search in (relative to the current working directory). This directory will be recursively searched."
     ).meta({ usageValue: "Directory path here" }),
-    regex: z12.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
+    regex: z16.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
       usageValue: "Your regex pattern here"
     }),
-    filePattern: z12.string().optional().describe(
+    filePattern: z16.string().optional().describe(
       'Comma-separated glob pattern to filter files (e.g., "*.ts" for TypeScript files or "*.ts,*.js" for both TypeScript and JavaScript files). If not provided, it will search all files (*).'
     ).meta({
       usageValue: "file pattern here (optional)"
@@ -1217,20 +1907,20 @@ var searchFiles_default = {
 };
 
 // src/tools/todo.ts
-import { z as z13 } from "zod";
-var TodoStatus = z13.enum(["open", "completed", "closed"]);
-var TodoItemSchema = z13.object({
-  id: z13.string(),
-  title: z13.string(),
-  description: z13.string(),
+import { z as z17 } from "zod";
+var TodoStatus = z17.enum(["open", "completed", "closed"]);
+var TodoItemSchema = z17.object({
+  id: z17.string(),
+  title: z17.string(),
+  description: z17.string(),
   status: TodoStatus
 });
-var UpdateTodoItemInputSchema = z13.object({
-  operation: z13.enum(["add", "update"]),
-  id: z13.string().nullish(),
-  parentId: z13.string().nullish(),
-  title: z13.string().nullish(),
-  description: z13.string().nullish(),
+var UpdateTodoItemInputSchema = z17.object({
+  operation: z17.enum(["add", "update"]),
+  id: z17.string().nullish(),
+  parentId: z17.string().nullish(),
+  title: z17.string().nullish(),
+  description: z17.string().nullish(),
   status: TodoStatus.nullish()
 }).superRefine((data, ctx) => {
   if (data.operation === "add") {
@@ -1251,18 +1941,18 @@ var UpdateTodoItemInputSchema = z13.object({
     }
   }
 });
-var UpdateTodoItemOutputSchema = z13.object({
-  id: z13.string()
+var UpdateTodoItemOutputSchema = z17.object({
+  id: z17.string()
 });
 
 // src/tools/writeToFile.ts
-import { z as z14 } from "zod";
+import { z as z18 } from "zod";
 var toolInfo12 = {
   name: "writeToFile",
   description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.",
-  parameters: z14.object({
-    path: z14.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
-    content: z14.string().describe(
+  parameters: z18.object({
+    path: z18.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
+    content: z18.string().describe(
       "The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified."
     ).meta({ usageValue: "Your file content here" })
   }).meta({
@@ -1290,13 +1980,7 @@ export default App;
 };
 var handler12 = async (provider, args) => {
   if (!provider.writeFile) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to write file."
-      }
-    };
+    return createProviderError("write file");
   }
   const parsed = toolInfo12.parameters.safeParse(args);
   if (!parsed.success) {
@@ -1310,7 +1994,7 @@ var handler12 = async (provider, args) => {
   }
   let { path, content } = parsed.data;
   const trimmedContent = content.trim();
-  if (trimmedContent.startsWith("<![CDATA[") && content.endsWith("]]>")) content = trimmedContent.slice(9, -3);
+  if (trimmedContent.startsWith("<![CDATA[") && trimmedContent.endsWith("]]>")) content = trimmedContent.slice(9, -3);
   await provider.writeFile(path, content);
   return {
     success: true,
@@ -1347,7 +2031,7 @@ var UsageMeter = class {
     this.#maxMessages = opts.maxMessages ?? 1e3;
     this.#maxCost = opts.maxCost ?? 100;
   }
-  #calculageUsage(usage, providerMetadata, modelInfo) {
+  #calculateUsage(usage, providerMetadata, modelInfo) {
     const providerMetadataKey = Object.keys(providerMetadata ?? {})[0];
     const metadata = providerMetadata?.[providerMetadataKey] ?? {};
     switch (providerMetadataKey) {
@@ -1405,7 +2089,7 @@ var UsageMeter = class {
       cacheReadsPrice: 0
     };
     const usage = "totalUsage" in resp ? resp.totalUsage : resp.usage;
-    const result = this.#calculageUsage(usage, resp.providerMetadata, modelInfo);
+    const result = this.#calculateUsage(usage, resp.providerMetadata, modelInfo);
     this.#totals.input += result.input || 0;
     this.#totals.output += result.output || 0;
     this.#totals.cachedRead += result.cachedRead || 0;
@@ -1475,7 +2159,7 @@ var UsageMeter = class {
 
 // src/workflow/agent.workflow.ts
 import { jsonSchema } from "ai";
-import { toJSONSchema, z as z15 } from "zod";
+import { toJSONSchema, z as z19 } from "zod";
 
 // src/workflow/types.ts
 var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
@@ -1547,9 +2231,9 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
     await event(`end-round-${i}`, { kind: "EndRequest" /* EndRequest */, message: textContent });
     if (toolCalls.length === 0) {
       if (!input.outputSchema) {
-        const exitReason2 = { type: "Exit", message: textContent, messages };
-        await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: exitReason2 });
-        return exitReason2;
+        const exitReason3 = { type: "Exit", message: textContent, messages };
+        await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: exitReason3 });
+        return exitReason3;
       }
       const parsed = parseJsonFromMarkdown(textContent);
       if (!parsed.success) {
@@ -1559,13 +2243,13 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
       }
       const validated = input.outputSchema.safeParse(parsed.data);
       if (!validated.success) {
-        const errorMessage = `Output validation failed. Error: ${z15.prettifyError(validated.error)}. Please correct the output.`;
+        const errorMessage = `Output validation failed. Error: ${z19.prettifyError(validated.error)}. Please correct the output.`;
         nextMessage = [{ role: "user", content: errorMessage }];
         continue;
       }
-      const exitReason = { type: "Exit", message: textContent, object: validated.data, messages };
-      await event("end-task", { kind: "EndTask" /* EndTask */, exitReason });
-      return exitReason;
+      const exitReason2 = { type: "Exit", message: textContent, object: validated.data, messages };
+      await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: exitReason2 });
+      return exitReason2;
     }
     const toolResults = [];
     for (const toolCall of toolCalls) {
@@ -1634,77 +2318,243 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
       }
     ];
   }
-  await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: { type: "UsageExceeded", messages } });
-  throw new Error("Maximum number of tool round trips reached.");
+  const exitReason = { type: "UsageExceeded", messages };
+  await event("end-task", { kind: "EndTask" /* EndTask */, exitReason });
+  return exitReason;
 };
 
 // src/workflow/dynamic.ts
-import { parse } from "yaml";
-import { z as z17 } from "zod";
+import { parse as parse2 } from "yaml";
+import { z as z21 } from "zod";
 
 // src/workflow/dynamic-types.ts
-import { z as z16 } from "zod";
-var WorkflowInputDefinitionSchema = z16.object({
-  id: z16.string(),
-  description: z16.string().nullish(),
-  default: z16.any().nullish()
+import { z as z20 } from "zod";
+var WorkflowInputDefinitionSchema = z20.object({
+  id: z20.string(),
+  description: z20.string().nullish(),
+  default: z20.any().nullish()
 });
-var WorkflowStepDefinitionSchema = z16.object({
-  id: z16.string(),
-  tools: z16.array(z16.string()).nullish(),
-  task: z16.string(),
-  output: z16.string().nullish(),
-  expected_outcome: z16.string().nullish(),
-  /**
-   * Persisted JavaScript/TypeScript (JS-compatible) async function body.
-   * The code is wrapped as: `async (ctx) => { <code> }`.
-   */
-  code: z16.string().nullish(),
+var WorkflowStepDefinitionSchema = z20.object({
+  id: z20.string(),
+  tools: z20.array(z20.string()).nullish(),
+  task: z20.string(),
+  output: z20.string().nullish(),
+  expected_outcome: z20.string().nullish(),
   /**
    * Optional JSON schema or other metadata for future structured outputs.
    * Not interpreted by core today.
    */
-  outputSchema: z16.any().nullish(),
+  outputSchema: z20.any().nullish(),
   /**
    * Optional timeout in milliseconds. Step execution will be aborted if it exceeds this duration.
    */
-  timeout: z16.number().positive().nullish()
+  timeout: z20.number().positive().nullish()
+});
+var WhileLoopStepSchema = z20.object({
+  id: z20.string(),
+  while: z20.object({
+    condition: z20.string().describe("JavaScript expression that evaluates to true/false"),
+    steps: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema))
+  }),
+  output: z20.string().nullish()
 });
-var WorkflowDefinitionSchema = z16.object({
-  task: z16.string(),
-  inputs: z16.array(WorkflowInputDefinitionSchema).nullish(),
-  steps: z16.array(WorkflowStepDefinitionSchema),
-  output: z16.string().nullish()
+var IfElseStepSchema = z20.object({
+  id: z20.string(),
+  if: z20.object({
+    condition: z20.string().describe("JavaScript expression that evaluates to true/false"),
+    thenBranch: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema)),
+    elseBranch: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema)).optional()
+  }),
+  output: z20.string().nullish()
 });
-var WorkflowFileSchema = z16.object({
-  workflows: z16.record(z16.string(), WorkflowDefinitionSchema)
+var BreakStepSchema = z20.object({
+  break: z20.literal(true)
+});
+var ContinueStepSchema = z20.object({
+  continue: z20.literal(true)
+});
+var TryCatchStepSchema = z20.object({
+  id: z20.string(),
+  try: z20.object({
+    trySteps: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema)),
+    catchSteps: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema))
+  }),
+  output: z20.string().nullish()
+});
+var WorkflowControlFlowStepSchema = z20.union([
+  WorkflowStepDefinitionSchema,
+  WhileLoopStepSchema,
+  IfElseStepSchema,
+  BreakStepSchema,
+  ContinueStepSchema,
+  TryCatchStepSchema
+]);
+var WorkflowDefinitionSchema = z20.object({
+  task: z20.string(),
+  inputs: z20.array(WorkflowInputDefinitionSchema).nullish(),
+  steps: z20.array(WorkflowControlFlowStepSchema),
+  output: z20.string().nullish()
+});
+var WorkflowFileSchema = z20.object({
+  workflows: z20.record(z20.string(), WorkflowDefinitionSchema)
 });
 
 // src/workflow/dynamic.ts
+var MAX_WHILE_LOOP_ITERATIONS = 1e3;
+function convertJsonSchemaToZod(schema) {
+  if (schema.enum) {
+    return z21.enum(schema.enum.map((v) => String(v)));
+  }
+  if (Array.isArray(schema.type)) {
+    const types = schema.type;
+    if (types.includes("null") && types.length === 2) {
+      const nonNullType = types.find((t) => t !== "null");
+      if (nonNullType === "string") return z21.string().nullable();
+      if (nonNullType === "number") return z21.number().nullable();
+      if (nonNullType === "integer")
+        return z21.number().refine((val) => Number.isInteger(val)).nullable();
+      if (nonNullType === "boolean") return z21.boolean().nullable();
+      if (nonNullType === "object") {
+        const shape = {};
+        if (schema.properties) {
+          for (const [propName, propSchema] of Object.entries(schema.properties)) {
+            const propZod = convertJsonSchemaToZod(propSchema);
+            const isRequired = schema.required?.includes(propName);
+            shape[propName] = isRequired ? propZod : propZod.optional();
+          }
+        }
+        return z21.object(shape).nullable();
+      }
+      if (nonNullType === "array") return z21.array(z21.any()).nullable();
+    }
+    return z21.any();
+  }
+  const type = schema.type;
+  switch (type) {
+    case "string":
+      return z21.string();
+    case "number":
+      return z21.number();
+    case "integer":
+      return z21.number().refine((val) => Number.isInteger(val), { message: "Expected an integer" });
+    case "boolean":
+      return z21.boolean();
+    case "null":
+      return z21.null();
+    case "object": {
+      const shape = {};
+      if (schema.properties) {
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+          const propZod = convertJsonSchemaToZod(propSchema);
+          const isRequired = schema.required?.includes(propName);
+          shape[propName] = isRequired ? propZod : propZod.optional();
+        }
+      }
+      let objectSchema = z21.object(shape);
+      if (schema.additionalProperties === true) {
+        objectSchema = objectSchema.and(z21.any());
+      } else if (typeof schema.additionalProperties === "object") {
+        const additionalSchema = convertJsonSchemaToZod(schema.additionalProperties);
+        objectSchema = objectSchema.and(z21.record(z21.string(), additionalSchema));
+      }
+      return objectSchema;
+    }
+    case "array": {
+      if (!schema.items) {
+        return z21.array(z21.any());
+      }
+      const itemSchema = convertJsonSchemaToZod(schema.items);
+      return z21.array(itemSchema);
+    }
+    default:
+      return z21.any();
+  }
+}
 var TOOL_GROUPS = {
   readonly: ["readFile", "readBinaryFile", "listFiles", "searchFiles"],
   readwrite: ["readFile", "readBinaryFile", "listFiles", "searchFiles", "writeToFile", "replaceInFile", "removeFile", "renameFile"],
   internet: ["fetchUrl", "search"]
 };
+function validateWorkflowFile(definition) {
+  const errors = [];
+  for (const [workflowId, workflow] of Object.entries(definition.workflows)) {
+    if (!workflow.steps || workflow.steps.length === 0) {
+      errors.push(`Workflow '${workflowId}' has no steps`);
+      continue;
+    }
+    const checkBreakOutsideLoop = (steps, inLoop, path) => {
+      for (const step of steps) {
+        if (isBreakStep(step) || isContinueStep(step)) {
+          if (!inLoop) {
+            errors.push(`${path} has break/continue outside of a loop`);
+          }
+        }
+        if (isWhileLoopStep(step)) {
+          checkBreakOutsideLoop(step.while.steps, true, `${path}/${step.id}`);
+        }
+        if (isIfElseStep(step)) {
+          if (step.if.thenBranch) {
+            checkBreakOutsideLoop(step.if.thenBranch, inLoop, `${path}/${step.id}/then`);
+          }
+          if (step.if.elseBranch) {
+            checkBreakOutsideLoop(step.if.elseBranch, inLoop, `${path}/${step.id}/else`);
+          }
+        }
+        if (isTryCatchStep(step)) {
+          checkBreakOutsideLoop(step.try.trySteps, inLoop, `${path}/${step.id}/try`);
+          checkBreakOutsideLoop(step.try.catchSteps, inLoop, `${path}/${step.id}/catch`);
+        }
+      }
+    };
+    checkBreakOutsideLoop(workflow.steps, false, workflowId);
+    const findRunWorkflowCalls = (steps, path) => {
+      for (const step of steps) {
+        if (isWhileLoopStep(step)) {
+          findRunWorkflowCalls(step.while.steps, `${path}/${step.id}`);
+        }
+        if (isIfElseStep(step)) {
+          if (step.if.thenBranch) {
+            findRunWorkflowCalls(step.if.thenBranch, `${path}/${step.id}/then`);
+          }
+          if (step.if.elseBranch) {
+            findRunWorkflowCalls(step.if.elseBranch, `${path}/${step.id}/else`);
+          }
+        }
+        if (isTryCatchStep(step)) {
+          findRunWorkflowCalls(step.try.trySteps, `${path}/${step.id}/try`);
+          findRunWorkflowCalls(step.try.catchSteps, `${path}/${step.id}/catch`);
+        }
+      }
+    };
+    findRunWorkflowCalls(workflow.steps, workflowId);
+  }
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+  return { success: true };
+}
 function parseDynamicWorkflowDefinition(source) {
   try {
-    const raw = parse(source);
+    const raw = parse2(source);
     const validated = WorkflowFileSchema.safeParse(raw);
     if (!validated.success) {
-      return { success: false, error: z17.prettifyError(validated.error) };
+      return { success: false, error: z21.prettifyError(validated.error) };
+    }
+    const validation = validateWorkflowFile(validated.data);
+    if (!validation.success) {
+      return { success: false, error: `Workflow validation failed:
+${validation.errors.map((e) => `  - ${e}`).join("\n")}` };
     }
     return { success: true, definition: validated.data };
   } catch (error) {
     return { success: false, error: error instanceof Error ? error.message : String(error) };
   }
 }
-var AsyncFunction = Object.getPrototypeOf(async () => {
-}).constructor;
 function validateAndApplyDefaults(workflowId, workflow, input) {
   if (!workflow.inputs || workflow.inputs.length === 0) {
     return input;
   }
-  const validatedInput = {};
+  const validatedInput = { ...input };
   const errors = [];
   for (const inputDef of workflow.inputs) {
     const providedValue = input[inputDef.id];
@@ -1722,36 +2572,217 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
   }
   return validatedInput;
 }
+function evaluateCondition(condition, input, state, allowUnsafeCodeExecution = false) {
+  if (allowUnsafeCodeExecution) {
+    const functionBody = `
+      try {
+        return ${condition};
+      } catch (error) {
+        throw new Error('Condition evaluation failed: ' + (error instanceof Error ? error.message : String(error)));
+      }
+    `;
+    try {
+      const fn = new Function("input", "state", functionBody);
+      const result = fn(input, state);
+      return Boolean(result);
+    } catch (error) {
+      throw new Error(`Failed to evaluate condition: ${condition}. Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  } else {
+    return evaluateConditionSafe(condition, input, state);
+  }
+}
+function evaluateConditionSafe(condition, input, state) {
+  condition = condition.trim();
+  if (condition === "true") return true;
+  if (condition === "false") return false;
+  const orIndex = findTopLevelOperator(condition, "||");
+  if (orIndex !== -1) {
+    const left = condition.slice(0, orIndex).trim();
+    const right = condition.slice(orIndex + 2).trim();
+    return evaluateConditionSafe(left, input, state) || evaluateConditionSafe(right, input, state);
+  }
+  const andIndex = findTopLevelOperator(condition, "&&");
+  if (andIndex !== -1) {
+    const left = condition.slice(0, andIndex).trim();
+    const right = condition.slice(andIndex + 2).trim();
+    return evaluateConditionSafe(left, input, state) && evaluateConditionSafe(right, input, state);
+  }
+  const comparisonOps = ["===", "!==", "==", "!=", ">=", "<=", ">", "<"];
+  for (const op of comparisonOps) {
+    const opIndex = findTopLevelOperator(condition, op);
+    if (opIndex !== -1) {
+      const left = evaluateValue(condition.slice(0, opIndex).trim(), input, state);
+      const right = evaluateValue(condition.slice(opIndex + op.length).trim(), input, state);
+      return compareValues(left, right, op);
+    }
+  }
+  if (condition.startsWith("!")) {
+    return !evaluateConditionSafe(condition.slice(1).trim(), input, state);
+  }
+  if (hasEnclosingParens(condition)) {
+    const inner = condition.slice(1, -1);
+    return evaluateConditionSafe(inner, input, state);
+  }
+  const value = evaluateValue(condition, input, state);
+  return Boolean(value);
+}
+function findTopLevelOperator(expr, op) {
+  let parenDepth = 0;
+  let inString = false;
+  let stringChar = "";
+  let escapeNext = false;
+  for (let i = 0; i <= expr.length - op.length; i++) {
+    const char = expr[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (!inString && (char === '"' || char === "'")) {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (inString && char === stringChar) {
+      inString = false;
+      stringChar = "";
+      continue;
+    }
+    if (inString) continue;
+    if (char === "(") parenDepth++;
+    if (char === ")") parenDepth--;
+    if (parenDepth === 0 && expr.slice(i, i + op.length) === op) {
+      return i;
+    }
+  }
+  return -1;
+}
+function hasEnclosingParens(expr) {
+  expr = expr.trim();
+  if (!expr.startsWith("(") || !expr.endsWith(")")) {
+    return false;
+  }
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  let escapeNext = false;
+  for (let i = 0; i < expr.length; i++) {
+    const char = expr[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (!inString && (char === '"' || char === "'")) {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (inString && char === stringChar) {
+      inString = false;
+      stringChar = "";
+      continue;
+    }
+    if (inString) continue;
+    if (char === "(") {
+      depth++;
+      if (i === 0) depth = 1;
+    }
+    if (char === ")") {
+      depth--;
+      if (depth === 0 && i === expr.length - 1) {
+        return true;
+      }
+      if (depth === 0 && i < expr.length - 1) {
+        return false;
+      }
+    }
+  }
+  return false;
+}
+function evaluateValue(expr, input, state) {
+  expr = expr.trim();
+  const stringMatch = expr.match(/^(["'])(?:(?=(\\?))\2.)*?\1$/);
+  if (stringMatch) {
+    const quote = stringMatch[1];
+    if (quote === '"') {
+      try {
+        return JSON.parse(expr);
+      } catch (error) {
+        throw new Error(`Invalid string literal: "${expr}". Error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    } else {
+      let inner = expr.slice(1, -1);
+      inner = inner.replace(/\\'/g, "'");
+      inner = inner.replace(/\\"/g, '"');
+      const converted = `"${inner.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+      try {
+        return JSON.parse(converted);
+      } catch (error) {
+        throw new Error(`Invalid string literal: "${expr}". Error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  if (/^-?\d*\.?\d+(?:[eE][+-]?\d+)?$/.test(expr)) {
+    return Number.parseFloat(expr);
+  }
+  if (expr === "true") return true;
+  if (expr === "false") return false;
+  if (expr === "null") return null;
+  if (expr.startsWith("input.")) {
+    return getNestedProperty(input, expr.slice(6));
+  }
+  if (expr.startsWith("state.")) {
+    return getNestedProperty(state, expr.slice(6));
+  }
+  throw new Error(
+    `Unrecognized expression in condition: "${expr}". Valid expressions are: string literals, numbers, boolean literals, null, or property access like "input.foo" or "state.bar"`
+  );
+}
+function getNestedProperty(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function compareValues(left, right, op) {
+  switch (op) {
+    case "===":
+      return left === right;
+    case "!==":
+      return left !== right;
+    case "==":
+      return Object.is(left, right);
+    case "!=":
+      return !Object.is(left, right);
+    case ">=":
+      return left >= right;
+    case "<=":
+      return left <= right;
+    case ">":
+      return left > right;
+    case "<":
+      return left < right;
+    default:
+      throw new Error(`Unknown comparison operator: ${op}`);
+  }
+}
 function createRunWorkflowFn(args) {
   return async (subWorkflowId, subInput) => {
     const mergedInput = { ...args.input, ...args.state, ...subInput ?? {} };
     return await args.runInternal(subWorkflowId, mergedInput, args.context, args.state);
   };
 }
-function compileStep(stepDef, workflowId, compiledSteps) {
-  const key = `${workflowId}.${stepDef.id}`;
-  const existing = compiledSteps.get(key);
-  if (existing) {
-    return existing;
-  }
-  if (!stepDef.code) {
-    throw new Error(`Step '${stepDef.id}' in workflow '${workflowId}' has no code`);
-  }
-  try {
-    const fn = new AsyncFunction("ctx", stepDef.code);
-    compiledSteps.set(key, fn);
-    return fn;
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    const codePreview = stepDef.code.length > 200 ? `${stepDef.code.substring(0, 200)}...` : stepDef.code;
-    throw new Error(
-      `Failed to compile code for step '${stepDef.id}' in workflow '${workflowId}':
-  Error: ${errorMsg}
-  Code:
-${codePreview.split("\n").map((line) => `    ${line}`).join("\n")}`
-    );
-  }
-}
 async function executeStepWithAgent(stepDef, workflowId, input, state, context, options, runInternal) {
   const tools = context.tools;
   if (typeof tools.generateText !== "function" || typeof tools.invokeTool !== "function" || typeof tools.taskEvent !== "function") {
@@ -1794,9 +2825,9 @@ async function executeStepWithAgent(stepDef, workflowId, input, state, context,
     toolsForAgent.push({
       name: "runWorkflow",
       description: "Run a named sub-workflow defined in the current workflow file.",
-      parameters: z17.object({
-        workflowId: z17.string().describe("Sub-workflow id to run"),
-        input: z17.any().nullish().describe("Optional input object for the sub-workflow")
+      parameters: z21.object({
+        workflowId: z21.string().describe("Sub-workflow id to run"),
+        input: z21.any().nullish().describe("Optional input object for the sub-workflow")
       }),
       handler: async () => {
         return { success: false, message: { type: "error-text", value: "runWorkflow is virtual." } };
@@ -1886,38 +2917,11 @@ async function executeStepWithAgent(stepDef, workflowId, input, state, context,
   if (result.type === "UsageExceeded") {
     throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' exceeded usage limits (tokens or rounds)`);
   }
-  throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' exited unexpectedly with type: ${result.type}`);
+  const _exhaustiveCheck = result;
+  throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' exited unexpectedly with unhandled type`);
 }
-async function executeStepWithTimeout(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal) {
+async function executeStepWithTimeout(stepDef, workflowId, input, state, context, options, runInternal) {
   const executeStepLogic = async () => {
-    if (stepDef.code && options.allowUnsafeCodeExecution) {
-      context.logger.debug(`[Step] Executing step '${stepDef.id}' with compiled code`);
-      const fn = compileStep(stepDef, workflowId, compiledSteps);
-      const runWorkflow = createRunWorkflowFn({ input, state, context, runInternal });
-      const agentTools = {};
-      if (options.toolInfo) {
-        for (const tool of options.toolInfo) {
-          if (typeof context.tools[tool.name] === "function") {
-            agentTools[tool.name] = context.tools[tool.name];
-          }
-        }
-      }
-      const runtimeCtx = {
-        workflowId,
-        stepId: stepDef.id,
-        input,
-        state,
-        tools: context.tools,
-        logger: context.logger,
-        step: context.step,
-        runWorkflow,
-        toolInfo: options.toolInfo,
-        agentTools
-      };
-      const result2 = await fn(runtimeCtx);
-      context.logger.debug(`[Step] Compiled code execution completed for step '${stepDef.id}'`);
-      return result2;
-    }
     context.logger.debug(`[Step] Executing step '${stepDef.id}' with agent`);
     const result = await executeStepWithAgent(stepDef, workflowId, input, state, context, options, runInternal);
     context.logger.debug(`[Step] Agent execution completed for step '${stepDef.id}'`);
@@ -1940,22 +2944,19 @@ async function executeStepWithTimeout(stepDef, workflowId, input, state, context
   }
   return await executeStepLogic();
 }
-async function executeStep(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal) {
-  const result = await executeStepWithTimeout(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal);
+async function executeStep(stepDef, workflowId, input, state, context, options, runInternal) {
+  const result = await executeStepWithTimeout(stepDef, workflowId, input, state, context, options, runInternal);
   if (stepDef.outputSchema) {
     try {
-      const _schema = z17.any();
-      if (typeof stepDef.outputSchema === "object") {
-        context.logger.debug(`[Step] Validating output for step '${stepDef.id}' against schema`);
-        if (stepDef.outputSchema.type === "object") {
-          if (typeof result !== "object" || result === null || Array.isArray(result)) {
-            throw new Error(`Expected object output, got ${Array.isArray(result) ? "array" : result === null ? "null" : typeof result}`);
-          }
-        }
-        if (stepDef.outputSchema.type === "array" && !Array.isArray(result)) {
-          throw new Error(`Expected array output, got ${typeof result}`);
-        }
-      }
+      context.logger.debug(`[Step] Validating output for step '${stepDef.id}' against schema`);
+      const zodSchema = convertJsonSchemaToZod(stepDef.outputSchema);
+      const validationResult = zodSchema.safeParse(result);
+      if (!validationResult.success) {
+        const errorDetails = validationResult.error.issues.map((e) => `  - ${e.path.join(".") || "root"}: ${e.message}`).join("\n");
+        throw new Error(`Output does not match expected schema:
+${errorDetails}`);
+      }
+      context.logger.debug(`[Step] Output validation successful for step '${stepDef.id}'`);
     } catch (error) {
       throw new Error(
         `Step '${stepDef.id}' in workflow '${workflowId}' output validation failed: ${error instanceof Error ? error.message : String(error)}`
@@ -1964,6 +2965,204 @@ async function executeStep(stepDef, workflowId, input, state, context, options,
   }
   return result;
 }
+function isBreakStep(step) {
+  return typeof step === "object" && step !== null && "break" in step && step.break === true;
+}
+function isContinueStep(step) {
+  return typeof step === "object" && step !== null && "continue" in step && step.continue === true;
+}
+function isWhileLoopStep(step) {
+  return typeof step === "object" && step !== null && "while" in step;
+}
+function isIfElseStep(step) {
+  return typeof step === "object" && step !== null && "if" in step;
+}
+function isTryCatchStep(step) {
+  return typeof step === "object" && step !== null && "try" in step;
+}
+function storeStepOutput(step, result, state) {
+  if ("id" in step && step.output) {
+    const outputKey = step.output;
+    state[outputKey] = result;
+  }
+}
+function getStepId(step) {
+  if ("id" in step && step.id) {
+    return step.id;
+  }
+  if (isWhileLoopStep(step)) {
+    return "while";
+  }
+  if (isIfElseStep(step)) {
+    return "if";
+  }
+  if (isTryCatchStep(step)) {
+    return "try";
+  }
+  return "control";
+}
+async function executeControlFlowStep(step, workflowId, input, state, context, options, runInternal, loopDepth, breakFlag, continueFlag) {
+  if (isBreakStep(step)) {
+    if (loopDepth === 0) {
+      throw new Error(`'break' statement found outside of a loop in workflow '${workflowId}'`);
+    }
+    context.logger.debug(`[ControlFlow] Executing break statement (loop depth: ${loopDepth})`);
+    return { result: void 0, shouldBreak: true, shouldContinue: false };
+  }
+  if (isContinueStep(step)) {
+    if (loopDepth === 0) {
+      throw new Error(`'continue' statement found outside of a loop in workflow '${workflowId}'`);
+    }
+    context.logger.debug(`[ControlFlow] Executing continue statement (loop depth: ${loopDepth})`);
+    return { result: void 0, shouldBreak: false, shouldContinue: true };
+  }
+  if (isWhileLoopStep(step)) {
+    context.logger.info(`[ControlFlow] Executing while loop '${step.id}'`);
+    context.logger.debug(`[ControlFlow] Condition: ${step.while.condition}`);
+    context.logger.debug(`[ControlFlow] Loop body has ${step.while.steps.length} step(s)`);
+    let iterationCount = 0;
+    let loopResult;
+    while (true) {
+      iterationCount++;
+      if (iterationCount > MAX_WHILE_LOOP_ITERATIONS) {
+        throw new Error(
+          `While loop '${step.id}' in workflow '${workflowId}' exceeded maximum iteration limit of ${MAX_WHILE_LOOP_ITERATIONS}`
+        );
+      }
+      const conditionResult = evaluateCondition(step.while.condition, input, state, options.allowUnsafeCodeExecution);
+      context.logger.debug(`[ControlFlow] While loop '${step.id}' iteration ${iterationCount}: condition = ${conditionResult}`);
+      if (!conditionResult) {
+        context.logger.info(`[ControlFlow] While loop '${step.id}' terminated after ${iterationCount - 1} iteration(s)`);
+        break;
+      }
+      for (const bodyStep of step.while.steps) {
+        const { result, shouldBreak, shouldContinue } = await executeControlFlowStep(
+          bodyStep,
+          workflowId,
+          input,
+          state,
+          context,
+          options,
+          runInternal,
+          loopDepth + 1,
+          breakFlag,
+          continueFlag
+        );
+        if (shouldBreak) {
+          context.logger.debug(`[ControlFlow] Breaking from while loop '${step.id}'`);
+          breakFlag.value = false;
+          return { result: loopResult, shouldBreak: false, shouldContinue: false };
+        }
+        if (shouldContinue) {
+          context.logger.debug(`[ControlFlow] Continuing to next iteration of while loop '${step.id}'`);
+          continueFlag.value = false;
+          break;
+        }
+        storeStepOutput(bodyStep, result, state);
+        loopResult = result;
+      }
+    }
+    const outputKey = step.output ?? step.id;
+    state[outputKey] = loopResult;
+    context.logger.debug(`[ControlFlow] While loop '${step.id}' stored output as '${outputKey}'`);
+    return { result: loopResult, shouldBreak: false, shouldContinue: false };
+  }
+  if (isIfElseStep(step)) {
+    const ifStep = step;
+    context.logger.info(`[ControlFlow] Executing if/else branch '${ifStep.id}'`);
+    context.logger.debug(`[ControlFlow] Condition: ${ifStep.if.condition}`);
+    context.logger.debug(`[ControlFlow] Then branch has ${ifStep.if.thenBranch.length} step(s)`);
+    if (ifStep.if.elseBranch) {
+      context.logger.debug(`[ControlFlow] Else branch has ${ifStep.if.elseBranch.length} step(s)`);
+    }
+    const conditionResult = evaluateCondition(ifStep.if.condition, input, state, options.allowUnsafeCodeExecution);
+    context.logger.debug(`[ControlFlow] If/else '${ifStep.id}' condition = ${conditionResult}`);
+    const branchSteps = conditionResult ? ifStep.if.thenBranch : ifStep.if.elseBranch ?? [];
+    const branchName = conditionResult ? "then" : ifStep.if.elseBranch ? "else" : "else (empty)";
+    context.logger.info(`[ControlFlow] Taking '${branchName}' branch of '${ifStep.id}'`);
+    let branchResult;
+    for (const branchStep of branchSteps) {
+      const { result, shouldBreak, shouldContinue } = await executeControlFlowStep(
+        branchStep,
+        workflowId,
+        input,
+        state,
+        context,
+        options,
+        runInternal,
+        loopDepth,
+        breakFlag,
+        continueFlag
+      );
+      if (shouldBreak || shouldContinue) {
+        return { result, shouldBreak, shouldContinue };
+      }
+      storeStepOutput(branchStep, result, state);
+      branchResult = result;
+    }
+    const outputKey = ifStep.output ?? ifStep.id;
+    state[outputKey] = branchResult;
+    context.logger.debug(`[ControlFlow] If/else '${ifStep.id}' stored output as '${outputKey}'`);
+    return { result: branchResult, shouldBreak: false, shouldContinue: false };
+  }
+  if (isTryCatchStep(step)) {
+    const tryStep = step;
+    context.logger.info(`[ControlFlow] Executing try/catch block '${tryStep.id}'`);
+    context.logger.debug(`[ControlFlow] Try block has ${tryStep.try.trySteps.length} step(s)`);
+    context.logger.debug(`[ControlFlow] Catch block has ${tryStep.try.catchSteps.length} step(s)`);
+    let tryResult;
+    let caughtError;
+    try {
+      for (const tryStepItem of tryStep.try.trySteps) {
+        const { result } = await executeControlFlowStep(
+          tryStepItem,
+          workflowId,
+          input,
+          state,
+          context,
+          options,
+          runInternal,
+          loopDepth,
+          breakFlag,
+          continueFlag
+        );
+        storeStepOutput(tryStepItem, result, state);
+        tryResult = result;
+      }
+      const outputKey = tryStep.output ?? tryStep.id;
+      state[outputKey] = tryResult;
+      context.logger.debug(`[ControlFlow] Try/catch '${tryStep.id}' completed successfully`);
+      return { result: tryResult, shouldBreak: false, shouldContinue: false };
+    } catch (error) {
+      caughtError = error instanceof Error ? error : new Error(String(error));
+      context.logger.warn(`[ControlFlow] Try/catch '${tryStep.id}' caught error: ${caughtError.message}`);
+      let catchResult;
+      for (const catchStepItem of tryStep.try.catchSteps) {
+        const { result } = await executeControlFlowStep(
+          catchStepItem,
+          workflowId,
+          input,
+          state,
+          context,
+          options,
+          runInternal,
+          loopDepth,
+          breakFlag,
+          continueFlag
+        );
+        storeStepOutput(catchStepItem, result, state);
+        catchResult = result;
+      }
+      const outputKey = tryStep.output ?? tryStep.id;
+      state[outputKey] = catchResult;
+      context.logger.debug(`[ControlFlow] Try/catch '${tryStep.id}' caught error and executed catch block`);
+      return { result: catchResult, shouldBreak: false, shouldContinue: false };
+    }
+  }
+  const stepDef = step;
+  const stepResult = await executeStep(stepDef, workflowId, input, state, context, options, runInternal);
+  return { result: stepResult, shouldBreak: false, shouldContinue: false };
+}
 function createDynamicWorkflow(definition, options = {}) {
   if (typeof definition === "string") {
     const res = parseDynamicWorkflowDefinition(definition);
@@ -1972,36 +3171,49 @@ function createDynamicWorkflow(definition, options = {}) {
     }
     definition = res.definition;
   }
-  const compiledSteps = /* @__PURE__ */ new Map();
   const runInternal = async (workflowId, input, context, inheritedState) => {
     const workflow = definition.workflows[workflowId];
     if (!workflow) {
+      const builtIn = options.builtInWorkflows?.[workflowId];
+      if (builtIn) {
+        context.logger.info(`[Workflow] Delegating to built-in workflow '${workflowId}'`);
+        return await builtIn(input, context);
+      }
       throw new Error(`Workflow '${workflowId}' not found`);
     }
     const validatedInput = validateAndApplyDefaults(workflowId, workflow, input);
     context.logger.info(`[Workflow] Starting workflow '${workflowId}'`);
     context.logger.debug(`[Workflow] Input: ${JSON.stringify(validatedInput)}`);
     context.logger.debug(`[Workflow] Inherited state: ${JSON.stringify(inheritedState)}`);
-    context.logger.debug(`[Workflow] Steps: ${workflow.steps.map((s) => s.id).join(", ")}`);
+    context.logger.debug(`[Workflow] Steps: ${workflow.steps.map((s) => "id" in s ? s.id : "<control flow>").join(", ")}`);
     const state = { ...inheritedState };
     let lastOutput;
+    const breakFlag = { value: false };
+    const continueFlag = { value: false };
     for (let i = 0; i < workflow.steps.length; i++) {
       const stepDef = workflow.steps[i];
-      const stepName = `${workflowId}.${stepDef.id}`;
-      context.logger.info(`[Workflow] Step ${i + 1}/${workflow.steps.length}: ${stepDef.id}`);
-      context.logger.debug(`[Workflow] Step task: ${stepDef.task}`);
-      if (stepDef.expected_outcome) {
-        context.logger.debug(`[Workflow] Expected outcome: ${stepDef.expected_outcome}`);
-      }
-      context.logger.debug(`[Workflow] Current state keys: ${Object.keys(state).join(", ")}`);
-      lastOutput = await context.step(stepName, async () => {
-        return await executeStep(stepDef, workflowId, validatedInput, state, context, options, compiledSteps, runInternal);
-      });
-      const outputKey = stepDef.output ?? stepDef.id;
-      state[outputKey] = lastOutput;
-      context.logger.debug(
-        `[Workflow] Step output stored as '${outputKey}': ${typeof lastOutput === "object" ? JSON.stringify(lastOutput).substring(0, 200) : lastOutput}`
+      const stepId = getStepId(stepDef);
+      context.logger.info(`[Workflow] Step ${i + 1}/${workflow.steps.length}: ${stepId}`);
+      const { result } = await executeControlFlowStep(
+        stepDef,
+        workflowId,
+        validatedInput,
+        state,
+        context,
+        options,
+        runInternal,
+        0,
+        // loop depth
+        breakFlag,
+        continueFlag
       );
+      lastOutput = result;
+      storeStepOutput(stepDef, result, state);
+      if ("id" in stepDef && stepDef.output) {
+        context.logger.debug(
+          `[Workflow] Step output stored as '${stepDef.output}': ${typeof lastOutput === "object" ? JSON.stringify(lastOutput).substring(0, 200) : lastOutput}`
+        );
+      }
     }
     context.logger.info(`[Workflow] Completed workflow '${workflowId}'`);
     if (workflow.output) {
@@ -2016,725 +3228,6 @@ function createDynamicWorkflow(definition, options = {}) {
   };
 }
 
-// src/workflow/dynamic-generator.workflow.ts
-import { z as z18 } from "zod";
-
-// src/workflow/prompts/dynamic-generator-prompts.ts
-var RUNTIME_CONTEXT_TYPES = `## Runtime context (ctx)
-\`\`\`ts
-// Runtime types (for reference)
-type Logger = {
-  debug: (...args: any[]) => void
-  info: (...args: any[]) => void
-  warn: (...args: any[]) => void
-  error: (...args: any[]) => void
-}
-
-type StepFn = {
-  <T>(name: string, fn: () => Promise<T>): Promise<T>
-  <T>(name: string, options: { retry?: number }, fn: () => Promise<T>): Promise<T>
-}
-
-type JsonModelMessage = { role: 'system' | 'user' | 'assistant' | 'tool'; content: any }
-type JsonResponseMessage = { role: 'assistant' | 'tool'; content: any }
-type ToolSet = Record<string, any>
-
-type ToolResponseResult =
-  | { type: 'text'; value: string }
-  | { type: 'json'; value: any }
-  | { type: 'error-text'; value: string }
-  | { type: 'error-json'; value: any }
-  | { type: 'content'; value: any[] }
-
-type ToolResponse =
-  | { type: 'Reply'; message: ToolResponseResult }
-  | { type: 'Exit'; message: string; object?: any }
-  | { type: 'Error'; message: ToolResponseResult }
-
-type ExitReason =
-  | { type: 'UsageExceeded' }
-  | { type: 'Exit'; message: string; object?: any }
-  | { type: 'Error'; error: { message: string; stack?: string } }
-
-type FullToolInfo = { name: string; description: string; parameters: any; handler: any }
-
-type AgentTools = {
-  readFile: (input: { path: string }) => Promise<string | null>
-  writeToFile: (input: { path: string; content: string }) => Promise<void>
-  executeCommand: (input: { command: string; pipe?: boolean; requiresApproval?: boolean } & ({ args: string[]; shell?: false } | { shell: true })) => Promise<{
-    exitCode: number
-    stdout: string
-    stderr: string
-  }>
-  searchFiles: (input: { path: string; regex: string; filePattern?: string }) => Promise<string>
-  listFiles: (input: { path: string; recursive?: boolean; maxCount?: number; includeIgnored?: boolean }) => Promise<string>
-  fetchUrl: (input: { url: string[] }) => Promise<string>
-  askFollowupQuestion: (input: { questions: { prompt: string; options?: string[] }[] }) => Promise<any>
-  // ... and other tools available in the environment
-}
-
-// Tools available on ctx.tools in dynamic steps
-type DynamicWorkflowTools = {
-  // LLM + agent helpers
-  runAgent: (input: {
-    tools: Readonly<FullToolInfo[]>
-    maxToolRoundTrips?: number
-    userMessage: readonly JsonModelMessage[]
-  } & ({ messages: JsonModelMessage[] } | { systemPrompt: string })) => Promise<ExitReason>
-
-  // CLI UX helpers
-  confirm: (input: { message: string }) => Promise<boolean>
-  input: (input: { message: string; default?: string }) => Promise<string>
-  select: (input: { message: string; choices: { name: string; value: string }[] }) => Promise<string>
-}
-
-type DynamicStepRuntimeContext = {
-  workflowId: string
-  stepId: string
-  input: Record<string, any>
-  state: Record<string, any>
-  tools: DynamicWorkflowTools
-  agentTools: AgentTools
-  logger: Logger
-  step: StepFn
-  runWorkflow: (workflowId: string, input?: Record<string, any>) => Promise<any>
-  toolInfo?: ReadonlyArray<FullToolInfo>
-}
-\`\`\`
-
-- \`ctx.input\`: workflow inputs (read-only).
-- \`ctx.state\`: shared state between steps (previous step outputs are stored here).
-- \`ctx.agentTools\`: standard tools (readFile, executeCommand, etc.). Call as \`await ctx.agentTools.someTool({ ... })\`.
-- \`ctx.tools\`: workflow helpers (runAgent, confirm, input, select).
-- \`ctx.runWorkflow\`: run a sub-workflow by id.`;
-var CONTEXT_USAGE_GUIDELINES = `## Guidelines
-- Use \`await\` for all async operations.
-- Return the output value for the step (this becomes the step output).
-- Access inputs via \`ctx.input.<inputId>\`.
-- Access previous step outputs via \`ctx.state.<stepOutputKey>\` (defaults to the step \`output\` or \`id\`).`;
-var QUALITY_GUIDELINES = `## Quality Guidelines for Code Implementation
-
-### Error Handling
-- ALWAYS validate inputs at the start of steps
-- Use try-catch for operations that might fail (file I/O, parsing, API calls)
-- Preserve stack traces: re-throw original errors rather than creating new ones
-- Use error type guards: \`const err = error instanceof Error ? error : new Error(String(error))\`
-- Check for null/undefined before using values
-- Handle edge cases (empty arrays, missing files, invalid data)
-
-### Logging
-- Use \`ctx.logger.info()\` for important progress updates
-- Use \`ctx.logger.debug()\` for detailed information
-- Use \`ctx.logger.warn()\` for recoverable issues
-- Use \`ctx.logger.error()\` before throwing errors
-- Log when starting and completing significant operations
-- Use template literals for readability: \`ctx.logger.info(\\\`Processing \${items.length} items...\\\`)\`
-
-### User Experience
-- Provide progress feedback for long operations
-- Return structured data (objects/arrays), not strings when possible
-- Include helpful metadata in results (counts, timestamps, status)
-- For batch operations, report progress: \`Processed 5/10 items\`
-
-### Data Validation
-- Validate required fields exist before accessing
-- Check data types match expectations
-- Validate array lengths before iteration
-- Example: \`if (!data?.users || !Array.isArray(data.users)) throw new Error('Invalid data format')\`
-
-### Best Practices
-- Use meaningful variable names
-- Avoid nested callbacks - use async/await
-- Clean up resources (close files, clear timeouts)
-- Return consistent data structures across similar steps
-- For iteration, consider batching or rate limiting
-
-### When to Simplify
-- Simple transformation steps (e.g., formatting strings) need only basic error handling
-- Internal sub-workflow steps with validated inputs from parent can skip redundant validation
-- Minimal logging is fine for fast steps (<100ms) that don't perform I/O or external calls
-- Use judgment: match error handling complexity to the step's failure risk and impact`;
-var TOOL_CALLING_EXAMPLES = `## Tool calling examples
-
-### Standard tools (ctx.agentTools)
-\`\`\`ts
-// readFile
-const readme = await ctx.agentTools.readFile({ path: 'README.md' })
-if (readme == null) throw new Error('README.md not found')
-
-// writeToFile
-await ctx.agentTools.writeToFile({ path: 'notes.txt', content: 'hello\\n' })
-
-// executeCommand (args form)
-const rg = await ctx.agentTools.executeCommand({ command: 'rg', args: ['-n', 'TODO', '.'] })
-if (rg.exitCode !== 0) throw new Error(rg.stderr)
-
-// executeCommand (shell form)
-await ctx.agentTools.executeCommand({ command: 'ls -la', shell: true, pipe: true })
-\`\`\`
-
-### Workflow helpers (ctx.tools)
-\`\`\`ts
-// runAgent (nested agent; use ctx.toolInfo as the tool list)
-const agentRes = await ctx.tools.runAgent({
-  systemPrompt: 'You are a helpful assistant.',
-  userMessage: [{ role: 'user', content: 'Summarize README.md in 3 bullets.' }],
-  tools: (ctx.toolInfo ?? []) as any,
-})
-if (agentRes.type !== 'Exit') throw new Error('runAgent failed')
-
-// confirm / input / select (interactive)
-const ok = await ctx.tools.confirm({ message: 'Proceed?' })
-const name = await ctx.tools.input({ message: 'Name?', default: 'main' })
-const flavor = await ctx.tools.select({
-  message: 'Pick one',
-  choices: [
-    { name: 'A', value: 'a' },
-    { name: 'B', value: 'b' },
-  ],
-})
-\`\`\`
-
-### Sub-workflow example (ctx.runWorkflow)
-\`\`\`ts
-const results: any[] = []
-for (const pr of ctx.state.prs ?? []) {
-  results.push(await ctx.runWorkflow('reviewPR', { prId: pr.id }))
-}
-return results
-\`\`\``;
-var COMPLETE_STEP_EXAMPLE = `## Complete Example: High-Quality Step Implementation
-
-This example demonstrates all quality guidelines in a single step:
-
-\`\`\`ts
-// Step: processUserData
-// Task: Read, validate, and process user data from a file
-
-// Input validation
-if (!ctx.input.dataFile) {
-  throw new Error('Missing required input: dataFile')
-}
-
-ctx.logger.info(\`Starting user data processing for: \${ctx.input.dataFile}\`)
-
-// Read file with error handling
-let rawData
-try {
-  ctx.logger.debug(\`Reading file: \${ctx.input.dataFile}\`)
-  rawData = await ctx.agentTools.readFile({ path: ctx.input.dataFile })
-
-  if (!rawData) {
-    throw new Error(\`File not found or empty: \${ctx.input.dataFile}\`)
-  }
-} catch (error) {
-  const err = error instanceof Error ? error : new Error(String(error))
-  ctx.logger.error(\`Failed to read file: \${err.message}\`)
-  throw err  // Preserve original stack trace
-}
-
-// Parse and validate data
-let users
-try {
-  ctx.logger.debug('Parsing JSON data')
-  const parsed = JSON.parse(rawData)
-
-  if (!parsed?.users || !Array.isArray(parsed.users)) {
-    throw new Error('Invalid data format: expected {users: [...]}')
-  }
-
-  users = parsed.users
-  ctx.logger.info(\`Found \${users.length} users to process\`)
-} catch (error) {
-  const err = error instanceof Error ? error : new Error(String(error))
-  ctx.logger.error(\`Data parsing failed: \${err.message}\`)
-  throw err  // Preserve original stack trace
-}
-
-// Process each user with progress reporting
-const results = []
-for (let i = 0; i < users.length; i++) {
-  const user = users[i]
-
-  // Validate each user object
-  if (!user?.id || !user?.email) {
-    ctx.logger.warn(\`Skipping invalid user at index \${i}: missing id or email\`)
-    continue
-  }
-
-  // Process user
-  const processed = {
-    id: user.id,
-    email: user.email.toLowerCase().trim(),
-    name: user.name?.trim() || 'Unknown',
-    processedAt: new Date().toISOString(),
-    status: 'active'
-  }
-
-  results.push(processed)
-
-  // Progress feedback every 10 items
-  if ((i + 1) % 10 === 0) {
-    ctx.logger.info(\`Processed \${i + 1}/\${users.length} users\`)
-  }
-}
-
-ctx.logger.info(\`Successfully processed \${results.length}/\${users.length} users\`)
-
-// Return structured result with metadata
-return {
-  users: results,
-  metadata: {
-    totalInput: users.length,
-    totalProcessed: results.length,
-    skipped: users.length - results.length,
-    processedAt: new Date().toISOString()
-  }
-}
-\`\`\`
-
-Key features demonstrated:
-- Input validation at start
-- Comprehensive error handling with try-catch that preserves stack traces
-- Logging at info, debug, warn, and error levels
-- Progress reporting for long operations (every 10 items)
-- Data validation throughout (null checks, type checks, array validation)
-- Structured return value with metadata for observability
-- Descriptive error messages with context
-- Meaningful variable names (rawData, users, processed)
-- Clean async/await usage
-- Template literals for readable string interpolation
-- Proper error type guards (error instanceof Error)`;
-var CODE_FIELD_CONSTRAINTS = `REMEMBER: The "code" field must be ONLY the function body statements.
-- DO NOT wrap code in arrow functions: \`(ctx) => { ... }\`
-- DO NOT wrap code in async functions: \`async (ctx) => { ... }\`
-- DO NOT include outer curly braces
-- DO include a return statement if the step should produce output
-- Each "code" field should be a string containing multiple statements separated by newlines`;
-function composeImplementationGuidelines() {
-  return [
-    RUNTIME_CONTEXT_TYPES,
-    "",
-    CONTEXT_USAGE_GUIDELINES,
-    "",
-    QUALITY_GUIDELINES,
-    "",
-    TOOL_CALLING_EXAMPLES,
-    "",
-    COMPLETE_STEP_EXAMPLE
-  ].join("\n");
-}
-
-// src/workflow/dynamic-generator.workflow.ts
-var GenerateWorkflowDefinitionInputSchema = z18.object({
-  prompt: z18.string(),
-  availableTools: z18.array(
-    z18.object({
-      name: z18.string(),
-      description: z18.string()
-    })
-  ).nullish()
-});
-var GenerateWorkflowCodeInputSchema = z18.object({
-  workflow: WorkflowFileSchema,
-  skipReview: z18.boolean().nullish()
-});
-var AsyncFunction2 = Object.getPrototypeOf(async () => {
-}).constructor;
-function validateWorkflowDefinition(workflow) {
-  const errors = [];
-  if (!workflow.workflows.main) {
-    errors.push("Missing required 'main' workflow");
-  }
-  for (const [wfId, wf] of Object.entries(workflow.workflows)) {
-    const stepIds = /* @__PURE__ */ new Set();
-    for (const step of wf.steps) {
-      if (stepIds.has(step.id)) {
-        errors.push(`Duplicate step ID '${step.id}' in workflow '${wfId}'`);
-      }
-      stepIds.add(step.id);
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function validateWorkflowCodeSyntax(workflow) {
-  const errors = [];
-  for (const [wfId, wf] of Object.entries(workflow.workflows)) {
-    for (const step of wf.steps) {
-      if (step.code) {
-        try {
-          new AsyncFunction2("ctx", step.code);
-        } catch (e) {
-          const errorMsg = e instanceof Error ? e.message : String(e);
-          errors.push(`Syntax error in ${wfId}.${step.id}: ${errorMsg}`);
-        }
-      }
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-var WORKFLOW_DEFINITION_SYSTEM_PROMPT = `You are an expert workflow architect.
-Your task is to create a JSON workflow definition based on the user's request.
-
-The workflow definition must follow this structure:
-{
-  "workflows": {
-    "workflowName": {
-      "task": "Description of the workflow",
-      "inputs": [
-        { "id": "inputName", "description": "Description", "default": "optionalDefault" }
-      ],
-      "steps": [
-        {
-          "id": "stepId",
-          "task": "Description of the step",
-          "tools": ["toolName1", "toolName2"], // Optional: restrict which tools can be used. Can use groups: "readonly", "readwrite", "internet", "all".
-          "output": "outputVariableName", // Optional: defaults to step id
-          "timeout": 30000, // Optional: timeout in milliseconds
-          "expected_outcome": "What this step produces", // Optional: documentation for expected results
-          "outputSchema": { "type": "object" } // Optional: validation schema
-        }
-      ],
-      "output": "outputVariableName" // Optional
-    }
-  }
-}
-
-Constraints:
-- You MUST always include a workflow named 'main'. This is the entry point.
-- The 'main' workflow input must be either empty (no input) or a single string input.
-- Break down complex tasks into logical steps.
-- Define clear inputs and outputs.
-
-Quality Guidelines:
-- Add "timeout" field (in milliseconds) for steps that might take long (file I/O, API calls, searches)
-- Use "expected_outcome" field to document what each step should produce and its format
-- Use descriptive step IDs (e.g., "validateInput", "fetchUserData", not "step1", "step2")
-- Design steps to be focused - one responsibility per step
-- For steps that process multiple items, consider creating a sub-workflow
-- Add "outputSchema" with type information for validation-critical steps
-- Order steps logically with clear data flow
-
-### Using expected_outcome Effectively
-
-The "expected_outcome" field helps document what each step produces. Best practices:
-- Describe the data structure: "Returns an array of { id, name, status } objects"
-- Mention important constraints: "Returns at most 10 results, sorted by date"
-- Note failure modes: "Returns null if file not found"
-- Document side effects: "Creates output directory if it doesn't exist"
-
-Example 1 - Research workflow:
-User: "Research a topic and summarize it."
-Output:
-\`\`\`json
-{
-  "workflows": {
-    "main": {
-      "task": "Research a topic and provide a summary",
-      "inputs": [
-        { "id": "topic", "description": "The topic to research" }
-      ],
-      "steps": [
-        {
-          "id": "search",
-          "task": "Search for information about the topic",
-          "tools": ["search"],
-          "output": "searchResults",
-          "timeout": 30000,
-          "expected_outcome": "Returns search results with titles, URLs, and snippets related to the topic"
-        },
-        {
-          "id": "summarize",
-          "task": "Summarize the search results",
-          "tools": ["runAgent"],
-          "output": "summary",
-          "expected_outcome": "Returns a concise summary string (2-3 paragraphs) of the key findings"
-        }
-      ],
-      "output": "summary"
-    }
-  }
-}
-\`\`\`
-
-Example 2 - PR review workflow with sub-workflow:
-User: "Review urgent PRs. For each PR, run the review workflow."
-Output:
-\`\`\`json
-{
-  "workflows": {
-    "main": {
-      "task": "Fetch urgent PRs and review them",
-      "inputs": [],
-      "steps": [
-        {
-          "id": "fetchPRs",
-          "task": "Fetch list of urgent PRs",
-          "tools": ["github_list_prs"],
-          "output": "prs",
-          "timeout": 15000,
-          "expected_outcome": "Returns array of PR objects with { id, title, author, url }"
-        },
-        {
-          "id": "reviewEachPR",
-          "task": "Run review workflow for each PR",
-          "tools": [],
-          "output": "reviews",
-          "expected_outcome": "Returns array of review results, one per PR"
-        }
-      ],
-      "output": "reviews"
-    },
-    "reviewPR": {
-      "task": "Review a single PR",
-      "inputs": [
-        { "id": "prId", "description": "ID of the PR to review" }
-      ],
-      "steps": [
-        {
-          "id": "getDiff",
-          "task": "Get PR diff",
-          "tools": ["github_get_diff"],
-          "output": "diff",
-          "timeout": 10000,
-          "expected_outcome": "Returns the unified diff string for the PR"
-        },
-        {
-          "id": "analyze",
-          "task": "Analyze the diff and provide feedback",
-          "tools": ["runAgent"],
-          "output": "analysis",
-          "expected_outcome": "Returns { summary, issues, suggestions } object with review feedback"
-        }
-      ],
-      "output": "analysis"
-    }
-  }
-}
-\`\`\`
-
-Example 3 - File processing with conditional logic:
-User: "Process all JSON files in a directory, validate them, and generate a report."
-Output:
-\`\`\`json
-{
-  "workflows": {
-    "main": {
-      "task": "Process and validate JSON files, then generate a report",
-      "inputs": [
-        { "id": "directory", "description": "Directory containing JSON files", "default": "data" }
-      ],
-      "steps": [
-        {
-          "id": "listJsonFiles",
-          "task": "List all JSON files in the directory",
-          "tools": ["listFiles"],
-          "output": "jsonFiles",
-          "timeout": 5000,
-          "expected_outcome": "Returns array of file paths ending in .json"
-        },
-        {
-          "id": "processFiles",
-          "task": "Process each JSON file using the processFile sub-workflow",
-          "tools": [],
-          "output": "processedResults",
-          "expected_outcome": "Returns array of { file, valid, errors?, data? } for each file"
-        },
-        {
-          "id": "generateReport",
-          "task": "Generate a summary report of all processed files",
-          "tools": ["writeToFile"],
-          "output": "reportPath",
-          "expected_outcome": "Writes report to 'report.md' and returns the file path"
-        }
-      ],
-      "output": "reportPath"
-    },
-    "processFile": {
-      "task": "Process and validate a single JSON file",
-      "inputs": [
-        { "id": "filePath", "description": "Path to the JSON file" }
-      ],
-      "steps": [
-        {
-          "id": "readFile",
-          "task": "Read the JSON file content",
-          "tools": ["readFile"],
-          "output": "content",
-          "timeout": 3000,
-          "expected_outcome": "Returns file content as string, or null if not found"
-        },
-        {
-          "id": "validateJson",
-          "task": "Parse and validate the JSON structure",
-          "tools": [],
-          "output": "validationResult",
-          "expected_outcome": "Returns { valid: boolean, data?: object, errors?: string[] }"
-        }
-      ],
-      "output": "validationResult"
-    }
-  }
-}
-\`\`\`
-`;
-var WORKFLOW_IMPLEMENTATION_GUIDELINES = composeImplementationGuidelines();
-var WORKFLOW_CODE_SYSTEM_PROMPT = `You are an expert TypeScript developer.
-Your task is to implement the TypeScript code for the steps in the provided workflow definition.
-
-You will receive a JSON workflow definition where the "code" field is null.
-You must fill in the "code" field for each step with valid TypeScript code.
-
-CRITICAL: Each step "code" field must contain ONLY the function body statements (the code inside the curly braces).
-DO NOT include function declaration, arrow function syntax, async keyword, parameter list, or outer curly braces.
-
-Prefer using \`ctx.tools.runAgent\` for complex tasks or when multiple steps/tools are needed. Use \`ctx.agentTools\` for direct tool usage (e.g. \`ctx.agentTools.readFile\`).
-
-The code will be wrapped automatically in: \`async (ctx) => { YOUR_CODE_HERE }\`
-
-Example of CORRECT code field:
-\`\`\`ts
-const result = await ctx.agentTools.readFile({ path: 'README.md' })
-if (!result) throw new Error('File not found')
-return result
-\`\`\`
-
-Example of INCORRECT code field (DO NOT DO THIS):
-\`\`\`ts
-async (ctx) => {
-  const result = await ctx.agentTools.readFile({ path: 'README.md' })
-  return result
-}
-\`\`\`
-
-${WORKFLOW_IMPLEMENTATION_GUIDELINES}
-
-## Final Instructions
-
-${CODE_FIELD_CONSTRAINTS}
-
-Return the complete workflow JSON with the "code" fields populated.
-`;
-var WORKFLOW_REVIEW_SYSTEM_PROMPT = `You are an expert TypeScript Code Reviewer.
-Your task is to review the provided workflow definition and its implemented code, and improve it to meet the highest quality standards.
-
-You will receive a JSON workflow definition where the "code" fields are already populated.
-You must review each step's code and improve it if necessary.
-
-Check for:
-- Correct usage of \`ctx.agentTools\` (for standard tools) and \`ctx.tools\` (for workflow helpers).
-- Proper error handling (try-catch, input validation).
-- Meaningful logging.
-- Adherence to the Quality Guidelines.
-- Correct syntax (no outer function wrappers).
-
-${QUALITY_GUIDELINES}
-
-## Final Instructions
-
-Return the complete workflow JSON with the "code" fields improved where necessary.
-Ensure the "code" field still contains ONLY the function body statements.
-`;
-var MAX_GENERATION_ATTEMPTS = 3;
-var generateWorkflowDefinitionWorkflow = async (input, ctx) => {
-  let systemPrompt = WORKFLOW_DEFINITION_SYSTEM_PROMPT;
-  if (input.availableTools && input.availableTools.length > 0) {
-    const toolsList = input.availableTools.map((t) => `- ${t.name}: ${t.description}`).join("\n");
-    systemPrompt += `
-
-Available Tools:
-${toolsList}
-
-Use these tools when appropriate.`;
-  }
-  const result = await ctx.step("generate-workflow-definition", async () => {
-    return agentWorkflow(
-      {
-        systemPrompt,
-        userMessage: [{ role: "user", content: input.prompt }],
-        tools: [],
-        outputSchema: WorkflowFileSchema
-      },
-      ctx
-    );
-  });
-  if (result.type !== "Exit" || !result.object) {
-    throw new Error("Failed to generate workflow definition");
-  }
-  const workflow = result.object;
-  await ctx.step("validate-workflow-definition", async () => {
-    const validation = validateWorkflowDefinition(workflow);
-    if (!validation.valid) {
-      ctx.logger.warn(`Workflow definition validation warnings: ${validation.errors.join("; ")}`);
-    }
-    return validation;
-  });
-  return workflow;
-};
-var generateWorkflowCodeWorkflow = async (input, ctx) => {
-  let lastError = null;
-  let currentWorkflow = input.workflow;
-  for (let attempt = 0; attempt < MAX_GENERATION_ATTEMPTS; attempt++) {
-    const stepName = attempt === 0 ? "generate-workflow-code" : `retry-workflow-code-${attempt}`;
-    const userMessage = lastError ? `Previous attempt had issues: ${lastError}
-
-Please fix the problems in this workflow:
-${JSON.stringify(currentWorkflow, null, 2)}` : JSON.stringify(currentWorkflow, null, 2);
-    const generated = await ctx.step(stepName, async () => {
-      return agentWorkflow(
-        {
-          systemPrompt: WORKFLOW_CODE_SYSTEM_PROMPT,
-          userMessage: [{ role: "user", content: userMessage }],
-          tools: [],
-          outputSchema: WorkflowFileSchema
-        },
-        ctx
-      );
-    });
-    if (generated.type !== "Exit" || !generated.object) {
-      lastError = "Failed to generate workflow code";
-      continue;
-    }
-    const generatedWorkflow = generated.object;
-    const syntaxValidation = await ctx.step(`validate-code-syntax-${attempt}`, async () => {
-      return validateWorkflowCodeSyntax(generatedWorkflow);
-    });
-    if (!syntaxValidation.valid) {
-      lastError = syntaxValidation.errors.join("; ");
-      currentWorkflow = generatedWorkflow;
-      ctx.logger.warn(`Code syntax validation failed (attempt ${attempt + 1}): ${lastError}`);
-      continue;
-    }
-    if (input.skipReview) {
-      return generatedWorkflow;
-    }
-    const reviewed = await ctx.step("review-workflow-code", async () => {
-      return agentWorkflow(
-        {
-          systemPrompt: WORKFLOW_REVIEW_SYSTEM_PROMPT,
-          userMessage: [{ role: "user", content: JSON.stringify(generatedWorkflow, null, 2) }],
-          tools: [],
-          outputSchema: WorkflowFileSchema
-        },
-        ctx
-      );
-    });
-    if (reviewed.type !== "Exit" || !reviewed.object) {
-      throw new Error("Failed to review workflow code");
-    }
-    const reviewedWorkflow = reviewed.object;
-    const reviewSyntaxValidation = await ctx.step("validate-reviewed-code-syntax", async () => {
-      return validateWorkflowCodeSyntax(reviewedWorkflow);
-    });
-    if (!reviewSyntaxValidation.valid) {
-      ctx.logger.warn(`Reviewed code has syntax issues: ${reviewSyntaxValidation.errors.join("; ")}`);
-      return generatedWorkflow;
-    }
-    return reviewedWorkflow;
-  }
-  throw new Error(`Failed to generate valid workflow code after ${MAX_GENERATION_ATTEMPTS} attempts: ${lastError}`);
-};
-
 // src/workflow/json-ai-types.ts
 var toJsonDataContent = (data) => {
   if (data instanceof URL) {
@@ -2933,16 +3426,35 @@ var makeStepFn = () => {
   };
 };
 export {
-  GenerateWorkflowCodeInputSchema,
-  GenerateWorkflowDefinitionInputSchema,
+  BreakStepSchema,
+  ContinueStepSchema,
+  IGNORED_DIRECTORIES,
+  IfElseStepSchema,
+  ListSkillsInputSchema,
+  ListSkillsOutputSchema,
+  LoadSkillInputSchema,
+  LoadSkillOutputSchema,
   MockProvider,
+  NodeFileSystemProvider,
+  ReadSkillFileInputSchema,
+  ReadSkillFileOutputSchema,
+  SKILL_ERROR_MESSAGES,
+  SKILL_LIMITS,
+  SOURCE_ICONS,
+  SUSPICIOUS_PATTERNS,
+  SkillDiscoveryError,
+  SkillDiscoveryService,
+  SkillValidationError,
   TOOL_GROUPS,
   TaskEventKind,
   TodoItemSchema,
   TodoStatus,
+  TryCatchStepSchema,
   UpdateTodoItemInputSchema,
   UpdateTodoItemOutputSchema,
   UsageMeter,
+  WhileLoopStepSchema,
+  WorkflowControlFlowStepSchema,
   WorkflowDefinitionSchema,
   WorkflowFileSchema,
   WorkflowInputDefinitionSchema,
@@ -2956,25 +3468,36 @@ export {
   executeCommand_default as executeCommand,
   fetchUrl_default as fetchUrl,
   fromJsonModelMessage,
-  generateWorkflowCodeWorkflow,
-  generateWorkflowDefinitionWorkflow,
+  getSkillStats,
   listFiles_default as listFiles,
+  listSkills,
+  listSkillsToolInfo,
+  loadSkill,
+  loadSkillToolInfo,
   makeStepFn,
+  mcpServerConfigSchema,
   parseDynamicWorkflowDefinition,
   parseJsonFromMarkdown,
+  providerConfigSchema,
   providerModelSchema,
   readBinaryFile_default as readBinaryFile,
   readFile_default as readFile,
+  readSkillFile,
+  readSkillFileToolInfo,
   removeFile_default as removeFile,
   renameFile_default as renameFile,
   replaceInFile_default as replaceInFile,
   replaceInFile as replaceInFileHelper,
   responsePrompts,
   ruleSchema,
+  scriptSchema,
   search_default as search,
   searchFiles_default as searchFiles,
+  skillMetadataSchema,
   toJsonModelMessage,
-  validateWorkflowCodeSyntax,
-  validateWorkflowDefinition,
+  validateSkillMetadata,
+  validateSkillReferences,
+  validateSkillSecurity,
+  validateWorkflowFile,
   writeToFile_default as writeToFile
 };