@mastra/agent-builder 0.0.1-alpha.1 → 0.0.1-alpha.2

package/dist/index.js

@@ -2,18 +2,20 @@ import { Agent } from '@mastra/core/agent';
 import { Memory } from '@mastra/memory';
 import { TokenLimiter } from '@mastra/memory/processors';
 import { exec as exec$1, execFile as execFile$1, spawn as spawn$1 } from 'child_process';
-import { mkdtemp, rm, readFile, writeFile, mkdir, copyFile, stat, readdir } from 'fs/promises';
-import { join, resolve, dirname, extname, basename, isAbsolute, relative } from 'path';
+import { mkdtemp, rm, readFile, writeFile, readdir, mkdir, copyFile, stat } from 'fs/promises';
+import { join, resolve, basename, extname, dirname, isAbsolute, relative } from 'path';
 import { createTool } from '@mastra/core/tools';
 import ignore from 'ignore';
 import { z } from 'zod';
 import { existsSync, readFileSync } from 'fs';
 import { createRequire } from 'module';
 import { promisify } from 'util';
-import { MemoryProcessor, Agent as Agent$1 } from '@mastra/core';
+import { openai as openai$1 } from '@ai-sdk/openai_v5';
+import { createStep as createStep$1, Agent as Agent$1, createWorkflow as createWorkflow$1, createTool as createTool$1, MemoryProcessor } from '@mastra/core';
 import { tmpdir } from 'os';
 import { openai } from '@ai-sdk/openai';
 import { createStep, createWorkflow } from '@mastra/core/workflows';
+import { stepCountIs } from 'ai';
 
 // src/agent/index.ts
 var UNIT_KINDS = ["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"];
@@ -491,6 +493,42 @@ async function renameAndCopyFile(sourceFile, targetFile) {
   console.log(`\u{1F4DD} Copied with unique name: ${basename(uniqueTargetFile)}`);
   return uniqueTargetFile;
 }
+var resolveModel = (runtimeContext) => {
+  const modelFromContext = runtimeContext.get("model");
+  if (modelFromContext) {
+    console.log(`Using model: ${modelFromContext}`);
+    if (isValidMastraLanguageModel(modelFromContext)) {
+      return modelFromContext;
+    }
+    throw new Error(
+      'Invalid model provided. Model must be a MastraLanguageModel instance (e.g., openai("gpt-4"), anthropic("claude-3-5-sonnet"), etc.)'
+    );
+  }
+  return openai$1("gpt-4.1");
+};
+var isValidMastraLanguageModel = (model) => {
+  return model && typeof model === "object" && typeof model.modelId === "string" && typeof model.generate === "function";
+};
+var resolveTargetPath = (inputData, runtimeContext) => {
+  if (inputData.targetPath) {
+    return inputData.targetPath;
+  }
+  const contextPath = runtimeContext.get("targetPath");
+  if (contextPath) {
+    return contextPath;
+  }
+  const envRoot = process.env.MASTRA_PROJECT_ROOT?.trim();
+  if (envRoot) {
+    return envRoot;
+  }
+  const cwd = process.cwd();
+  const parent = dirname(cwd);
+  const grand = dirname(parent);
+  if (basename(cwd) === "output" && basename(parent) === ".mastra") {
+    return grand;
+  }
+  return cwd;
+};
 
 // src/defaults.ts
 var AgentBuilderDefaults = class _AgentBuilderDefaults {
@@ -944,7 +982,7 @@ export const mastra = new Mastra({
           path: z.string().describe("Directory path to list"),
           recursive: z.boolean().default(false).describe("List subdirectories recursively"),
           includeHidden: z.boolean().default(false).describe("Include hidden files and directories"),
-          pattern: z.string().optional().describe("Glob pattern to filter files"),
+          pattern: z.string().default("*").describe("Glob pattern to filter files"),
           maxDepth: z.number().default(10).describe("Maximum recursion depth"),
           includeMetadata: z.boolean().default(true).describe("Include file metadata")
         }),
@@ -1072,12 +1110,16 @@ export const mastra = new Mastra({
       }),
       replaceLines: createTool({
         id: "replace-lines",
-        description: "Replace specific line ranges in files with new content. Perfect for fixing multiline imports, function signatures, or other structured code.",
+        description: "Replace specific line ranges in files with new content. IMPORTANT: This tool replaces ENTIRE lines, not partial content within lines. Lines are 1-indexed.",
         inputSchema: z.object({
           filePath: z.string().describe("Path to the file to edit"),
-          startLine: z.number().describe("Starting line number to replace (1-indexed)"),
-          endLine: z.number().describe("Ending line number to replace (1-indexed, inclusive)"),
-          newContent: z.string().describe("New content to replace the lines with"),
+          startLine: z.number().describe("Starting line number to replace (1-indexed, inclusive). Count from the first line = 1"),
+          endLine: z.number().describe(
+            "Ending line number to replace (1-indexed, inclusive). To replace single line, use same number as startLine"
+          ),
+          newContent: z.string().describe(
+            'New content to replace the lines with. Use empty string "" to delete lines completely. For multiline content, include \\n characters'
+          ),
           createBackup: z.boolean().default(false).describe("Create backup file before editing")
         }),
         outputSchema: z.object({
@@ -1091,6 +1133,35 @@ export const mastra = new Mastra({
           return await _AgentBuilderDefaults.replaceLines({ ...context, projectPath });
         }
       }),
+      // File diagnostics tool to help debug line replacement issues
+      showFileLines: createTool({
+        id: "show-file-lines",
+        description: "Show specific lines from a file with line numbers. Useful for debugging before using replaceLines.",
+        inputSchema: z.object({
+          filePath: z.string().describe("Path to the file to examine"),
+          startLine: z.number().optional().describe("Starting line number to show (1-indexed). If not provided, shows all lines"),
+          endLine: z.number().optional().describe(
+            "Ending line number to show (1-indexed, inclusive). If not provided but startLine is, shows only that line"
+          ),
+          context: z.number().default(2).describe("Number of context lines to show before and after the range")
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          lines: z.array(
+            z.object({
+              lineNumber: z.number(),
+              content: z.string(),
+              isTarget: z.boolean().describe("Whether this line is in the target range")
+            })
+          ),
+          totalLines: z.number(),
+          message: z.string(),
+          error: z.string().optional()
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.showFileLines({ ...context, projectPath });
+        }
+      }),
       // Interactive Communication
       askClarification: createTool({
         id: "ask-clarification",
@@ -1168,11 +1239,13 @@ export const mastra = new Mastra({
       }),
       validateCode: createTool({
         id: "validate-code",
-        description: "Validates generated code through TypeScript compilation, ESLint, schema validation, and other checks",
+        description: "Validates code using a fast hybrid approach: syntax \u2192 semantic \u2192 lint. RECOMMENDED: Always provide specific files for optimal performance and accuracy.",
         inputSchema: z.object({
           projectPath: z.string().optional().describe("Path to the project to validate (defaults to current project)"),
-          validationType: z.array(z.enum(["types", "lint", "schemas", "tests", "build"])).describe("Types of validation to perform"),
-          files: z.array(z.string()).optional().describe("Specific files to validate (if not provided, validates entire project)")
+          validationType: z.array(z.enum(["types", "lint", "schemas", "tests", "build"])).describe('Types of validation to perform. Recommended: ["types", "lint"] for code quality'),
+          files: z.array(z.string()).optional().describe(
+            "RECOMMENDED: Specific files to validate (e.g., files you created/modified). Uses hybrid validation: fast syntax check \u2192 semantic types \u2192 ESLint. Without files, falls back to slower CLI validation."
+          )
         }),
         outputSchema: z.object({
           valid: z.boolean(),
@@ -1863,13 +1936,99 @@ export const mastra = new Mastra({
       }
     }
   }
+  // Cache for TypeScript program (lazily loaded)
+  static tsProgram = null;
+  static programProjectPath = null;
   /**
-   * Validate code using TypeScript, ESLint, and other tools
+   * Validate code using hybrid approach: syntax -> types -> lint
+   *
+   * BEST PRACTICES FOR CODING AGENTS:
+   *
+   * ✅ RECOMMENDED (Fast & Accurate):
+   * validateCode({
+   *   validationType: ['types', 'lint'],
+   *   files: ['src/workflows/my-workflow.ts', 'src/components/Button.tsx']
+   * })
+   *
+   * Performance: ~150ms
+   * - Syntax check (1ms) - catches 80% of issues instantly
+   * - Semantic validation (100ms) - full type checking with dependencies
+   * - ESLint (50ms) - style and best practices
+   * - Only shows errors from YOUR files
+   *
+   * ❌ AVOID (Slow & Noisy):
+   * validateCode({ validationType: ['types', 'lint'] }) // no files specified
+   *
+   * Performance: ~2000ms+
+   * - Full project CLI validation
+   * - Shows errors from all project files (confusing)
+   * - Much slower for coding agents
+   *
+   * @param projectPath - Project root directory (defaults to cwd)
+   * @param validationType - ['types', 'lint'] recommended for most use cases
+   * @param files - ALWAYS provide this for best performance
    */
   static async validateCode({
     projectPath,
     validationType,
     files
+  }) {
+    const errors = [];
+    const validationsPassed = [];
+    const validationsFailed = [];
+    const targetProjectPath = projectPath || process.cwd();
+    if (!files || files.length === 0) {
+      return this.validateCodeCLI({ projectPath, validationType });
+    }
+    for (const filePath of files) {
+      const absolutePath = isAbsolute(filePath) ? filePath : resolve(targetProjectPath, filePath);
+      try {
+        const fileContent = await readFile(absolutePath, "utf-8");
+        const fileResults = await this.validateSingleFileHybrid(
+          absolutePath,
+          fileContent,
+          targetProjectPath,
+          validationType
+        );
+        errors.push(...fileResults.errors);
+        for (const type of validationType) {
+          const hasErrors = fileResults.errors.some((e) => e.type === type && e.severity === "error");
+          if (hasErrors) {
+            if (!validationsFailed.includes(type)) validationsFailed.push(type);
+          } else {
+            if (!validationsPassed.includes(type)) validationsPassed.push(type);
+          }
+        }
+      } catch (error) {
+        errors.push({
+          type: "typescript",
+          severity: "error",
+          message: `Failed to read file ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+          file: filePath
+        });
+        validationsFailed.push("types");
+      }
+    }
+    const totalErrors = errors.filter((e) => e.severity === "error").length;
+    const totalWarnings = errors.filter((e) => e.severity === "warning").length;
+    const isValid = totalErrors === 0;
+    return {
+      valid: isValid,
+      errors,
+      summary: {
+        totalErrors,
+        totalWarnings,
+        validationsPassed,
+        validationsFailed
+      }
+    };
+  }
+  /**
+   * CLI-based validation for when no specific files are provided
+   */
+  static async validateCodeCLI({
+    projectPath,
+    validationType
   }) {
     const errors = [];
     const validationsPassed = [];
@@ -1877,8 +2036,7 @@ export const mastra = new Mastra({
     const execOptions = { cwd: projectPath };
     if (validationType.includes("types")) {
       try {
-        const fileArgs = files?.length ? files : [];
-        const args = ["tsc", "--noEmit", ...fileArgs];
+        const args = ["tsc", "--noEmit"];
         await execFile("npx", args, execOptions);
         validationsPassed.push("types");
       } catch (error) {
@@ -1900,8 +2058,7 @@ export const mastra = new Mastra({
     }
     if (validationType.includes("lint")) {
       try {
-        const fileArgs = files?.length ? files : ["."];
-        const eslintArgs = ["eslint", ...fileArgs, "--format", "json"];
+        const eslintArgs = ["eslint", "--format", "json"];
         const { stdout } = await execFile("npx", eslintArgs, execOptions);
         if (stdout) {
           const eslintResults = JSON.parse(stdout);
@@ -1950,6 +2107,187 @@ export const mastra = new Mastra({
       }
     };
   }
+  /**
+   * Hybrid validation for a single file
+   */
+  static async validateSingleFileHybrid(filePath, fileContent, projectPath, validationType) {
+    const errors = [];
+    if (validationType.includes("types")) {
+      const syntaxErrors = await this.validateSyntaxOnly(fileContent, filePath);
+      errors.push(...syntaxErrors);
+      if (syntaxErrors.length > 0) {
+        return { errors };
+      }
+      const typeErrors = await this.validateTypesSemantic(filePath, projectPath);
+      errors.push(...typeErrors);
+    }
+    if (validationType.includes("lint") && !errors.some((e) => e.severity === "error")) {
+      const lintErrors = await this.validateESLintSingle(filePath, projectPath);
+      errors.push(...lintErrors);
+    }
+    return { errors };
+  }
+  /**
+   * Fast syntax-only validation using TypeScript parser
+   */
+  static async validateSyntaxOnly(fileContent, fileName) {
+    const errors = [];
+    try {
+      const ts = await import('typescript');
+      const sourceFile = ts.createSourceFile(fileName, fileContent, ts.ScriptTarget.Latest, true);
+      const options = {
+        allowJs: true,
+        checkJs: false,
+        noEmit: true
+      };
+      const host = {
+        getSourceFile: (name) => name === fileName ? sourceFile : void 0,
+        writeFile: () => {
+        },
+        getCurrentDirectory: () => "",
+        getDirectories: () => [],
+        fileExists: (name) => name === fileName,
+        readFile: (name) => name === fileName ? fileContent : void 0,
+        getCanonicalFileName: (name) => name,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => "\n",
+        getDefaultLibFileName: () => "lib.d.ts"
+      };
+      const program = ts.createProgram([fileName], options, host);
+      const diagnostics = program.getSyntacticDiagnostics(sourceFile);
+      for (const diagnostic of diagnostics) {
+        if (diagnostic.start !== void 0) {
+          const position = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
+          errors.push({
+            type: "typescript",
+            severity: "error",
+            message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+            file: fileName,
+            line: position.line + 1,
+            column: position.character + 1
+          });
+        }
+      }
+    } catch (error) {
+      console.warn("TypeScript not available for syntax validation:", error);
+      const lines = fileContent.split("\n");
+      const commonErrors = [
+        { pattern: /\bimport\s+.*\s+from\s+['""][^'"]*$/, message: "Unterminated import statement" },
+        { pattern: /\{[^}]*$/, message: "Unclosed brace" },
+        { pattern: /\([^)]*$/, message: "Unclosed parenthesis" },
+        { pattern: /\[[^\]]*$/, message: "Unclosed bracket" }
+      ];
+      lines.forEach((line, index) => {
+        commonErrors.forEach(({ pattern, message }) => {
+          if (pattern.test(line)) {
+            errors.push({
+              type: "typescript",
+              severity: "error",
+              message,
+              file: fileName,
+              line: index + 1
+            });
+          }
+        });
+      });
+    }
+    return errors;
+  }
+  /**
+   * TypeScript semantic validation using incremental program
+   */
+  static async validateTypesSemantic(filePath, projectPath) {
+    const errors = [];
+    try {
+      const program = await this.getOrCreateTSProgram(projectPath);
+      if (!program) {
+        return errors;
+      }
+      const sourceFile = program.getSourceFile(filePath);
+      if (!sourceFile) {
+        return errors;
+      }
+      const diagnostics = [
+        ...program.getSemanticDiagnostics(sourceFile),
+        ...program.getSyntacticDiagnostics(sourceFile)
+      ];
+      const ts = await import('typescript');
+      for (const diagnostic of diagnostics) {
+        if (diagnostic.start !== void 0) {
+          const position = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
+          errors.push({
+            type: "typescript",
+            severity: diagnostic.category === ts.DiagnosticCategory.Warning ? "warning" : "error",
+            message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+            file: filePath,
+            line: position.line + 1,
+            column: position.character + 1
+          });
+        }
+      }
+    } catch (error) {
+      console.warn(`TypeScript semantic validation failed for ${filePath}:`, error);
+    }
+    return errors;
+  }
+  /**
+   * ESLint validation for a single file
+   */
+  static async validateESLintSingle(filePath, projectPath) {
+    const errors = [];
+    try {
+      const { stdout } = await execFile("npx", ["eslint", filePath, "--format", "json"], { cwd: projectPath });
+      if (stdout) {
+        const eslintResults = JSON.parse(stdout);
+        const eslintErrors = this.parseESLintErrors(eslintResults);
+        errors.push(...eslintErrors);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes('"filePath"') || errorMessage.includes("messages")) {
+        try {
+          const eslintResults = JSON.parse(errorMessage);
+          const eslintErrors = this.parseESLintErrors(eslintResults);
+          errors.push(...eslintErrors);
+        } catch {
+        }
+      }
+    }
+    return errors;
+  }
+  /**
+   * Get or create TypeScript program
+   */
+  static async getOrCreateTSProgram(projectPath) {
+    if (this.tsProgram && this.programProjectPath === projectPath) {
+      return this.tsProgram;
+    }
+    try {
+      const ts = await import('typescript');
+      const configPath = ts.findConfigFile(projectPath, ts.sys.fileExists, "tsconfig.json");
+      if (!configPath) {
+        return null;
+      }
+      const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+      if (configFile.error) {
+        return null;
+      }
+      const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, projectPath);
+      if (parsedConfig.errors.length > 0) {
+        return null;
+      }
+      this.tsProgram = ts.createProgram({
+        rootNames: parsedConfig.fileNames,
+        options: parsedConfig.options
+      });
+      this.programProjectPath = projectPath;
+      return this.tsProgram;
+    } catch (error) {
+      console.warn("Failed to create TypeScript program:", error);
+      return null;
+    }
+  }
+  // Note: Old filterTypeScriptErrors method removed in favor of hybrid validation approach
   /**
    * Parse ESLint errors from JSON output
    */
@@ -2364,10 +2702,17 @@ export const mastra = new Mastra({
       const fullPath = isAbsolute(filePath) ? filePath : join(projectPath, filePath);
       const content = await readFile(fullPath, "utf-8");
       const lines = content.split("\n");
-      if (startLine < 1 || endLine < 1 || startLine > lines.length || endLine > lines.length) {
+      if (startLine < 1 || endLine < 1) {
         return {
           success: false,
-          message: `Invalid line range: ${startLine}-${endLine}. File has ${lines.length} lines.`,
+          message: `Line numbers must be 1 or greater. Got startLine: ${startLine}, endLine: ${endLine}`,
+          error: "Invalid line range"
+        };
+      }
+      if (startLine > lines.length || endLine > lines.length) {
+        return {
+          success: false,
+          message: `Line range ${startLine}-${endLine} is out of bounds. File has ${lines.length} lines. Remember: lines are 1-indexed, so valid range is 1-${lines.length}.`,
           error: "Invalid line range"
         };
       }
@@ -2391,9 +2736,10 @@ export const mastra = new Mastra({
       const updatedContent = updatedLines.join("\n");
       await writeFile(fullPath, updatedContent, "utf-8");
       const linesReplaced = endLine - startLine + 1;
+      const newLineCount = newLines.length;
       return {
         success: true,
-        message: `Successfully replaced ${linesReplaced} lines (${startLine}-${endLine}) in ${filePath}`,
+        message: `Successfully replaced ${linesReplaced} lines (${startLine}-${endLine}) with ${newLineCount} new lines in ${filePath}`,
         linesReplaced,
         backup
       };
@@ -2405,6 +2751,51 @@ export const mastra = new Mastra({
       };
     }
   }
+  /**
+   * Show file lines with line numbers for debugging
+   */
+  static async showFileLines(context) {
+    const { filePath, startLine, endLine, context: contextLines = 2, projectPath = process.cwd() } = context;
+    try {
+      const fullPath = isAbsolute(filePath) ? filePath : join(projectPath, filePath);
+      const content = await readFile(fullPath, "utf-8");
+      const lines = content.split("\n");
+      let targetStart = startLine;
+      let targetEnd = endLine;
+      if (!targetStart) {
+        targetStart = 1;
+        targetEnd = lines.length;
+      } else if (!targetEnd) {
+        targetEnd = targetStart;
+      }
+      const displayStart = Math.max(1, targetStart - contextLines);
+      const displayEnd = Math.min(lines.length, targetEnd + contextLines);
+      const result = [];
+      for (let i = displayStart; i <= displayEnd; i++) {
+        const lineIndex = i - 1;
+        const isTarget = i >= targetStart && i <= targetEnd;
+        result.push({
+          lineNumber: i,
+          content: lineIndex < lines.length ? lines[lineIndex] ?? "" : "",
+          isTarget
+        });
+      }
+      return {
+        success: true,
+        lines: result,
+        totalLines: lines.length,
+        message: `Showing lines ${displayStart}-${displayEnd} of ${lines.length} total lines in ${filePath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        lines: [],
+        totalLines: 0,
+        message: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
   /**
    * Ask user for clarification
    */
@@ -2900,10 +3291,10 @@ var WriteToDiskProcessor = class extends MemoryProcessor {
     return messages;
   }
 };
-var resolveModel = (runtimeContext) => {
+var resolveModel2 = (runtimeContext) => {
   const modelFromContext = runtimeContext.get("model");
   if (modelFromContext) {
-    if (isValidMastraLanguageModel(modelFromContext)) {
+    if (isValidMastraLanguageModel2(modelFromContext)) {
       return modelFromContext;
     }
     throw new Error(
@@ -2912,7 +3303,7 @@ var resolveModel = (runtimeContext) => {
   }
   return openai("gpt-4.1");
 };
-var isValidMastraLanguageModel = (model) => {
+var isValidMastraLanguageModel2 = (model) => {
   return model && typeof model === "object" && typeof model.modelId === "string" && typeof model.generate === "function";
 };
 var cloneTemplateStep = createStep({
@@ -3003,7 +3394,7 @@ var discoverUnitsStep = createStep({
     const tools = await AgentBuilderDefaults.DEFAULT_TOOLS(templateDir);
     try {
       const agent = new Agent({
-        model: resolveModel(runtimeContext),
+        model: resolveModel2(runtimeContext),
         instructions: `You are an expert at analyzing Mastra projects.
 
 Your task is to scan the provided directory and identify all available units (agents, workflows, tools, MCP servers, networks).
@@ -3135,7 +3526,7 @@ var prepareBranchStep = createStep({
   inputSchema: PrepareBranchInputSchema,
   outputSchema: PrepareBranchResultSchema,
   execute: async ({ inputData, runtimeContext }) => {
-    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    const targetPath = resolveTargetPath(inputData, runtimeContext);
     try {
       const branchName = `feat/install-template-${inputData.slug}`;
       await gitCheckoutBranch(branchName, targetPath);
@@ -3162,7 +3553,7 @@ var packageMergeStep = createStep({
   execute: async ({ inputData, runtimeContext }) => {
     console.log("Package merge step starting...");
     const { slug, packageInfo } = inputData;
-    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    const targetPath = resolveTargetPath(inputData, runtimeContext);
     try {
       const targetPkgPath = join(targetPath, "package.json");
       let targetPkgRaw = "{}";
@@ -3238,7 +3629,7 @@ var installStep = createStep({
   outputSchema: InstallResultSchema,
   execute: async ({ inputData, runtimeContext }) => {
     console.log("Running install step...");
-    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    const targetPath = resolveTargetPath(inputData, runtimeContext);
     try {
       await spawnSWPM(targetPath, "install", []);
       const lock = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"].map((f) => join(targetPath, f)).find((f) => existsSync(f));
@@ -3267,7 +3658,7 @@ var programmaticFileCopyStep = createStep({
   execute: async ({ inputData, runtimeContext }) => {
     console.log("Programmatic file copy step starting...");
     const { orderedUnits, templateDir, commitSha, slug } = inputData;
-    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    const targetPath = resolveTargetPath(inputData, runtimeContext);
     try {
       const copiedFiles = [];
       const conflicts = [];
@@ -3346,7 +3737,7 @@ var programmaticFileCopyStep = createStep({
         const convertedFileName = namingConvention !== "unknown" ? convertNaming(baseId + fileExtension, namingConvention) : baseId + fileExtension;
         const targetFile = resolve(targetPath, targetDir, convertedFileName);
         if (existsSync(targetFile)) {
-          const strategy = determineConflictStrategy();
+          const strategy = determineConflictStrategy(unit, targetFile);
           console.log(`File exists: ${convertedFileName}, using strategy: ${strategy}`);
           switch (strategy) {
             case "skip":
@@ -3537,7 +3928,7 @@ var intelligentMergeStep = createStep({
   execute: async ({ inputData, runtimeContext }) => {
     console.log("Intelligent merge step starting...");
     const { conflicts, copiedFiles, commitSha, slug, templateDir, branchName } = inputData;
-    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    const targetPath = resolveTargetPath(inputData, runtimeContext);
     try {
       const copyFileTool = createTool({
         id: "copy-file",
@@ -3576,7 +3967,7 @@ var intelligentMergeStep = createStep({
       const agentBuilder = new AgentBuilder({
         projectPath: targetPath,
         mode: "template",
-        model: resolveModel(runtimeContext),
+        model: resolveModel2(runtimeContext),
         instructions: `
 You are an expert at integrating Mastra template components into existing projects.
 
@@ -3798,7 +4189,7 @@ var validationAndFixStep = createStep({
   execute: async ({ inputData, runtimeContext }) => {
     console.log("Validation and fix step starting...");
     const { commitSha, slug, orderedUnits, templateDir, copiedFiles, conflictsResolved, maxIterations = 5 } = inputData;
-    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    const targetPath = resolveTargetPath(inputData, runtimeContext);
     const hasChanges = copiedFiles.length > 0 || conflictsResolved && conflictsResolved.length > 0;
     if (!hasChanges) {
       console.log("\u23ED\uFE0F Skipping validation - no files copied or conflicts resolved");
@@ -3927,7 +4318,7 @@ INTEGRATED UNITS:
 ${JSON.stringify(orderedUnits, null, 2)}
 
 Be thorough and methodical. Always use listDirectory to verify actual file existence before fixing imports.`,
-        model: resolveModel(runtimeContext),
+        model: resolveModel2(runtimeContext),
         tools: {
           validateCode: allTools.validateCode,
           readFile: allTools.readFile,
@@ -4217,6 +4608,1389 @@ var determineConflictStrategy = (_unit, _targetFile) => {
 var shouldAbortWorkflow = (stepResult) => {
   return stepResult?.success === false || stepResult?.error;
 };
+var TaskSchema = z.array(
+  z.object({
+    id: z.string().describe("Unique task ID using kebab-case"),
+    content: z.string().describe("Specific, actionable task description"),
+    status: z.enum(["pending", "in_progress", "completed", "blocked"]).default("pending"),
+    priority: z.enum(["high", "medium", "low"]).describe("Task priority"),
+    dependencies: z.array(z.string()).optional().describe("IDs of tasks this depends on"),
+    notes: z.string().describe("Detailed implementation notes and specifics")
+  })
+);
+var QuestionSchema = z.array(
+  z.object({
+    id: z.string().describe("Unique question ID"),
+    question: z.string().describe("Clear, specific question for the user"),
+    type: z.enum(["choice", "text", "boolean"]).describe("Type of answer expected"),
+    options: z.array(z.string()).optional().describe("Options for choice questions"),
+    context: z.string().optional().describe("Additional context or explanation")
+  })
+);
+var PlanningIterationResultSchema = z.object({
+  success: z.boolean(),
+  tasks: TaskSchema,
+  questions: QuestionSchema,
+  reasoning: z.string(),
+  planComplete: z.boolean(),
+  message: z.string(),
+  error: z.string().optional(),
+  allPreviousQuestions: z.array(z.any()).optional(),
+  allPreviousAnswers: z.record(z.string()).optional()
+});
+
+// src/workflows/task-planning/prompts.ts
+var taskPlanningPrompts = {
+  planningAgent: {
+    instructions: (context) => `You are a Mastra workflow planning expert. Your task is to create a detailed, executable task plan.
+
+PLANNING RESPONSIBILITIES:
+1. **Analyze Requirements**: Review the user's description and requirements thoroughly
+2. **Identify Decision Points**: Find any choices that require user input (email providers, databases, APIs, etc.)
+3. **Create Specific Tasks**: Generate concrete, actionable tasks with clear implementation notes
+4. **Ask Clarifying Questions**: If any decisions are unclear, formulate specific questions for the user 
+- do not ask about package managers
+- Assume the user is going to use zod for validation
+- You do not need to ask questions if you have none
+- NEVER ask questions that have already been answered before
+5. **Incorporate Feedback**: Use any previous answers or feedback to refine the plan
+
+${context.storedQAPairs.length > 0 ? `PREVIOUS QUESTION-ANSWER PAIRS (${context.storedQAPairs.length} total):
+${context.storedQAPairs.map(
+      (pair, index) => `${index + 1}. Q: ${pair.question.question}
+   A: ${pair.answer || "NOT ANSWERED YET"}
+   Type: ${pair.question.type}
+   Asked: ${pair.askedAt}
+   ${pair.answer ? `Answered: ${pair.answeredAt}` : ""}`
+    ).join("\n\n")}
+
+IMPORTANT: DO NOT ASK ANY QUESTIONS THAT HAVE ALREADY BEEN ASKED!` : ""}
+
+Based on the context and any user answers, create or refine the task plan.`,
+    refinementPrompt: (context) => `Refine the existing task plan based on all user answers collected so far. 
+
+ANSWERED QUESTIONS AND RESPONSES:
+${context.storedQAPairs.filter((pair) => pair.answer).map(
+      (pair, index) => `${index + 1}. Q: ${pair.question.question}
+   A: ${pair.answer}
+   Context: ${pair.question.context || "None"}`
+    ).join("\n\n")}
+
+REQUIREMENTS:
+- Action: ${context.action}
+- Workflow Name: ${context.workflowName || "To be determined"}
+- Description: ${context.description || "Not specified"}
+- Requirements: ${context.requirements || "Not specified"}
+
+PROJECT CONTEXT:
+- Discovered Workflows: ${JSON.stringify(context.discoveredWorkflows, null, 2)}
+- Project Structure: ${JSON.stringify(context.projectStructure, null, 2)}
+- Research: ${JSON.stringify(context.research, null, 2)}
+
+${context.hasTaskFeedback ? `
+USER FEEDBACK ON PREVIOUS TASK LIST:
+${context.userAnswers?.taskFeedback}
+
+PLEASE INCORPORATE THIS FEEDBACK INTO THE REFINED TASK LIST.` : ""}
+
+Refine the task list and determine if any additional questions are needed.`,
+    initialPrompt: (context) => `Create an initial task plan for ${context.action}ing a Mastra workflow.
+
+REQUIREMENTS:
+- Action: ${context.action}
+- Workflow Name: ${context.workflowName || "To be determined"}
+- Description: ${context.description || "Not specified"}  
+- Requirements: ${context.requirements || "Not specified"}
+
+PROJECT CONTEXT:
+- Discovered Workflows: ${JSON.stringify(context.discoveredWorkflows, null, 2)}
+- Project Structure: ${JSON.stringify(context.projectStructure, null, 2)}
+- Research: ${JSON.stringify(context.research, null, 2)}
+
+Create specific tasks and identify any questions that need user clarification.`
+  },
+  taskApproval: {
+    message: (questionsCount) => `Please answer ${questionsCount} question(s) to finalize the workflow plan:`,
+    approvalMessage: (tasksCount) => `Please review and approve the ${tasksCount} task(s) for execution:`
+  }
+};
+var WorkflowBuilderInputSchema = z.object({
+  workflowName: z.string().optional().describe("Name of the workflow to create or edit"),
+  action: z.enum(["create", "edit"]).describe("Action to perform: create new or edit existing workflow"),
+  description: z.string().optional().describe("Description of what the workflow should do"),
+  requirements: z.string().optional().describe("Detailed requirements for the workflow"),
+  projectPath: z.string().optional().describe("Path to the Mastra project (defaults to current directory)")
+});
+var DiscoveredWorkflowSchema = z.object({
+  name: z.string(),
+  file: z.string(),
+  description: z.string().optional(),
+  inputSchema: z.any().optional(),
+  outputSchema: z.any().optional(),
+  steps: z.array(z.string()).optional()
+});
+var WorkflowDiscoveryResultSchema = z.object({
+  success: z.boolean(),
+  workflows: z.array(DiscoveredWorkflowSchema),
+  mastraIndexExists: z.boolean(),
+  message: z.string(),
+  error: z.string().optional()
+});
+var ProjectDiscoveryResultSchema = z.object({
+  success: z.boolean(),
+  structure: z.object({
+    hasWorkflowsDir: z.boolean(),
+    hasAgentsDir: z.boolean(),
+    hasToolsDir: z.boolean(),
+    hasMastraIndex: z.boolean(),
+    existingWorkflows: z.array(z.string()),
+    existingAgents: z.array(z.string()),
+    existingTools: z.array(z.string())
+  }),
+  dependencies: z.record(z.string()),
+  message: z.string(),
+  error: z.string().optional()
+});
+var WorkflowResearchResultSchema = z.object({
+  success: z.boolean(),
+  documentation: z.object({
+    workflowPatterns: z.array(z.string()),
+    stepExamples: z.array(z.string()),
+    bestPractices: z.array(z.string())
+  }),
+  webResources: z.array(
+    z.object({
+      title: z.string(),
+      url: z.string(),
+      snippet: z.string(),
+      relevance: z.number()
+    })
+  ),
+  message: z.string(),
+  error: z.string().optional()
+});
+var TaskManagementResultSchema = z.object({
+  success: z.boolean(),
+  tasks: TaskSchema,
+  message: z.string(),
+  error: z.string().optional()
+});
+var TaskExecutionInputSchema = z.object({
+  action: z.enum(["create", "edit"]),
+  workflowName: z.string().optional(),
+  description: z.string().optional(),
+  requirements: z.string().optional(),
+  tasks: TaskSchema,
+  discoveredWorkflows: z.array(z.any()),
+  projectStructure: z.any(),
+  research: z.any(),
+  projectPath: z.string().optional()
+});
+var TaskExecutionSuspendSchema = z.object({
+  questions: QuestionSchema,
+  currentProgress: z.string(),
+  completedTasks: z.array(z.string()),
+  message: z.string()
+});
+var TaskExecutionResumeSchema = z.object({
+  answers: z.array(
+    z.object({
+      questionId: z.string(),
+      answer: z.string()
+    })
+  )
+});
+var TaskExecutionResultSchema = z.object({
+  success: z.boolean(),
+  filesModified: z.array(z.string()),
+  validationResults: z.object({
+    passed: z.boolean(),
+    errors: z.array(z.string()),
+    warnings: z.array(z.string())
+  }),
+  completedTasks: z.array(z.string()),
+  message: z.string(),
+  error: z.string().optional()
+});
+z.object({
+  questions: QuestionSchema
+});
+z.object({
+  answers: z.record(z.string()),
+  hasAnswers: z.boolean()
+});
+var WorkflowBuilderResultSchema = z.object({
+  success: z.boolean(),
+  action: z.enum(["create", "edit"]),
+  workflowName: z.string().optional(),
+  workflowFile: z.string().optional(),
+  discovery: WorkflowDiscoveryResultSchema.optional(),
+  projectStructure: ProjectDiscoveryResultSchema.optional(),
+  research: WorkflowResearchResultSchema.optional(),
+  planning: PlanningIterationResultSchema.optional(),
+  taskManagement: TaskManagementResultSchema.optional(),
+  execution: TaskExecutionResultSchema.optional(),
+  needsUserInput: z.boolean().optional(),
+  questions: QuestionSchema.optional(),
+  message: z.string(),
+  nextSteps: z.array(z.string()).optional(),
+  error: z.string().optional()
+});
+var TaskExecutionIterationInputSchema = (taskLength) => z.object({
+  status: z.enum(["in_progress", "completed", "needs_clarification"]).describe('Status - only use "completed" when ALL remaining tasks are finished'),
+  progress: z.string().describe("Current progress description"),
+  completedTasks: z.array(z.string()).describe("List of ALL completed task IDs (including previously completed ones)"),
+  totalTasksRequired: z.number().describe(`Total number of tasks that must be completed (should be ${taskLength})`),
+  tasksRemaining: z.array(z.string()).describe("List of task IDs that still need to be completed"),
+  filesModified: z.array(z.string()).describe("List of files that were created or modified - use these exact paths for validateCode tool"),
+  questions: QuestionSchema.optional().describe("Questions for user if clarification is needed"),
+  message: z.string().describe("Summary of work completed or current status"),
+  error: z.string().optional().describe("Any errors encountered")
+});
+
+// src/workflows/task-planning/schema.ts
+var PlanningIterationInputSchema = z.object({
+  action: z.enum(["create", "edit"]),
+  workflowName: z.string().optional(),
+  description: z.string().optional(),
+  requirements: z.string().optional(),
+  discoveredWorkflows: z.array(DiscoveredWorkflowSchema),
+  projectStructure: ProjectDiscoveryResultSchema,
+  research: WorkflowResearchResultSchema,
+  userAnswers: z.record(z.string()).optional()
+});
+var PlanningIterationSuspendSchema = z.object({
+  questions: QuestionSchema,
+  message: z.string(),
+  currentPlan: z.object({
+    tasks: TaskSchema,
+    reasoning: z.string()
+  })
+});
+var PlanningIterationResumeSchema = z.object({
+  answers: z.record(z.string())
+});
+var PlanningAgentOutputSchema = z.object({
+  tasks: TaskSchema,
+  questions: QuestionSchema.optional(),
+  reasoning: z.string().describe("Explanation of the plan and any questions"),
+  planComplete: z.boolean().describe("Whether the plan is ready for execution (no more questions)")
+});
+var TaskApprovalOutputSchema = z.object({
+  approved: z.boolean(),
+  tasks: TaskSchema,
+  message: z.string(),
+  userFeedback: z.string().optional()
+});
+var TaskApprovalSuspendSchema = z.object({
+  taskList: TaskSchema,
+  summary: z.string(),
+  message: z.string()
+});
+var TaskApprovalResumeSchema = z.object({
+  approved: z.boolean(),
+  modifications: z.string().optional()
+});
+
+// src/workflows/task-planning/task-planning.ts
+var planningIterationStep = createStep$1({
+  id: "planning-iteration",
+  description: "Create or refine task plan with user input",
+  inputSchema: PlanningIterationInputSchema,
+  outputSchema: PlanningIterationResultSchema,
+  suspendSchema: PlanningIterationSuspendSchema,
+  resumeSchema: PlanningIterationResumeSchema,
+  execute: async ({ inputData, resumeData, suspend, runtimeContext }) => {
+    const {
+      action,
+      workflowName,
+      description,
+      requirements,
+      discoveredWorkflows,
+      projectStructure,
+      research,
+      userAnswers
+    } = inputData;
+    console.log("Starting planning iteration...");
+    const qaKey = "workflow-builder-qa";
+    let storedQAPairs = runtimeContext.get(qaKey) || [];
+    const newAnswers = { ...userAnswers || {}, ...resumeData?.answers || {} };
+    console.log("before", storedQAPairs);
+    console.log("newAnswers", newAnswers);
+    if (Object.keys(newAnswers).length > 0) {
+      storedQAPairs = storedQAPairs.map((pair) => {
+        if (newAnswers[pair.question.id]) {
+          return {
+            ...pair,
+            answer: newAnswers[pair.question.id] || null,
+            answeredAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        return pair;
+      });
+      runtimeContext.set(qaKey, storedQAPairs);
+    }
+    console.log("after", storedQAPairs);
+    console.log(
+      `Current Q&A state: ${storedQAPairs.length} question-answer pairs, ${storedQAPairs.filter((p) => p.answer).length} answered`
+    );
+    try {
+      const planningAgent = new Agent$1({
+        model: resolveModel(runtimeContext),
+        instructions: taskPlanningPrompts.planningAgent.instructions({
+          storedQAPairs
+        }),
+        name: "Workflow Planning Agent"
+        // tools: filteredMcpTools,
+      });
+      const hasTaskFeedback = Boolean(userAnswers && userAnswers.taskFeedback);
+      const planningPrompt = storedQAPairs.some((pair) => pair.answer) ? taskPlanningPrompts.planningAgent.refinementPrompt({
+        action,
+        workflowName,
+        description,
+        requirements,
+        discoveredWorkflows,
+        projectStructure,
+        research,
+        storedQAPairs,
+        hasTaskFeedback,
+        userAnswers
+      }) : taskPlanningPrompts.planningAgent.initialPrompt({
+        action,
+        workflowName,
+        description,
+        requirements,
+        discoveredWorkflows,
+        projectStructure,
+        research
+      });
+      const result = await planningAgent.generateVNext(planningPrompt, {
+        output: PlanningAgentOutputSchema
+        // maxSteps: 15,
+      });
+      const planResult = await result.object;
+      if (!planResult) {
+        return {
+          tasks: [],
+          success: false,
+          questions: [],
+          reasoning: "Planning agent failed to generate a valid response",
+          planComplete: false,
+          message: "Planning failed"
+        };
+      }
+      if (planResult.questions && planResult.questions.length > 0 && !planResult.planComplete) {
+        console.log(`Planning needs user clarification: ${planResult.questions.length} questions`);
+        console.log(planResult.questions);
+        const newQAPairs = planResult.questions.map((question) => ({
+          question,
+          answer: null,
+          askedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          answeredAt: null
+        }));
+        storedQAPairs = [...storedQAPairs, ...newQAPairs];
+        runtimeContext.set(qaKey, storedQAPairs);
+        console.log(
+          `Updated Q&A state: ${storedQAPairs.length} total question-answer pairs, ${storedQAPairs.filter((p) => p.answer).length} answered`
+        );
+        return suspend({
+          questions: planResult.questions,
+          message: taskPlanningPrompts.taskApproval.message(planResult.questions.length),
+          currentPlan: {
+            tasks: planResult.tasks,
+            reasoning: planResult.reasoning
+          }
+        });
+      }
+      console.log(`Planning complete with ${planResult.tasks.length} tasks`);
+      runtimeContext.set(qaKey, storedQAPairs);
+      console.log(
+        `Final Q&A state: ${storedQAPairs.length} total question-answer pairs, ${storedQAPairs.filter((p) => p.answer).length} answered`
+      );
+      return {
+        tasks: planResult.tasks,
+        success: true,
+        questions: [],
+        reasoning: planResult.reasoning,
+        planComplete: true,
+        message: `Successfully created ${planResult.tasks.length} tasks`,
+        allPreviousQuestions: storedQAPairs.map((pair) => pair.question),
+        allPreviousAnswers: Object.fromEntries(
+          storedQAPairs.filter((pair) => pair.answer).map((pair) => [pair.question.id, pair.answer])
+        )
+      };
+    } catch (error) {
+      console.error("Planning iteration failed:", error);
+      return {
+        tasks: [],
+        success: false,
+        questions: [],
+        reasoning: `Planning failed: ${error instanceof Error ? error.message : String(error)}`,
+        planComplete: false,
+        message: "Planning iteration failed",
+        error: error instanceof Error ? error.message : String(error),
+        allPreviousQuestions: storedQAPairs.map((pair) => pair.question),
+        allPreviousAnswers: Object.fromEntries(
+          storedQAPairs.filter((pair) => pair.answer).map((pair) => [pair.question.id, pair.answer])
+        )
+      };
+    }
+  }
+});
+var taskApprovalStep = createStep$1({
+  id: "task-approval",
+  description: "Get user approval for the final task list",
+  inputSchema: PlanningIterationResultSchema,
+  outputSchema: TaskApprovalOutputSchema,
+  suspendSchema: TaskApprovalSuspendSchema,
+  resumeSchema: TaskApprovalResumeSchema,
+  execute: async ({ inputData, resumeData, suspend }) => {
+    const { tasks } = inputData;
+    if (!resumeData?.approved && resumeData?.approved !== false) {
+      console.log(`Requesting user approval for ${tasks.length} tasks`);
+      const summary = `Task List for Approval:
+
+${tasks.length} tasks planned:
+${tasks.map((task, i) => `${i + 1}. [${task.priority.toUpperCase()}] ${task.content}${task.dependencies?.length ? ` (depends on: ${task.dependencies.join(", ")})` : ""}
+   Notes: ${task.notes || "None"}`).join("\n")}`;
+      return suspend({
+        taskList: tasks,
+        summary,
+        message: taskPlanningPrompts.taskApproval.approvalMessage(tasks.length)
+      });
+    }
+    if (resumeData.approved) {
+      console.log("Task list approved by user");
+      return {
+        approved: true,
+        tasks,
+        message: "Task list approved, ready for execution"
+      };
+    } else {
+      console.log("Task list rejected by user");
+      return {
+        approved: false,
+        tasks,
+        message: "Task list rejected",
+        userFeedback: resumeData.modifications
+      };
+    }
+  }
+});
+var planningAndApprovalWorkflow = createWorkflow$1({
+  id: "planning-and-approval",
+  description: "Handle iterative planning with questions and task list approval",
+  inputSchema: PlanningIterationInputSchema,
+  outputSchema: TaskApprovalOutputSchema,
+  steps: [planningIterationStep, taskApprovalStep]
+}).dountil(planningIterationStep, async ({ inputData }) => {
+  console.log(`Sub-workflow planning check: planComplete=${inputData.planComplete}`);
+  return inputData.planComplete === true;
+}).map(async ({ inputData }) => {
+  return {
+    tasks: inputData.tasks || [],
+    success: inputData.success || false,
+    questions: inputData.questions || [],
+    reasoning: inputData.reasoning || "",
+    planComplete: inputData.planComplete || false,
+    message: inputData.message || ""
+  };
+}).then(taskApprovalStep).commit();
+
+// src/workflows/workflow-builder/prompts.ts
+var workflowResearch = `
+## \u{1F50D} **COMPREHENSIVE MASTRA WORKFLOW RESEARCH SUMMARY**
+
+Based on extensive research of Mastra documentation and examples, here's essential information for building effective Mastra workflows:
+
+### **\u{1F4CB} WORKFLOW FUNDAMENTALS**
+
+**Core Components:**
+- **\`createWorkflow()\`**: Main factory function that creates workflow instances
+- **\`createStep()\`**: Creates individual workflow steps with typed inputs/outputs  
+- **\`.commit()\`**: Finalizes workflow definition (REQUIRED to make workflows executable)
+- **Zod schemas**: Used for strict input/output typing and validation
+
+**Basic Structure:**
+\`\`\`typescript
+import { createWorkflow, createStep } from "@mastra/core/workflows";
+import { z } from "zod";
+
+const workflow = createWorkflow({
+  id: "unique-workflow-id",           // Required: kebab-case recommended
+  description: "What this workflow does", // Optional but recommended
+  inputSchema: z.object({...}),       // Required: Defines workflow inputs
+  outputSchema: z.object({...})       // Required: Defines final outputs
+})
+  .then(step1)                       // Chain steps sequentially
+  .then(step2)
+  .commit();                         // CRITICAL: Makes workflow executable
+\`\`\`
+
+### **\u{1F527} STEP CREATION PATTERNS**
+
+**Standard Step Definition:**
+\`\`\`typescript
+const myStep = createStep({
+  id: "step-id",                     // Required: unique identifier
+  description: "Step description",    // Recommended for clarity
+  inputSchema: z.object({...}),       // Required: input validation
+  outputSchema: z.object({...}),      // Required: output validation
+  execute: async ({ inputData, mastra, getStepResult, getInitData }) => {
+    // Step logic here
+    return { /* matches outputSchema */ };
+  }
+});
+\`\`\`
+
+**Execute Function Parameters:**
+- \`inputData\`: Validated input matching inputSchema
+- \`mastra\`: Access to Mastra instance (agents, tools, other workflows)
+- \`getStepResult(stepInstance)\`: Get results from previous steps
+- \`getInitData()\`: Access original workflow input data
+- \`runtimeContext\`: Runtime dependency injection context
+- \`runCount\`: Number of times this step has run (useful for retries)
+
+### **\u{1F504} CONTROL FLOW METHODS**
+
+**Sequential Execution:**
+- \`.then(step)\`: Execute steps one after another
+- Data flows automatically if schemas match
+
+**Parallel Execution:**
+- \`.parallel([step1, step2])\`: Run steps simultaneously
+- All parallel steps complete before continuing
+
+**Conditional Logic:**
+- \`.branch([[condition, step], [condition, step]])\`: Execute different steps based on conditions
+- Conditions evaluated sequentially, matching steps run in parallel
+
+**Loops:**
+- \`.dountil(step, condition)\`: Repeat until condition becomes true
+- \`.dowhile(step, condition)\`: Repeat while condition is true  
+- \`.foreach(step, {concurrency: N})\`: Execute step for each array item
+
+**Data Transformation:**
+- \`.map(({ inputData, getStepResult, getInitData }) => transformedData)\`: Transform data between steps
+
+### **\u23F8\uFE0F SUSPEND & RESUME CAPABILITIES**
+
+**For Human-in-the-Loop Workflows:**
+\`\`\`typescript
+const userInputStep = createStep({
+  id: "user-input",
+  suspendSchema: z.object({}),        // Schema for suspension payload
+  resumeSchema: z.object({            // Schema for resume data
+    userResponse: z.string()
+  }),
+  execute: async ({ resumeData, suspend }) => {
+    if (!resumeData?.userResponse) {
+      await suspend({});  // Pause workflow
+      return { response: "" };
+    }
+    return { response: resumeData.userResponse };
+  }
+});
+\`\`\`
+
+**Resume Workflow:**
+\`\`\`typescript
+const result = await run.start({ inputData: {...} });
+if (result.status === "suspended") {
+  await run.resume({
+    step: result.suspended[0],        // Or specific step ID
+    resumeData: { userResponse: "answer" }
+  });
+}
+\`\`\`
+
+### **\u{1F6E0}\uFE0F INTEGRATING AGENTS & TOOLS**
+
+**Using Agents in Steps:**
+\`\`\`typescript
+// Method 1: Agent as step
+const agentStep = createStep(myAgent);
+
+// Method 2: Call agent in execute function
+const step = createStep({
+  execute: async ({ inputData }) => {
+    const result = await myAgent.generate(prompt);
+    return { output: result.text };
+  }
+});
+\`\`\`
+
+**Using Tools in Steps:**
+\`\`\`typescript
+// Method 1: Tool as step  
+const toolStep = createStep(myTool);
+
+// Method 2: Call tool in execute function
+const step = createStep({
+  execute: async ({ inputData, runtimeContext }) => {
+    const result = await myTool.execute({
+      context: inputData,
+      runtimeContext
+    });
+    return result;
+  }
+});
+\`\`\`
+
+### **\u{1F5C2}\uFE0F PROJECT ORGANIZATION PATTERNS**
+
+**MANDATORY Workflow Organization:**
+Each workflow MUST be organized in its own dedicated folder with separated concerns:
+
+\`\`\`
+src/mastra/workflows/
+\u251C\u2500\u2500 my-workflow-name/         # Kebab-case folder name
+\u2502   \u251C\u2500\u2500 types.ts             # All Zod schemas and TypeScript types
+\u2502   \u251C\u2500\u2500 steps.ts             # All individual step definitions
+\u2502   \u251C\u2500\u2500 workflow.ts          # Main workflow composition and export
+\u2502   \u2514\u2500\u2500 utils.ts             # Helper functions (if needed)
+\u251C\u2500\u2500 another-workflow/
+\u2502   \u251C\u2500\u2500 types.ts
+\u2502   \u251C\u2500\u2500 steps.ts
+\u2502   \u251C\u2500\u2500 workflow.ts
+\u2502   \u2514\u2500\u2500 utils.ts
+\u2514\u2500\u2500 index.ts                 # Export all workflows
+\`\`\`
+
+**CRITICAL File Organization Rules:**
+- **ALWAYS create a dedicated folder** for each workflow
+- **Folder names MUST be kebab-case** version of workflow name
+- **types.ts**: Define all input/output schemas, validation types, and interfaces
+- **steps.ts**: Create all individual step definitions using createStep()
+- **workflow.ts**: Compose steps into workflow using createWorkflow() and export the final workflow
+- **utils.ts**: Any helper functions, constants, or utilities (create only if needed)
+- **NEVER put everything in one file** - always separate concerns properly
+
+**Workflow Registration:**
+\`\`\`typescript
+// src/mastra/index.ts
+export const mastra = new Mastra({
+  workflows: {
+    sendEmailWorkflow,      // Use camelCase for keys
+    dataProcessingWorkflow
+  },
+  storage: new LibSQLStore({ url: 'file:./mastra.db' }), // Required for suspend/resume
+});
+\`\`\`
+
+### **\u{1F4E6} ESSENTIAL DEPENDENCIES**
+
+**Required Packages:**
+\`\`\`json
+{
+  "dependencies": {
+    "@mastra/core": "latest",
+    "zod": "^3.25.67"
+  }
+}
+\`\`\`
+
+**Additional Packages (as needed):**
+- \`@mastra/libsql\`: For workflow state persistence
+- \`@ai-sdk/openai\`: For AI model integration
+- \`ai\`: For AI SDK functionality
+
+### **\u2705 WORKFLOW BEST PRACTICES**
+
+**Schema Design:**
+- Use descriptive property names in schemas
+- Make schemas as specific as possible (avoid \`z.any()\`)
+- Include validation for required business logic
+
+**Error Handling:**
+- Use \`try/catch\` blocks in step execute functions
+- Return meaningful error messages
+- Consider using \`bail()\` for early successful exits
+
+**Step Organization:**
+- Keep steps focused on single responsibilities
+- Use descriptive step IDs (kebab-case recommended)
+- Create reusable steps for common operations
+
+**Data Flow:**
+- Use \`.map()\` when schemas don't align between steps
+- Access previous step results with \`getStepResult(stepInstance)\`
+- Use \`getInitData()\` to access original workflow input
+
+### **\u{1F680} EXECUTION PATTERNS**
+
+**Running Workflows:**
+\`\`\`typescript
+// Create and start run
+const run = await workflow.createRunAsync();
+const result = await run.start({ inputData: {...} });
+
+// Stream execution for real-time monitoring
+const stream = await run.streamVNext({ inputData: {...} });
+for await (const chunk of stream) {
+  console.log(chunk);
+}
+
+// Watch for events
+run.watch((event) => console.log(event));
+\`\`\`
+
+**Workflow Status Types:**
+- \`"success"\`: Completed successfully
+- \`"suspended"\`: Paused awaiting input
+- \`"failed"\`: Encountered error
+
+### **\u{1F517} ADVANCED FEATURES**
+
+**Nested Workflows:**
+- Use workflows as steps: \`.then(otherWorkflow)\`
+- Enable complex workflow composition
+
+**Runtime Context:**
+- Pass shared data across all steps
+- Enable dependency injection patterns
+
+**Streaming & Events:**
+- Real-time workflow monitoring
+- Integration with external event systems
+
+**Cloning:**
+- \`cloneWorkflow(original, {id: "new-id"})\`: Reuse workflow structure
+- \`cloneStep(original, {id: "new-id"})\`: Reuse step logic
+
+This comprehensive research provides the foundation for creating robust, maintainable Mastra workflows with proper typing, error handling, and architectural patterns.
+`;
+var workflowBuilderPrompts = {
+  researchAgent: {
+    instructions: `You are a Mastra workflow research expert. Your task is to gather relevant information about creating Mastra workflows.
+
+RESEARCH OBJECTIVES:
+1. **Core Concepts**: Understand how Mastra workflows work
+2. **Best Practices**: Learn workflow patterns and conventions  
+3. **Code Examples**: Find relevant implementation examples
+4. **Technical Details**: Understand schemas, steps, and configuration
+
+Use the available documentation and examples tools to gather comprehensive information about Mastra workflows.`,
+    prompt: (context) => `Research everything about Mastra workflows to help create or edit them effectively.
+
+PROJECT CONTEXT:
+- Project Structure: ${JSON.stringify(context.projectStructure, null, 2)}
+- Dependencies: ${JSON.stringify(context.dependencies, null, 2)}
+- Has Workflows Directory: ${context.hasWorkflowsDir}
+
+Focus on:
+1. How to create workflows using createWorkflow()
+2. How to create and chain workflow steps
+3. Best practices for workflow organization
+4. Common workflow patterns and examples
+5. Schema definitions and types
+6. Error handling and debugging
+
+Use the docs and examples tools to gather comprehensive information.`
+  },
+  executionAgent: {
+    instructions: (context) => `You are executing a workflow ${context.action} task for: "${context.workflowName}"
+
+CRITICAL WORKFLOW EXECUTION REQUIREMENTS:
+1. **EXPLORE PROJECT STRUCTURE FIRST**: Use listDirectory and readFile tools to understand the existing project layout, folder structure, and conventions before creating any files
+2. **FOLLOW PROJECT CONVENTIONS**: Look at existing workflows, agents, and file structures to understand where new files should be placed (typically src/mastra/workflows/, src/mastra/agents/, etc.)
+3. **USE PRE-LOADED TASK LIST**: Your task list has been pre-populated in the taskManager tool. Use taskManager with action 'list' to see all tasks, and action 'update' to mark progress
+4. **COMPLETE EVERY SINGLE TASK**: You MUST complete ALL ${context.tasksLength} tasks that are already in the taskManager. Do not stop until every task is marked as 'completed'
+5. **Follow Task Dependencies**: Execute tasks in the correct order, respecting dependencies
+6. **Request User Input When Needed**: If you encounter choices (like email providers, databases, etc.) that require user decision, return questions for clarification
+7. **STRICT WORKFLOW ORGANIZATION**: When creating or editing workflows, you MUST follow this exact structure
+
+MANDATORY WORKFLOW FOLDER STRUCTURE:
+When ${context.action === "create" ? "creating a new workflow" : "editing a workflow"}, you MUST organize files as follows:
+
+\u{1F4C1} src/mastra/workflows/${context.workflowName?.toLowerCase().replace(/[^a-z0-9]/g, "-") || "new-workflow"}/
+\u251C\u2500\u2500 \u{1F4C4} types.ts          # All Zod schemas and TypeScript types
+\u251C\u2500\u2500 \u{1F4C4} steps.ts          # All individual step definitions  
+\u251C\u2500\u2500 \u{1F4C4} workflow.ts       # Main workflow composition and export
+\u2514\u2500\u2500 \u{1F4C4} utils.ts          # Helper functions (if needed)
+
+CRITICAL FILE ORGANIZATION RULES:
+- **ALWAYS create a dedicated folder** for the workflow in src/mastra/workflows/
+- **Folder name MUST be kebab-case** version of workflow name
+- **types.ts**: Define all input/output schemas, validation types, and interfaces
+- **steps.ts**: Create all individual step definitions using createStep()
+- **workflow.ts**: Compose steps into workflow using createWorkflow() and export the final workflow
+- **utils.ts**: Any helper functions, constants, or utilities (create only if needed)
+- **NEVER put everything in one file** - always separate concerns properly
+
+CRITICAL COMPLETION REQUIREMENTS: 
+- ALWAYS explore the directory structure before creating files to understand where they should go
+- You MUST complete ALL ${context.tasksLength} tasks before returning status='completed'
+- Use taskManager tool with action 'list' to see your current task list and action 'update' to mark tasks as 'in_progress' or 'completed'
+- If you need to make any decisions during implementation (choosing providers, configurations, etc.), return questions for user clarification
+- DO NOT make assumptions about file locations - explore first!
+- You cannot finish until ALL tasks in the taskManager are marked as 'completed'
+
+PROJECT CONTEXT:
+- Action: ${context.action}
+- Workflow Name: ${context.workflowName}
+- Project Path: ${context.currentProjectPath}
+- Discovered Workflows: ${JSON.stringify(context.discoveredWorkflows, null, 2)}
+- Project Structure: ${JSON.stringify(context.projectStructure, null, 2)}
+
+AVAILABLE RESEARCH:
+${JSON.stringify(context.research, null, 2)}
+
+PRE-LOADED TASK LIST (${context.tasksLength} tasks already in taskManager):
+${context.tasks.map((task) => `- ${task.id}: ${task.content} (Priority: ${task.priority})`).join("\n")}
+
+${context.resumeData ? `USER PROVIDED ANSWERS: ${JSON.stringify(context.resumeData.answers, null, 2)}` : ""}
+
+Start by exploring the project structure, then use 'taskManager' with action 'list' to see your pre-loaded tasks, and work through each task systematically.`,
+    prompt: (context) => context.resumeData ? `Continue working on the task list. The user has provided answers to your questions: ${JSON.stringify(context.resumeData.answers, null, 2)}. 
+
+CRITICAL: You must complete ALL ${context.tasks.length} tasks that are pre-loaded in the taskManager. Use the taskManager tool with action 'list' to check your progress and continue with the next tasks. Do not stop until every single task is marked as 'completed'.` : `Begin executing the pre-loaded task list to ${context.action} the workflow "${context.workflowName}". 
+
+CRITICAL REQUIREMENTS:
+- Your ${context.tasks.length} tasks have been PRE-LOADED into the taskManager tool
+- Start by exploring the project directory structure using listDirectory and readFile tools to understand:
+  - Where workflows are typically stored (look for src/mastra/workflows/ or similar)
+  - What the existing file structure looks like
+  - How other workflows are organized and named
+  - Where agent files are stored if needed
+- Then use taskManager with action 'list' to see your pre-loaded tasks
+- Use taskManager with action 'update' to mark tasks as 'in_progress' or 'completed'
+
+CRITICAL FILE ORGANIZATION RULES:
+- **ALWAYS create a dedicated folder** for the workflow in src/mastra/workflows/
+- **Folder name MUST be kebab-case** version of workflow name  
+- **NEVER put everything in one file** - separate types, steps, and workflow composition
+- Follow the 4-file structure above for maximum maintainability and clarity
+
+- DO NOT return status='completed' until ALL ${context.tasks.length} tasks are marked as 'completed' in the taskManager
+
+PRE-LOADED TASKS (${context.tasks.length} total tasks in taskManager):
+${context.tasks.map((task, index) => `${index + 1}. [${task.id}] ${task.content}`).join("\n")}
+
+Use taskManager with action 'list' to see the current status of all tasks. You must complete every single one before finishing.`,
+    iterationPrompt: (context) => `Continue working on the remaining tasks. You have already completed these tasks: [${context.completedTasks.map((t) => t.id).join(", ")}]
+
+REMAINING TASKS TO COMPLETE (${context.pendingTasks.length} tasks):
+${context.pendingTasks.map((task, index) => `${index + 1}. [${task.id}] ${task.content}`).join("\n")}
+
+CRITICAL: You must complete ALL of these remaining ${context.pendingTasks.length} tasks. Use taskManager with action 'list' to check current status and action 'update' to mark tasks as completed.
+
+${context.resumeData ? `USER PROVIDED ANSWERS: ${JSON.stringify(context.resumeData.answers, null, 2)}` : ""}`
+  },
+  validation: {
+    instructions: `CRITICAL VALIDATION INSTRUCTIONS:
+- When using the validateCode tool, ALWAYS pass the specific files you created or modified using the 'files' parameter
+- The tool uses a hybrid validation approach: fast syntax checking \u2192 semantic type checking \u2192 ESLint
+- This is much faster than full project compilation and only shows errors from your specific files
+- Example: validateCode({ validationType: ['types', 'lint'], files: ['src/workflows/my-workflow.ts', 'src/agents/my-agent.ts'] })
+- ALWAYS validate after creating or modifying files to ensure they compile correctly`
+  }
+};
+var restrictedTaskManager = createTool$1({
+  id: "task-manager",
+  description: "View and update your pre-loaded task list. You can only mark tasks as in_progress or completed, not create new tasks.",
+  inputSchema: z.object({
+    action: z.enum(["list", "update", "complete"]).describe("List tasks, update status, or mark complete - tasks are pre-loaded"),
+    tasks: z.array(
+      z.object({
+        id: z.string().describe("Task ID - must match existing task"),
+        content: z.string().optional().describe("Task content (read-only)"),
+        status: z.enum(["pending", "in_progress", "completed", "blocked"]).describe("Task status"),
+        priority: z.enum(["high", "medium", "low"]).optional().describe("Task priority (read-only)"),
+        dependencies: z.array(z.string()).optional().describe("Task dependencies (read-only)"),
+        notes: z.string().optional().describe("Additional notes or progress updates")
+      })
+    ).optional().describe("Tasks to update (status and notes only)"),
+    taskId: z.string().optional().describe("Specific task ID for single task operations")
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    tasks: z.array(
+      z.object({
+        id: z.string(),
+        content: z.string(),
+        status: z.string(),
+        priority: z.string(),
+        dependencies: z.array(z.string()).optional(),
+        notes: z.string().optional(),
+        createdAt: z.string(),
+        updatedAt: z.string()
+      })
+    ),
+    message: z.string()
+  }),
+  execute: async ({ context }) => {
+    const adaptedContext = {
+      ...context,
+      action: context.action,
+      tasks: context.tasks?.map((task) => ({
+        ...task,
+        priority: task.priority || "medium"
+      }))
+    };
+    return await AgentBuilderDefaults.manageTaskList(adaptedContext);
+  }
+});
+
+// src/workflows/workflow-builder/workflow-builder.ts
+var workflowDiscoveryStep = createStep({
+  id: "workflow-discovery",
+  description: "Discover existing workflows in the project",
+  inputSchema: WorkflowBuilderInputSchema,
+  outputSchema: WorkflowDiscoveryResultSchema,
+  execute: async ({ inputData, runtimeContext: _runtimeContext }) => {
+    console.log("Starting workflow discovery...");
+    const { projectPath = process.cwd() } = inputData;
+    try {
+      const workflowsPath = join(projectPath, "src/mastra/workflows");
+      if (!existsSync(workflowsPath)) {
+        console.log("No workflows directory found");
+        return {
+          success: true,
+          workflows: [],
+          mastraIndexExists: existsSync(join(projectPath, "src/mastra/index.ts")),
+          message: "No existing workflows found in the project"
+        };
+      }
+      const workflowFiles = await readdir(workflowsPath);
+      const workflows = [];
+      for (const fileName of workflowFiles) {
+        if (fileName.endsWith(".ts") && !fileName.endsWith(".test.ts")) {
+          const filePath = join(workflowsPath, fileName);
+          try {
+            const content = await readFile(filePath, "utf-8");
+            const nameMatch = content.match(/createWorkflow\s*\(\s*{\s*id:\s*['"]([^'"]+)['"]/);
+            const descMatch = content.match(/description:\s*['"]([^'"]*)['"]/);
+            if (nameMatch && nameMatch[1]) {
+              workflows.push({
+                name: nameMatch[1],
+                file: filePath,
+                description: descMatch?.[1] ?? "No description available"
+              });
+            }
+          } catch (error) {
+            console.warn(`Failed to read workflow file ${filePath}:`, error);
+          }
+        }
+      }
+      console.log(`Discovered ${workflows.length} existing workflows`);
+      return {
+        success: true,
+        workflows,
+        mastraIndexExists: existsSync(join(projectPath, "src/mastra/index.ts")),
+        message: workflows.length > 0 ? `Found ${workflows.length} existing workflow(s): ${workflows.map((w) => w.name).join(", ")}` : "No existing workflows found in the project"
+      };
+    } catch (error) {
+      console.error("Workflow discovery failed:", error);
+      return {
+        success: false,
+        workflows: [],
+        mastraIndexExists: false,
+        message: `Workflow discovery failed: ${error instanceof Error ? error.message : String(error)}`,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+var projectDiscoveryStep = createStep({
+  id: "project-discovery",
+  description: "Analyze the project structure and setup",
+  inputSchema: WorkflowDiscoveryResultSchema,
+  outputSchema: ProjectDiscoveryResultSchema,
+  execute: async ({ inputData: _inputData, runtimeContext: _runtimeContext }) => {
+    console.log("Starting project discovery...");
+    try {
+      const projectPath = process.cwd();
+      const projectStructure = {
+        hasPackageJson: existsSync(join(projectPath, "package.json")),
+        hasMastraConfig: existsSync(join(projectPath, "mastra.config.js")) || existsSync(join(projectPath, "mastra.config.ts")),
+        hasSrcDirectory: existsSync(join(projectPath, "src")),
+        hasMastraDirectory: existsSync(join(projectPath, "src/mastra")),
+        hasWorkflowsDirectory: existsSync(join(projectPath, "src/mastra/workflows")),
+        hasToolsDirectory: existsSync(join(projectPath, "src/mastra/tools")),
+        hasAgentsDirectory: existsSync(join(projectPath, "src/mastra/agents"))
+      };
+      let packageInfo = null;
+      if (projectStructure.hasPackageJson) {
+        try {
+          const packageContent = await readFile(join(projectPath, "package.json"), "utf-8");
+          packageInfo = JSON.parse(packageContent);
+        } catch (error) {
+          console.warn("Failed to read package.json:", error);
+        }
+      }
+      console.log("Project discovery completed");
+      return {
+        success: true,
+        structure: {
+          hasWorkflowsDir: projectStructure.hasWorkflowsDirectory,
+          hasAgentsDir: projectStructure.hasAgentsDirectory,
+          hasToolsDir: projectStructure.hasToolsDirectory,
+          hasMastraIndex: existsSync(join(projectPath, "src/mastra/index.ts")),
+          existingWorkflows: [],
+          existingAgents: [],
+          existingTools: []
+        },
+        dependencies: packageInfo?.dependencies || {},
+        message: "Project discovery completed successfully"
+      };
+    } catch (error) {
+      console.error("Project discovery failed:", error);
+      return {
+        success: false,
+        structure: {
+          hasWorkflowsDir: false,
+          hasAgentsDir: false,
+          hasToolsDir: false,
+          hasMastraIndex: false,
+          existingWorkflows: [],
+          existingAgents: [],
+          existingTools: []
+        },
+        dependencies: {},
+        message: "Project discovery failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+var workflowResearchStep = createStep({
+  id: "workflow-research",
+  description: "Research Mastra workflows and gather relevant documentation",
+  inputSchema: ProjectDiscoveryResultSchema,
+  outputSchema: WorkflowResearchResultSchema,
+  execute: async ({ inputData, runtimeContext }) => {
+    console.log("Starting workflow research...");
+    try {
+      const researchAgent = new Agent({
+        model: resolveModel(runtimeContext),
+        instructions: workflowBuilderPrompts.researchAgent.instructions,
+        name: "Workflow Research Agent"
+        // tools: filteredMcpTools,
+      });
+      const researchPrompt = workflowBuilderPrompts.researchAgent.prompt({
+        projectStructure: inputData.structure,
+        dependencies: inputData.dependencies,
+        hasWorkflowsDir: inputData.structure.hasWorkflowsDir
+      });
+      const result = await researchAgent.generateVNext(researchPrompt, {
+        output: WorkflowResearchResultSchema
+        // stopWhen: stepCountIs(10),
+      });
+      const researchResult = await result.object;
+      if (!researchResult) {
+        return {
+          success: false,
+          documentation: {
+            workflowPatterns: [],
+            stepExamples: [],
+            bestPractices: []
+          },
+          webResources: [],
+          message: "Research agent failed to generate valid response",
+          error: "Research agent failed to generate valid response"
+        };
+      }
+      console.log("Research completed successfully");
+      return {
+        success: true,
+        documentation: {
+          workflowPatterns: researchResult.documentation.workflowPatterns,
+          stepExamples: researchResult.documentation.stepExamples,
+          bestPractices: researchResult.documentation.bestPractices
+        },
+        webResources: researchResult.webResources,
+        message: "Research completed successfully"
+      };
+    } catch (error) {
+      console.error("Workflow research failed:", error);
+      return {
+        success: false,
+        documentation: {
+          workflowPatterns: [],
+          stepExamples: [],
+          bestPractices: []
+        },
+        webResources: [],
+        message: "Research failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+var taskExecutionStep = createStep({
+  id: "task-execution",
+  description: "Execute the approved task list to create or edit the workflow",
+  inputSchema: TaskExecutionInputSchema,
+  outputSchema: TaskExecutionResultSchema,
+  suspendSchema: TaskExecutionSuspendSchema,
+  resumeSchema: TaskExecutionResumeSchema,
+  execute: async ({ inputData, resumeData, suspend, runtimeContext }) => {
+    const {
+      action,
+      workflowName,
+      description: _description,
+      requirements: _requirements,
+      tasks,
+      discoveredWorkflows,
+      projectStructure,
+      research,
+      projectPath
+    } = inputData;
+    console.log(`Starting task execution for ${action}ing workflow: ${workflowName}`);
+    console.log(`Executing ${tasks.length} tasks using AgentBuilder stream...`);
+    try {
+      const currentProjectPath = projectPath || process.cwd();
+      console.log("Pre-populating taskManager with planned tasks...");
+      const taskManagerContext = {
+        action: "create",
+        tasks: tasks.map((task) => ({
+          id: task.id,
+          content: task.content,
+          status: "pending",
+          priority: task.priority,
+          dependencies: task.dependencies,
+          notes: task.notes
+        }))
+      };
+      const taskManagerResult = await AgentBuilderDefaults.manageTaskList(taskManagerContext);
+      console.log(`Task manager initialized with ${taskManagerResult.tasks.length} tasks`);
+      if (!taskManagerResult.success) {
+        throw new Error(`Failed to initialize task manager: ${taskManagerResult.message}`);
+      }
+      const executionAgent = new AgentBuilder({
+        projectPath: currentProjectPath,
+        model: resolveModel(runtimeContext),
+        tools: {
+          "task-manager": restrictedTaskManager
+        },
+        instructions: `${workflowBuilderPrompts.executionAgent.instructions({
+          action,
+          workflowName,
+          tasksLength: tasks.length,
+          currentProjectPath,
+          discoveredWorkflows,
+          projectStructure,
+          research,
+          tasks,
+          resumeData
+        })}
+
+${workflowBuilderPrompts.validation.instructions}`
+      });
+      const executionPrompt = workflowBuilderPrompts.executionAgent.prompt({
+        action,
+        workflowName,
+        tasks,
+        resumeData
+      });
+      const originalInstructions = await executionAgent.getInstructions({ runtimeContext });
+      const additionalInstructions = executionAgent.instructions;
+      let enhancedInstructions = originalInstructions;
+      if (additionalInstructions) {
+        enhancedInstructions = `${originalInstructions}
+
+${additionalInstructions}`;
+      }
+      const enhancedOptions = {
+        stopWhen: stepCountIs(100),
+        temperature: 0.3,
+        instructions: enhancedInstructions
+      };
+      let finalResult = null;
+      let allTasksCompleted = false;
+      let iterationCount = 0;
+      const maxIterations = 5;
+      const expectedTaskIds = tasks.map((task) => task.id);
+      while (!allTasksCompleted && iterationCount < maxIterations) {
+        iterationCount++;
+        const currentTaskStatus = await AgentBuilderDefaults.manageTaskList({ action: "list" });
+        const completedTasks = currentTaskStatus.tasks.filter((task) => task.status === "completed");
+        const pendingTasks = currentTaskStatus.tasks.filter((task) => task.status !== "completed");
+        console.log(`
+=== EXECUTION ITERATION ${iterationCount} ===`);
+        console.log(`Completed tasks: ${completedTasks.length}/${expectedTaskIds.length}`);
+        console.log(`Remaining tasks: ${pendingTasks.map((t) => t.id).join(", ")}`);
+        allTasksCompleted = pendingTasks.length === 0;
+        if (allTasksCompleted) {
+          console.log("All tasks completed! Breaking execution loop.");
+          break;
+        }
+        const iterationPrompt = iterationCount === 1 ? executionPrompt : `${workflowBuilderPrompts.executionAgent.iterationPrompt({
+          completedTasks,
+          pendingTasks,
+          workflowName,
+          resumeData
+        })}
+
+${workflowBuilderPrompts.validation.instructions}`;
+        const stream = await executionAgent.streamVNext(iterationPrompt, {
+          structuredOutput: {
+            schema: TaskExecutionIterationInputSchema(tasks.length),
+            model: resolveModel(runtimeContext)
+          },
+          ...enhancedOptions
+        });
+        let finalMessage = "";
+        for await (const chunk of stream.fullStream) {
+          if (chunk.type === "text-delta") {
+            finalMessage += chunk.payload.text;
+          }
+          if (chunk.type === "step-finish") {
+            console.log(finalMessage);
+            finalMessage = "";
+          }
+          if (chunk.type === "tool-result") {
+            console.log(JSON.stringify(chunk, null, 2));
+          }
+          if (chunk.type === "finish") {
+            console.log(chunk);
+          }
+        }
+        await stream.consumeStream();
+        finalResult = await stream.object;
+        console.log(`Iteration ${iterationCount} result:`, { finalResult });
+        if (!finalResult) {
+          throw new Error(`No result received from agent execution on iteration ${iterationCount}`);
+        }
+        const postIterationTaskStatus = await AgentBuilderDefaults.manageTaskList({ action: "list" });
+        const postCompletedTasks = postIterationTaskStatus.tasks.filter((task) => task.status === "completed");
+        const postPendingTasks = postIterationTaskStatus.tasks.filter((task) => task.status !== "completed");
+        allTasksCompleted = postPendingTasks.length === 0;
+        console.log(
+          `After iteration ${iterationCount}: ${postCompletedTasks.length}/${expectedTaskIds.length} tasks completed in taskManager`
+        );
+        if (finalResult.status === "needs_clarification" && finalResult.questions && finalResult.questions.length > 0) {
+          console.log(
+            `Agent needs clarification on iteration ${iterationCount}: ${finalResult.questions.length} questions`
+          );
+          break;
+        }
+        if (finalResult.status === "completed" && !allTasksCompleted) {
+          console.log(
+            `Agent claimed completion but taskManager shows pending tasks: ${postPendingTasks.map((t) => t.id).join(", ")}`
+          );
+        }
+      }
+      if (iterationCount >= maxIterations && !allTasksCompleted) {
+        finalResult.error = `Maximum iterations (${maxIterations}) reached but not all tasks completed`;
+        finalResult.status = "in_progress";
+      }
+      if (!finalResult) {
+        throw new Error("No result received from agent execution");
+      }
+      if (finalResult.status === "needs_clarification" && finalResult.questions && finalResult.questions.length > 0) {
+        console.log(`Agent needs clarification: ${finalResult.questions.length} questions`);
+        console.log("finalResult", JSON.stringify(finalResult, null, 2));
+        return suspend({
+          questions: finalResult.questions,
+          currentProgress: finalResult.progress,
+          completedTasks: finalResult.completedTasks || [],
+          message: finalResult.message
+        });
+      }
+      const finalTaskStatus = await AgentBuilderDefaults.manageTaskList({ action: "list" });
+      const finalCompletedTasks = finalTaskStatus.tasks.filter((task) => task.status === "completed");
+      const finalPendingTasks = finalTaskStatus.tasks.filter((task) => task.status !== "completed");
+      const tasksCompleted = finalCompletedTasks.length;
+      const tasksExpected = expectedTaskIds.length;
+      const finalAllTasksCompleted = finalPendingTasks.length === 0;
+      const success = finalAllTasksCompleted && !finalResult.error;
+      const message = success ? `Successfully completed workflow ${action} - all ${tasksExpected} tasks completed after ${iterationCount} iteration(s): ${finalResult.message}` : `Workflow execution finished with issues after ${iterationCount} iteration(s): ${finalResult.message}. Completed: ${tasksCompleted}/${tasksExpected} tasks`;
+      console.log(message);
+      const missingTasks = finalPendingTasks.map((task) => task.id);
+      const validationErrors = [];
+      if (finalResult.error) {
+        validationErrors.push(finalResult.error);
+      }
+      if (!finalAllTasksCompleted) {
+        validationErrors.push(
+          `Incomplete tasks: ${missingTasks.join(", ")} (${tasksCompleted}/${tasksExpected} completed)`
+        );
+      }
+      return {
+        success,
+        completedTasks: finalCompletedTasks.map((task) => task.id),
+        filesModified: finalResult.filesModified || [],
+        validationResults: {
+          passed: success,
+          errors: validationErrors,
+          warnings: finalAllTasksCompleted ? [] : [`Missing ${missingTasks.length} tasks: ${missingTasks.join(", ")}`]
+        },
+        message,
+        error: finalResult.error
+      };
+    } catch (error) {
+      console.error("Task execution failed:", error);
+      return {
+        success: false,
+        completedTasks: [],
+        filesModified: [],
+        validationResults: {
+          passed: false,
+          errors: [`Task execution failed: ${error instanceof Error ? error.message : String(error)}`],
+          warnings: []
+        },
+        message: `Task execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+var workflowBuilderWorkflow = createWorkflow({
+  id: "workflow-builder",
+  description: "Create or edit Mastra workflows using AI-powered assistance with iterative planning",
+  inputSchema: WorkflowBuilderInputSchema,
+  outputSchema: WorkflowBuilderResultSchema,
+  steps: [
+    workflowDiscoveryStep,
+    projectDiscoveryStep,
+    workflowResearchStep,
+    planningAndApprovalWorkflow,
+    taskExecutionStep
+  ]
+}).then(workflowDiscoveryStep).then(projectDiscoveryStep).then(workflowResearchStep).map(async ({ getStepResult, getInitData }) => {
+  const initData = getInitData();
+  const discoveryResult = getStepResult(workflowDiscoveryStep);
+  const projectResult = getStepResult(projectDiscoveryStep);
+  return {
+    action: initData.action,
+    workflowName: initData.workflowName,
+    description: initData.description,
+    requirements: initData.requirements,
+    discoveredWorkflows: discoveryResult.workflows,
+    projectStructure: projectResult,
+    // research: researchResult,
+    research: workflowResearch,
+    userAnswers: void 0
+  };
+}).dountil(planningAndApprovalWorkflow, async ({ inputData }) => {
+  console.log(`Sub-workflow check: approved=${inputData.approved}`);
+  return inputData.approved === true;
+}).map(async ({ getStepResult, getInitData }) => {
+  const initData = getInitData();
+  const discoveryResult = getStepResult(workflowDiscoveryStep);
+  const projectResult = getStepResult(projectDiscoveryStep);
+  const subWorkflowResult = getStepResult(planningAndApprovalWorkflow);
+  return {
+    action: initData.action,
+    workflowName: initData.workflowName,
+    description: initData.description,
+    requirements: initData.requirements,
+    tasks: subWorkflowResult.tasks,
+    discoveredWorkflows: discoveryResult.workflows,
+    projectStructure: projectResult,
+    // research: researchResult,
+    research: workflowResearch,
+    projectPath: initData.projectPath || process.cwd()
+  };
+}).then(taskExecutionStep).commit();
+
+// src/workflows/workflow-map.ts
+var agentBuilderWorkflows = {
+  "merge-template": agentBuilderTemplateWorkflow,
+  "workflow-builder": workflowBuilderWorkflow
+};
 
 // src/agent/index.ts
 var AgentBuilder = class extends Agent {
@@ -4240,9 +6014,7 @@ ${config.instructions}` : "";
           ...config.tools || {}
         };
       },
-      workflows: {
-        "merge-template": agentBuilderTemplateWorkflow
-      },
+      workflows: agentBuilderWorkflows,
       memory: new Memory({
         options: AgentBuilderDefaults.DEFAULT_MEMORY_CONFIG,
         processors: [
@@ -4345,4 +6117,6 @@ ${!options?.outputFormat || options.outputFormat === "both" ? "Provide both expl
   }
 };
 
-export { AgentBuilder, AgentBuilderDefaults, agentBuilderTemplateWorkflow, mergeTemplateBySlug };
+export { AgentBuilder, AgentBuilderDefaults, agentBuilderTemplateWorkflow, agentBuilderWorkflows, mergeTemplateBySlug, planningAndApprovalWorkflow, workflowBuilderWorkflow };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map