@synergenius/flow-weaver 0.16.0 → 0.17.0

package/dist/cli/flow-weaver.mjs

@@ -2944,7 +2944,7 @@ var require_brace_expansion = __commonJS({
             incr *= -1;
             test = gte;
           }
-          var pad = n.some(isPadded);
+          var pad2 = n.some(isPadded);
           N = [];
           for (var i = x; test(i, y); i += incr) {
             var c;
@@ -2954,7 +2954,7 @@ var require_brace_expansion = __commonJS({
                 c = "";
             } else {
               c = String(i);
-              if (pad) {
+              if (pad2) {
                 var need = width - c.length;
                 if (need > 0) {
                   var z = new Array(need + 1).join("0");
@@ -9671,7 +9671,7 @@ var VERSION;
 var init_generated_version = __esm({
   "src/generated-version.ts"() {
     "use strict";
-    VERSION = "0.16.0";
+    VERSION = "0.17.0";
   }
 });
 
@@ -51552,9 +51552,9 @@ function portBadgeWidth(port) {
   const abbrev = TYPE_ABBREVIATIONS[port.dataType] ?? port.dataType;
   const typeWidth = measureText(abbrev);
   const labelWidth = measureText(port.label);
-  const pad = 7;
+  const pad2 = 7;
   const divGap = 4;
-  return pad + typeWidth + divGap + 1 + divGap + labelWidth + pad;
+  return pad2 + typeWidth + divGap + 1 + divGap + labelWidth + pad2;
 }
 function portLabelExtent(port) {
   const badgeGap = 5;
@@ -53241,9 +53241,9 @@ function renderPortLabels(parts2, nodeId, inputs, outputs, theme, themeName) {
     const portLabel = port.label;
     const typeWidth = measureText(abbrev);
     const labelWidth = measureText(portLabel);
-    const pad = 7;
+    const pad2 = 7;
     const divGap = 4;
-    const badgeWidth = pad + typeWidth + divGap + 1 + divGap + labelWidth + pad;
+    const badgeWidth = pad2 + typeWidth + divGap + 1 + divGap + labelWidth + pad2;
     const badgeHeight = 16;
     const badgeGap = 5;
     const rr = badgeHeight / 2;
@@ -53252,15 +53252,15 @@ function renderPortLabels(parts2, nodeId, inputs, outputs, theme, themeName) {
     parts2.push(`    <g data-port-label="${portId}">`);
     parts2.push(`      <rect x="${badgeX}" y="${badgeY}" width="${badgeWidth}" height="${badgeHeight}" rx="${rr}" fill="${theme.nodeFill}" stroke="${theme.labelBadgeBorder}" stroke-width="1"/>`);
     if (isInput) {
-      const typeX = badgeX + badgeWidth - pad - typeWidth / 2;
+      const typeX = badgeX + badgeWidth - pad2 - typeWidth / 2;
       const divX = typeX - typeWidth / 2 - divGap;
       const nameX = divX - divGap;
       parts2.push(`      <line x1="${divX}" y1="${badgeY + 3}" x2="${divX}" y2="${badgeY + badgeHeight - 3}" stroke="${theme.labelBadgeBorder}" stroke-width="1"/>`);
       parts2.push(`      <text class="port-label" x="${nameX}" y="${port.cy + 3.5}" text-anchor="end">${escapeXml(portLabel)}</text>`);
       parts2.push(`      <text class="port-type-label" x="${typeX}" y="${port.cy + 3.5}" text-anchor="middle" fill="${color}">${escapeXml(abbrev)}</text>`);
     } else {
-      const typeX = badgeX + pad + typeWidth / 2;
-      const divX = badgeX + pad + typeWidth + divGap;
+      const typeX = badgeX + pad2 + typeWidth / 2;
+      const divX = badgeX + pad2 + typeWidth + divGap;
       const nameX = divX + 1 + divGap;
       parts2.push(`      <line x1="${divX}" y1="${badgeY + 3}" x2="${divX}" y2="${badgeY + badgeHeight - 3}" stroke="${theme.labelBadgeBorder}" stroke-width="1"/>`);
       parts2.push(`      <text class="port-type-label" x="${typeX}" y="${port.cy + 3.5}" text-anchor="middle" fill="${color}">${escapeXml(abbrev)}</text>`);
@@ -56433,20 +56433,20 @@ __export(workflow_executor_exports, {
   computeTraceSummary: () => computeTraceSummary,
   executeWorkflowFromFile: () => executeWorkflowFromFile
 });
-import * as path18 from "path";
-import * as fs18 from "fs";
+import * as path20 from "path";
+import * as fs20 from "fs";
 import { pathToFileURL } from "url";
 import ts4 from "typescript";
 async function executeWorkflowFromFile(filePath, params, options) {
-  const resolvedPath = path18.resolve(filePath);
+  const resolvedPath = path20.resolve(filePath);
   const includeTrace = options?.includeTrace !== false;
   const tmpId = `fw-exec-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const tmpBase = path18.join(path18.dirname(resolvedPath), tmpId);
+  const tmpBase = path20.join(path20.dirname(resolvedPath), tmpId);
   const tmpTsFile = `${tmpBase}.ts`;
   const tmpFile = `${tmpBase}.mjs`;
   try {
-    fs18.copyFileSync(resolvedPath, tmpTsFile);
-    const source = fs18.readFileSync(resolvedPath, "utf8");
+    fs20.copyFileSync(resolvedPath, tmpTsFile);
+    const source = fs20.readFileSync(resolvedPath, "utf8");
     const allWorkflows = getAvailableWorkflows(source);
     const production = options?.debugController ? false : options?.production ?? !includeTrace;
     for (const wf of allWorkflows) {
@@ -56457,7 +56457,7 @@ async function executeWorkflowFromFile(filePath, params, options) {
         generate: { production }
       });
     }
-    let compiledCode = fs18.readFileSync(tmpTsFile, "utf8");
+    let compiledCode = fs20.readFileSync(tmpTsFile, "utf8");
     compiledCode = compiledCode.replace(
       "declare const __flowWeaverDebugger__: TDebugger | undefined;",
       "const __flowWeaverDebugger__ = (globalThis as any).__fw_debugger__;"
@@ -56469,7 +56469,7 @@ async function executeWorkflowFromFile(filePath, params, options) {
         esModuleInterop: true
       }
     });
-    fs18.writeFileSync(tmpFile, jsOutput.outputText, "utf8");
+    fs20.writeFileSync(tmpFile, jsOutput.outputText, "utf8");
     const trace = [];
     const debugger_ = includeTrace ? {
       sendEvent: (event) => {
@@ -56525,11 +56525,11 @@ async function executeWorkflowFromFile(filePath, params, options) {
     delete globalThis.__fw_agent_channel__;
     delete globalThis.__fw_debug_controller__;
     try {
-      fs18.unlinkSync(tmpFile);
+      fs20.unlinkSync(tmpFile);
     } catch {
     }
     try {
-      fs18.unlinkSync(tmpTsFile);
+      fs20.unlinkSync(tmpTsFile);
     } catch {
     }
   }
@@ -56600,7 +56600,7 @@ var require_XMLHttpRequest = __commonJS({
   "node_modules/xmlhttprequest-ssl/lib/XMLHttpRequest.js"(exports2, module2) {
     var fs53 = __require("fs");
     var Url = __require("url");
-    var spawn2 = __require("child_process").spawn;
+    var spawn3 = __require("child_process").spawn;
     module2.exports = XMLHttpRequest3;
     XMLHttpRequest3.XMLHttpRequest = XMLHttpRequest3;
     function XMLHttpRequest3(opts) {
@@ -56896,7 +56896,7 @@ var require_XMLHttpRequest = __commonJS({
           var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
           fs53.writeFileSync(syncFile, "", "utf8");
           var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var responseData = Buffer.alloc(0);var req = doRequest(options, function(response) {response.on('data', function(chunk) {  var data = Buffer.from(chunk);  responseText += data.toString('utf8');  responseData = Buffer.concat([responseData, data]);});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
-          var syncProc = spawn2(process.argv[0], ["-e", execString]);
+          var syncProc = spawn3(process.argv[0], ["-e", execString]);
           var statusText;
           while (fs53.existsSync(syncFile)) {
           }
@@ -72068,8 +72068,8 @@ var init_executor = __esm({
 });
 
 // src/deployment/core/adapters.ts
-import * as fs28 from "fs";
-import * as path30 from "path";
+import * as fs30 from "fs";
+import * as path32 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function createAdapter(source) {
   switch (source) {
@@ -72162,12 +72162,12 @@ var init_adapters = __esm({
             throw new Error(`Invalid JSON in params: ${input.params}`);
           }
         } else if (input.paramsFile) {
-          const paramsFilePath = path30.resolve(input.paramsFile);
-          if (!fs28.existsSync(paramsFilePath)) {
+          const paramsFilePath = path32.resolve(input.paramsFile);
+          if (!fs30.existsSync(paramsFilePath)) {
             throw new Error(`Params file not found: ${paramsFilePath}`);
           }
           try {
-            const content = fs28.readFileSync(paramsFilePath, "utf8");
+            const content = fs30.readFileSync(paramsFilePath, "utf8");
             params = JSON.parse(content);
           } catch {
             throw new Error(`Failed to parse params file: ${input.paramsFile}`);
@@ -72188,7 +72188,7 @@ var init_adapters = __esm({
        * Extract workflow ID from file path (uses filename without extension)
        */
       extractWorkflowId(filePath) {
-        const basename20 = path30.basename(filePath, path30.extname(filePath));
+        const basename20 = path32.basename(filePath, path32.extname(filePath));
         return basename20;
       }
     };
@@ -72502,8 +72502,8 @@ var init_defaults2 = __esm({
 });
 
 // src/deployment/config/loader.ts
-import * as fs29 from "fs";
-import * as path31 from "path";
+import * as fs31 from "fs";
+import * as path33 from "path";
 async function loadConfig(cliOverrides, configPath) {
   const environment = detectEnvironment(cliOverrides);
   let config2 = getDefaultConfig(environment);
@@ -72540,22 +72540,22 @@ async function loadConfigFile(configPath) {
   }
   const cwd = process.cwd();
   for (const fileName of CONFIG_FILE_NAMES) {
-    const configFilePath = path31.join(cwd, fileName);
-    if (fs29.existsSync(configFilePath)) {
+    const configFilePath = path33.join(cwd, fileName);
+    if (fs31.existsSync(configFilePath)) {
       return loadConfigFromPath(configFilePath);
     }
   }
   return null;
 }
 async function loadConfigFromPath(filePath) {
-  const absolutePath = path31.resolve(filePath);
-  if (!fs29.existsSync(absolutePath)) {
+  const absolutePath = path33.resolve(filePath);
+  if (!fs31.existsSync(absolutePath)) {
     return null;
   }
-  const ext2 = path31.extname(absolutePath);
+  const ext2 = path33.extname(absolutePath);
   if (ext2 === ".yaml" || ext2 === ".yml") {
     try {
-      const content = fs29.readFileSync(absolutePath, "utf8");
+      const content = fs31.readFileSync(absolutePath, "utf8");
       return load(content);
     } catch {
       return null;
@@ -73178,7 +73178,7 @@ var init_generator = __esm({
 });
 
 // src/deployment/targets/base.ts
-import * as path32 from "path";
+import * as path34 from "path";
 var BaseExportTarget, ExportTargetRegistry;
 var init_base = __esm({
   "src/deployment/targets/base.ts"() {
@@ -73229,7 +73229,7 @@ var init_base = __esm({
       createFile(outputDir, relativePath, content, type2) {
         return {
           relativePath,
-          absolutePath: path32.join(outputDir, relativePath),
+          absolutePath: path34.join(outputDir, relativePath),
           content,
           type: type2
         };
@@ -73282,7 +73282,7 @@ var init_base = __esm({
        * Get relative import path for the workflow
        */
       getWorkflowImport(workflowFile) {
-        const basename20 = path32.basename(workflowFile, path32.extname(workflowFile));
+        const basename20 = path34.basename(workflowFile, path34.extname(workflowFile));
         return `./${basename20}.js`;
       }
       /**
@@ -74334,8 +74334,8 @@ __export(registry_exports, {
   listInstalledPackages: () => listInstalledPackages,
   searchPackages: () => searchPackages
 });
-import * as fs30 from "fs";
-import * as path33 from "path";
+import * as fs32 from "fs";
+import * as path35 from "path";
 async function searchPackages(options = {}) {
   const { query, limit = 20, registryUrl } = options;
   const textParts = [
@@ -74360,25 +74360,25 @@ async function searchPackages(options = {}) {
   }));
 }
 async function listInstalledPackages(projectDir) {
-  const nodeModules = path33.join(projectDir, "node_modules");
-  if (!fs30.existsSync(nodeModules)) return [];
+  const nodeModules = path35.join(projectDir, "node_modules");
+  if (!fs32.existsSync(nodeModules)) return [];
   const patterns = [
-    path33.join(nodeModules, "flowweaver-pack-*", "flowweaver.manifest.json"),
-    path33.join(nodeModules, "@*", "flowweaver-pack-*", "flowweaver.manifest.json")
+    path35.join(nodeModules, "flowweaver-pack-*", "flowweaver.manifest.json"),
+    path35.join(nodeModules, "@*", "flowweaver-pack-*", "flowweaver.manifest.json")
   ];
   const results = [];
   for (const pattern of patterns) {
     const manifestPaths = await glob(pattern.replace(/\\/g, "/"), { absolute: true });
     for (const manifestPath of manifestPaths) {
       try {
-        const pkgDir = path33.dirname(manifestPath);
+        const pkgDir = path35.dirname(manifestPath);
         const manifest = JSON.parse(
-          fs30.readFileSync(manifestPath, "utf-8")
+          fs32.readFileSync(manifestPath, "utf-8")
         );
-        const pkgJsonPath = path33.join(pkgDir, "package.json");
+        const pkgJsonPath = path35.join(pkgDir, "package.json");
         let version3 = manifest.version;
-        if (fs30.existsSync(pkgJsonPath)) {
-          const pkg = JSON.parse(fs30.readFileSync(pkgJsonPath, "utf-8"));
+        if (fs32.existsSync(pkgJsonPath)) {
+          const pkg = JSON.parse(fs32.readFileSync(pkgJsonPath, "utf-8"));
           version3 = pkg.version ?? manifest.version;
         }
         results.push({
@@ -74394,11 +74394,11 @@ async function listInstalledPackages(projectDir) {
   return results;
 }
 function getInstalledPackageManifest(projectDir, packageName) {
-  const packageDir = path33.join(projectDir, "node_modules", packageName);
-  const manifestPath = path33.join(packageDir, "flowweaver.manifest.json");
-  if (!fs30.existsSync(manifestPath)) return null;
+  const packageDir = path35.join(projectDir, "node_modules", packageName);
+  const manifestPath = path35.join(packageDir, "flowweaver.manifest.json");
+  if (!fs32.existsSync(manifestPath)) return null;
   try {
-    return JSON.parse(fs30.readFileSync(manifestPath, "utf-8"));
+    return JSON.parse(fs32.readFileSync(manifestPath, "utf-8"));
   } catch {
     return null;
   }
@@ -74450,7 +74450,7 @@ __export(deployment_exports, {
   loadConfigSync: () => loadConfigSync,
   schemaConverter: () => schemaConverter
 });
-import * as path34 from "path";
+import * as path36 from "path";
 async function createTargetRegistry(projectDir) {
   const registry2 = new ExportTargetRegistry();
   if (projectDir) {
@@ -74458,7 +74458,7 @@ async function createTargetRegistry(projectDir) {
     const packages = await listInstalledPackages2(projectDir);
     for (const pkg of packages) {
       for (const def of pkg.manifest.exportTargets ?? []) {
-        const filePath = path34.join(pkg.path, def.file);
+        const filePath = path36.join(pkg.path, def.file);
         const mod = await import(filePath);
         const TargetClass = def.exportName ? mod[def.exportName] : mod.default;
         registry2.register(def.name, () => new TargetClass());
@@ -77762,9 +77762,9 @@ async function validateCommand(input, options = {}) {
 }
 
 // src/cli/commands/init.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
-import { execSync as execSync2 } from "child_process";
+import * as fs19 from "fs";
+import * as path18 from "path";
+import { execSync as execSync3, spawn } from "child_process";
 
 // node_modules/@inquirer/input/node_modules/@inquirer/core/dist/lib/key.js
 var isBackspaceKey = (key) => key.name === "backspace";
@@ -80770,6 +80770,1220 @@ var eraseLine2 = ESC3 + "2K";
 
 // src/cli/commands/init.ts
 init_templates();
+
+// src/cli/commands/mcp-setup.ts
+import { execSync as execSync2 } from "child_process";
+import * as fs17 from "fs";
+import * as path16 from "path";
+import * as os from "os";
+var MCP_COMMAND = "npx";
+var MCP_ARGS = ["@synergenius/flow-weaver@latest", "mcp-server", "--stdio"];
+var MCP_ENTRY = { command: MCP_COMMAND, args: [...MCP_ARGS] };
+var CLI_TOOL_IDS = /* @__PURE__ */ new Set(["claude", "codex"]);
+var CLI_TOOL_BINARY = {
+  claude: "claude",
+  codex: "codex"
+};
+function defaultDeps() {
+  return {
+    execCommand: async (cmd) => {
+      try {
+        const stdout = execSync2(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+        return { stdout: stdout.trim(), exitCode: 0 };
+      } catch {
+        return { stdout: "", exitCode: 1 };
+      }
+    },
+    fileExists: async (filePath) => {
+      try {
+        await fs17.promises.access(filePath);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    readFile: async (filePath) => {
+      try {
+        return await fs17.promises.readFile(filePath, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    writeFile: async (filePath, content) => {
+      await fs17.promises.writeFile(filePath, content, "utf8");
+    },
+    mkdir: async (dirPath) => {
+      await fs17.promises.mkdir(dirPath, { recursive: true });
+    },
+    cwd: () => process.cwd(),
+    homedir: () => os.homedir(),
+    log: (msg) => process.stdout.write(msg + "\n")
+  };
+}
+function whichCmd(binary2) {
+  return process.platform === "win32" ? `where ${binary2}` : `which ${binary2}`;
+}
+async function binaryExists(binary2, deps) {
+  const result = await deps.execCommand(whichCmd(binary2));
+  return result.exitCode === 0;
+}
+async function mergeJsonConfig(deps, filePath, rootKey) {
+  const existing = await deps.readFile(filePath);
+  if (existing === null) {
+    const dir = path16.dirname(filePath);
+    await deps.mkdir(dir);
+    const config3 = { [rootKey]: { "flow-weaver": MCP_ENTRY } };
+    await deps.writeFile(filePath, JSON.stringify(config3, null, 2) + "\n");
+    return { action: "created", detail: `created ${filePath}` };
+  }
+  let config2;
+  try {
+    config2 = JSON.parse(existing);
+  } catch {
+    throw new Error(`invalid JSON in ${filePath}`);
+  }
+  if (!config2[rootKey] || typeof config2[rootKey] !== "object") {
+    config2[rootKey] = {};
+  }
+  const servers = config2[rootKey];
+  if (servers["flow-weaver"]) {
+    return { action: "already-configured", detail: `already in ${filePath}` };
+  }
+  servers["flow-weaver"] = MCP_ENTRY;
+  await deps.writeFile(filePath, JSON.stringify(config2, null, 2) + "\n");
+  return { action: "added", detail: `added to ${filePath}` };
+}
+var TOOL_REGISTRY = [
+  // Claude Code
+  {
+    id: "claude",
+    displayName: "Claude Code",
+    detect: (deps) => binaryExists("claude", deps),
+    isConfigured: async (deps) => {
+      const result = await deps.execCommand("claude mcp list");
+      return result.exitCode === 0 && result.stdout.includes("flow-weaver");
+    },
+    configure: async (deps) => {
+      const cmd = `claude mcp add --scope project flow-weaver -- ${MCP_COMMAND} ${MCP_ARGS.join(" ")}`;
+      const result = await deps.execCommand(cmd);
+      if (result.exitCode !== 0) {
+        throw new Error("claude mcp add failed");
+      }
+      return "registered via claude mcp add";
+    }
+  },
+  // Cursor
+  {
+    id: "cursor",
+    displayName: "Cursor",
+    detect: async (deps) => {
+      const dirExists = await deps.fileExists(path16.join(deps.cwd(), ".cursor"));
+      if (dirExists) return true;
+      return binaryExists("cursor", deps);
+    },
+    isConfigured: async (deps) => {
+      const filePath = path16.join(deps.cwd(), ".cursor", "mcp.json");
+      const content = await deps.readFile(filePath);
+      if (!content) return false;
+      try {
+        const config2 = JSON.parse(content);
+        return !!config2?.mcpServers?.["flow-weaver"];
+      } catch {
+        return false;
+      }
+    },
+    configure: async (deps) => {
+      const filePath = path16.join(deps.cwd(), ".cursor", "mcp.json");
+      const result = await mergeJsonConfig(deps, filePath, "mcpServers");
+      return result.detail;
+    }
+  },
+  // VS Code Copilot
+  {
+    id: "vscode",
+    displayName: "VS Code Copilot",
+    detect: (deps) => binaryExists("code", deps),
+    isConfigured: async (deps) => {
+      const filePath = path16.join(deps.cwd(), ".vscode", "mcp.json");
+      const content = await deps.readFile(filePath);
+      if (!content) return false;
+      try {
+        const config2 = JSON.parse(content);
+        return !!config2?.servers?.["flow-weaver"];
+      } catch {
+        return false;
+      }
+    },
+    configure: async (deps) => {
+      const filePath = path16.join(deps.cwd(), ".vscode", "mcp.json");
+      const result = await mergeJsonConfig(deps, filePath, "servers");
+      return result.detail;
+    }
+  },
+  // Windsurf
+  {
+    id: "windsurf",
+    displayName: "Windsurf",
+    detect: async (deps) => {
+      const configDir = path16.join(deps.homedir(), ".codeium", "windsurf");
+      const dirExists = await deps.fileExists(configDir);
+      if (dirExists) return true;
+      return binaryExists("windsurf", deps);
+    },
+    isConfigured: async (deps) => {
+      const filePath = path16.join(deps.homedir(), ".codeium", "windsurf", "mcp_config.json");
+      const content = await deps.readFile(filePath);
+      if (!content) return false;
+      try {
+        const config2 = JSON.parse(content);
+        return !!config2?.mcpServers?.["flow-weaver"];
+      } catch {
+        return false;
+      }
+    },
+    configure: async (deps) => {
+      const filePath = path16.join(deps.homedir(), ".codeium", "windsurf", "mcp_config.json");
+      const result = await mergeJsonConfig(deps, filePath, "mcpServers");
+      return result.detail;
+    }
+  },
+  // Codex (OpenAI)
+  {
+    id: "codex",
+    displayName: "Codex",
+    detect: (deps) => binaryExists("codex", deps),
+    isConfigured: async (deps) => {
+      const result = await deps.execCommand("codex mcp list");
+      return result.exitCode === 0 && result.stdout.includes("flow-weaver");
+    },
+    configure: async (deps) => {
+      const cmd = `codex mcp add flow-weaver -- ${MCP_COMMAND} ${MCP_ARGS.join(" ")}`;
+      const result = await deps.execCommand(cmd);
+      if (result.exitCode !== 0) {
+        throw new Error("codex mcp add failed");
+      }
+      return "registered via codex mcp add";
+    }
+  },
+  // OpenClaw
+  {
+    id: "openclaw",
+    displayName: "OpenClaw",
+    detect: async (deps) => {
+      return deps.fileExists(path16.join(deps.cwd(), "openclaw.json"));
+    },
+    isConfigured: async (deps) => {
+      const filePath = path16.join(deps.cwd(), "openclaw.json");
+      const content = await deps.readFile(filePath);
+      if (!content) return false;
+      try {
+        const config2 = JSON.parse(content);
+        return !!config2?.mcpServers?.["flow-weaver"];
+      } catch {
+        return false;
+      }
+    },
+    configure: async (deps) => {
+      const filePath = path16.join(deps.cwd(), "openclaw.json");
+      const result = await mergeJsonConfig(deps, filePath, "mcpServers");
+      return result.detail;
+    }
+  }
+];
+async function detectTools(deps) {
+  const results = await Promise.all(
+    TOOL_REGISTRY.map(async (tool) => {
+      const detected = await tool.detect(deps);
+      const configured = detected ? await tool.isConfigured(deps) : false;
+      return { id: tool.id, displayName: tool.displayName, detected, configured };
+    })
+  );
+  return results;
+}
+async function configureTool(tool, deps) {
+  try {
+    const already = await tool.isConfigured(deps);
+    if (already) {
+      return { id: tool.id, displayName: tool.displayName, action: "already-configured", detail: "already configured" };
+    }
+    const detail = await tool.configure(deps);
+    return { id: tool.id, displayName: tool.displayName, action: "configured", detail };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { id: tool.id, displayName: tool.displayName, action: "failed", detail: msg };
+  }
+}
+async function runMcpSetupFromInit(deps) {
+  const d = deps ?? defaultDeps();
+  const detected = await detectTools(d);
+  const toConfig = detected.filter((t) => t.detected && !t.configured);
+  const configured = [];
+  const failed = [];
+  const toolMap = new Map(TOOL_REGISTRY.map((t) => [t.id, t]));
+  for (const t of toConfig) {
+    const tool = toolMap.get(t.id);
+    if (!tool) continue;
+    const result = await configureTool(tool, d);
+    if (result.action === "configured") {
+      configured.push(result.displayName);
+    } else if (result.action === "failed") {
+      failed.push(result.displayName);
+    }
+  }
+  for (const t of detected) {
+    if (t.configured) {
+      configured.push(t.displayName);
+    }
+  }
+  const allConfiguredIds = detected.filter((t) => t.detected && (t.configured || configured.includes(t.displayName))).map((t) => t.id);
+  const cliTools = allConfiguredIds.filter((id) => CLI_TOOL_IDS.has(id));
+  const guiTools = allConfiguredIds.filter((id) => !CLI_TOOL_IDS.has(id));
+  return { configured, failed, cliTools, guiTools };
+}
+async function mcpSetupCommand(options, deps) {
+  const d = deps ?? defaultDeps();
+  const detected = await detectTools(d);
+  if (options.list) {
+    d.log("");
+    for (const t of detected) {
+      const status = t.detected ? t.configured ? "detected, configured" : "detected" : "not found";
+      const icon = t.detected ? t.configured ? "\u25CF" : "\u25CB" : "\xB7";
+      d.log(`  ${icon} ${t.displayName.padEnd(18)} ${status}`);
+    }
+    d.log("");
+    return;
+  }
+  let toolIds;
+  if (options.tool && options.tool.length > 0) {
+    const valid = new Set(TOOL_REGISTRY.map((t) => t.id));
+    for (const name of options.tool) {
+      if (!valid.has(name)) {
+        d.log(`Unknown tool: "${name}". Valid tools: ${[...valid].join(", ")}`);
+        return;
+      }
+    }
+    toolIds = options.tool;
+  } else if (options.all) {
+    toolIds = detected.filter((t) => t.detected).map((t) => t.id);
+  } else if (isNonInteractive()) {
+    toolIds = detected.filter((t) => t.detected).map((t) => t.id);
+  } else {
+    const detectedTools = detected.filter((t) => t.detected);
+    if (detectedTools.length === 0) {
+      d.log("No AI coding tools detected. You can specify tools manually with --tool.");
+      return;
+    }
+    d.log("");
+    d.log("Detected tools:");
+    for (const t of detected) {
+      const icon = t.detected ? "\u2713" : "\u2717";
+      d.log(`  ${icon} ${t.displayName}`);
+    }
+    d.log("");
+    toolIds = [];
+    try {
+      for (const t of detectedTools) {
+        if (t.configured) {
+          d.log(`  ${t.displayName}: already configured, skipping`);
+          continue;
+        }
+        const yes = await dist_default6({
+          message: `Configure ${t.displayName}?`,
+          default: true
+        });
+        if (yes) toolIds.push(t.id);
+      }
+    } catch (err) {
+      if (err instanceof ExitPromptError4) return;
+      throw err;
+    }
+    d.log("");
+  }
+  if (toolIds.length === 0) {
+    const anyDetected = detected.some((t) => t.detected);
+    if (!anyDetected) {
+      d.log("No AI coding tools detected. You can specify tools manually with --tool.");
+    } else {
+      d.log("No tools selected.");
+    }
+    return;
+  }
+  const toolMap = new Map(TOOL_REGISTRY.map((t) => [t.id, t]));
+  const results = [];
+  for (const id of toolIds) {
+    const tool = toolMap.get(id);
+    const result = await configureTool(tool, d);
+    results.push(result);
+    const icon = result.action === "configured" ? "\u2713" : result.action === "already-configured" ? "\u25CF" : "\u2717";
+    d.log(`${icon} ${result.displayName}: ${result.detail}`);
+  }
+  const configured = results.filter((r) => r.action === "configured").length;
+  const alreadyDone = results.filter((r) => r.action === "already-configured").length;
+  const failed = results.filter((r) => r.action === "failed").length;
+  const parts2 = [];
+  if (configured > 0) parts2.push(`${configured} configured`);
+  if (alreadyDone > 0) parts2.push(`${alreadyDone} already configured`);
+  if (failed > 0) parts2.push(`${failed} failed`);
+  d.log("");
+  d.log(`Done. ${parts2.join(", ")}.`);
+}
+
+// src/cli/commands/init-personas.ts
+init_templates();
+
+// src/docs/index.ts
+import * as fs18 from "fs";
+import * as path17 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function getDocsDir() {
+  const thisFile = fileURLToPath3(import.meta.url);
+  const packageRoot = path17.resolve(path17.dirname(thisFile), "..", "..");
+  return path17.join(packageRoot, "docs", "reference");
+}
+function parseFrontmatter(raw) {
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) {
+    return {
+      frontmatter: { name: "", description: "", keywords: [] },
+      body: raw
+    };
+  }
+  const fmBlock = fmMatch[1];
+  const body = fmMatch[2];
+  let name = "";
+  let description = "";
+  let keywords = [];
+  for (const line of fmBlock.split("\n")) {
+    const nameMatch = line.match(/^name:\s*(.+)$/);
+    if (nameMatch) {
+      name = nameMatch[1].trim();
+      continue;
+    }
+    const descMatch = line.match(/^description:\s*(.+)$/);
+    if (descMatch) {
+      description = descMatch[1].trim();
+      continue;
+    }
+    const kwMatch = line.match(/^keywords:\s*\[(.+)\]$/);
+    if (kwMatch) {
+      keywords = kwMatch[1].split(",").map((k) => k.trim().replace(/^['"]|['"]$/g, ""));
+      continue;
+    }
+  }
+  return { frontmatter: { name, description, keywords }, body };
+}
+function splitSections(body) {
+  const lines = body.split("\n");
+  const sections = [];
+  let currentHeading = "";
+  let currentLevel = 0;
+  let currentLines = [];
+  function flush() {
+    if (currentHeading || currentLines.length > 0) {
+      const content = currentLines.join("\n").trim();
+      const codeBlocks = [];
+      const codeRe = /```[\s\S]*?```/g;
+      let m;
+      while ((m = codeRe.exec(content)) !== null) {
+        codeBlocks.push(m[0]);
+      }
+      sections.push({
+        heading: currentHeading,
+        level: currentLevel,
+        content,
+        codeBlocks
+      });
+    }
+  }
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      flush();
+      currentLevel = headingMatch[1].length;
+      currentHeading = headingMatch[2];
+      currentLines = [];
+    } else {
+      currentLines.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
+function listTopics() {
+  const docsDir = getDocsDir();
+  if (!fs18.existsSync(docsDir)) return [];
+  const files = fs18.readdirSync(docsDir).filter((f) => f.endsWith(".md")).sort();
+  return files.map((file) => {
+    const raw = fs18.readFileSync(path17.join(docsDir, file), "utf-8");
+    const { frontmatter } = parseFrontmatter(raw);
+    return {
+      slug: file.replace(/\.md$/, ""),
+      name: frontmatter.name,
+      description: frontmatter.description,
+      keywords: frontmatter.keywords
+    };
+  });
+}
+function readTopic(slug, compact2) {
+  const docsDir = getDocsDir();
+  const filePath = path17.join(docsDir, `${slug}.md`);
+  if (!fs18.existsSync(filePath)) return null;
+  const raw = fs18.readFileSync(filePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(raw);
+  const content = compact2 ? buildCompactContent(frontmatter, body) : body.trim();
+  return {
+    slug,
+    name: frontmatter.name,
+    description: frontmatter.description,
+    keywords: frontmatter.keywords,
+    content
+  };
+}
+function readTopicStructured(slug) {
+  const docsDir = getDocsDir();
+  const filePath = path17.join(docsDir, `${slug}.md`);
+  if (!fs18.existsSync(filePath)) return null;
+  const raw = fs18.readFileSync(filePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(raw);
+  const sections = splitSections(body);
+  return {
+    slug,
+    name: frontmatter.name,
+    description: frontmatter.description,
+    keywords: frontmatter.keywords,
+    sections
+  };
+}
+function searchDocs(query) {
+  const topics = listTopics();
+  const docsDir = getDocsDir();
+  const queryLower = query.toLowerCase();
+  const queryTerms = queryLower.split(/\s+/).filter(Boolean);
+  const results = [];
+  for (const topic of topics) {
+    const keywordMatch = topic.keywords.some(
+      (kw) => queryTerms.some((term) => kw.toLowerCase().includes(term))
+    );
+    const filePath = path17.join(docsDir, `${topic.slug}.md`);
+    const raw = fs18.readFileSync(filePath, "utf-8");
+    const { body } = parseFrontmatter(raw);
+    const sections = splitSections(body);
+    for (const section of sections) {
+      const sectionLower = section.content.toLowerCase();
+      const headingLower = section.heading.toLowerCase();
+      let relevance = 0;
+      if (sectionLower.includes(queryLower)) {
+        relevance += 10;
+      }
+      for (const term of queryTerms) {
+        if (headingLower.includes(term)) relevance += 5;
+        if (sectionLower.includes(term)) relevance += 2;
+      }
+      if (keywordMatch) relevance += 3;
+      if (relevance > 0) {
+        const lines = section.content.split("\n");
+        const matchingLines = [];
+        for (const line of lines) {
+          if (queryTerms.some((term) => line.toLowerCase().includes(term))) {
+            matchingLines.push(line.trim());
+            if (matchingLines.length >= 3) break;
+          }
+        }
+        results.push({
+          topic: topic.name,
+          slug: topic.slug,
+          section: section.heading,
+          heading: section.heading,
+          excerpt: matchingLines.join("\n") || section.content.slice(0, 200),
+          relevance
+        });
+      }
+    }
+  }
+  results.sort((a, b) => b.relevance - a.relevance);
+  return results;
+}
+function buildCompactContent(frontmatter, body) {
+  const lines = body.split("\n");
+  const output = [];
+  output.push(`# ${frontmatter.name}`);
+  output.push(frontmatter.description);
+  output.push("");
+  let inCodeBlock = false;
+  let inTable = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      output.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      output.push(line);
+      continue;
+    }
+    if (line.match(/^#{1,6}\s/)) {
+      output.push("");
+      output.push(line);
+      continue;
+    }
+    if (line.trim().startsWith("|")) {
+      inTable = true;
+      output.push(line);
+      continue;
+    }
+    if (inTable && !line.trim().startsWith("|")) {
+      inTable = false;
+    }
+    if (line.trim().startsWith("- ") || line.trim().startsWith("* ") || line.trim().startsWith("> ")) {
+      output.push(line);
+      continue;
+    }
+  }
+  return output.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/context/index.ts
+init_grammar_diagrams();
+var PRESETS = {
+  core: ["concepts", "jsdoc-grammar", "tutorial"],
+  authoring: [
+    "concepts",
+    "jsdoc-grammar",
+    "advanced-annotations",
+    "built-in-nodes",
+    "scaffold",
+    "node-conversion",
+    "patterns"
+  ],
+  ops: [
+    "cli-reference",
+    "compilation",
+    "deployment",
+    "export-interface",
+    "debugging",
+    "error-codes"
+  ],
+  full: [
+    "concepts",
+    "tutorial",
+    "jsdoc-grammar",
+    "advanced-annotations",
+    "built-in-nodes",
+    "cli-reference",
+    "compilation",
+    "debugging",
+    "deployment",
+    "error-codes",
+    "export-interface",
+    "iterative-development",
+    "marketplace",
+    "node-conversion",
+    "patterns",
+    "scaffold"
+  ]
+};
+var PRESET_NAMES = Object.keys(PRESETS);
+var STANDALONE_PREAMBLE = `# Flow Weaver Reference
+
+Flow Weaver is a TypeScript workflow compiler. You write plain .ts files with
+JSDoc annotations (@flowWeaver nodeType, @flowWeaver workflow, @input, @output,
+@connect, @node, @scope). The compiler parses these annotations, validates the
+graph, and generates executable code inline. The source file is the workflow:
+no JSON configs, no YAML, no separate graph files.
+
+Key concepts: node types define reusable processing steps with typed input/output
+ports. Workflows instantiate nodes and connect their ports. Start and Exit are
+implicit boundary nodes. The compiler handles execution ordering, type checking,
+and code generation.`;
+function buildAssistantPreamble() {
+  const allSlugs = listTopics().map((t) => t.slug);
+  return `# Flow Weaver Context
+
+You have Flow Weaver MCP tools available (fw_ prefix). Use them to create,
+modify, validate, compile, and inspect workflows without manual file editing.
+
+For documentation not included below, call fw_docs(action="read", topic="<slug>").
+Available topic slugs: ${allSlugs.join(", ")}.
+
+Tool quick reference:
+- fw_create_model: Build workflow from structured description (steps + flow path)
+- fw_implement_node: Replace a declare stub with a real function body
+- fw_modify / fw_modify_batch: Add/remove nodes, connections, rename, reposition
+- fw_validate: Check for errors after any change
+- fw_describe: Inspect structure. Use format "text" for readable, "json" for data
+- fw_diagram: Visualize. Prefer format "ascii-compact" in chat contexts
+- fw_compile: Generate executable TypeScript from annotations
+- fw_docs: Look up reference docs by topic slug
+- fw_scaffold: Create from templates (sequential, foreach, ai-agent, etc.)
+
+File conventions: .ts extension, camelCase node names, PascalCase workflow names.`;
+}
+function resolveTopics(preset, explicit, add) {
+  const base = explicit ?? PRESETS[preset];
+  const combined = add ? [...base, ...add] : base;
+  return [...new Set(combined)];
+}
+function buildGrammarSection() {
+  const grammars = getAllGrammars();
+  const allProductions = [
+    ...grammars.port,
+    ...grammars.node,
+    ...grammars.connect,
+    ...grammars.position,
+    ...grammars.scope
+  ];
+  const ebnf = serializedToEBNF(allProductions);
+  return `## JSDoc Annotation Grammar (EBNF)
+
+\`\`\`ebnf
+${ebnf}
+\`\`\``;
+}
+function buildContext(options = {}) {
+  const profile = options.profile ?? "standalone";
+  const preset = options.preset ?? "core";
+  const includeGrammar = options.includeGrammar ?? true;
+  const topicSlugs = resolveTopics(preset, options.topics, options.addTopics);
+  const sections = [];
+  if (profile === "standalone") {
+    sections.push(STANDALONE_PREAMBLE);
+  } else {
+    sections.push(buildAssistantPreamble());
+  }
+  if (includeGrammar) {
+    sections.push(buildGrammarSection());
+  }
+  let topicCount = 0;
+  const includedSlugs = [];
+  for (const slug of topicSlugs) {
+    const doc = readTopic(slug, true);
+    if (!doc) continue;
+    let body = doc.content;
+    if (body.startsWith("# ")) {
+      const lines = body.split("\n");
+      let startLine = 1;
+      if (lines.length > 1 && lines[1].trim() && !lines[1].startsWith("#")) {
+        startLine = 2;
+      }
+      body = lines.slice(startLine).join("\n").replace(/^\n+/, "");
+    }
+    const bodyLines = body.split("\n");
+    let inCode = false;
+    for (let i = 0; i < bodyLines.length; i++) {
+      if (bodyLines[i].trimStart().startsWith("```")) {
+        inCode = !inCode;
+        continue;
+      }
+      if (!inCode && bodyLines[i].match(/^#{1,5}\s/)) {
+        bodyLines[i] = "##" + bodyLines[i];
+      }
+    }
+    body = bodyLines.join("\n");
+    const heading = doc.name || slug;
+    sections.push(`## ${heading}
+
+${body}`);
+    topicCount++;
+    includedSlugs.push(slug);
+  }
+  const content = sections.join("\n\n---\n\n");
+  const lineCount = content.split("\n").length;
+  return {
+    content,
+    topicCount,
+    lineCount,
+    topicSlugs: includedSlugs,
+    profile
+  };
+}
+
+// src/cli/commands/init-personas.ts
+var PERSONA_CHOICES = [
+  { value: "nocode", name: "AI does everything", description: "Describe in plain language, AI builds the workflow. Guided setup included." },
+  { value: "vibecoder", name: "AI-assisted coding", description: "Collaborate with AI, iterate by describing changes. Hands-on setup with AI." },
+  { value: "lowcode", name: "Template-based", description: "Pick a template, customize the code. AI helps with initial setup." },
+  { value: "expert", name: "Full TypeScript", description: "Write workflows from scratch. Minimal setup, full control." }
+];
+var PERSONA_CONFIRMATIONS = {
+  nocode: "AI will handle the code. You describe, it builds.",
+  vibecoder: "You and AI will build this together.",
+  lowcode: "Starting from a template, you customize from there.",
+  expert: null
+};
+var USE_CASE_CHOICES = [
+  { value: "data", name: "Data pipeline", description: "Process, transform, and validate data" },
+  { value: "ai", name: "AI agent", description: "LLM with tools, reasoning, or retrieval" },
+  { value: "api", name: "API / webhook", description: "HTTP endpoints and integrations" },
+  { value: "automation", name: "Automation", description: "Conditional logic, error handling, routing" },
+  { value: "cicd", name: "CI/CD pipeline", description: "Test, build, and deploy workflows" },
+  { value: "minimal", name: "Something else", description: "Start with a minimal template" }
+];
+var USE_CASE_TEMPLATES = {
+  data: { default: "sequential", all: ["sequential", "foreach", "aggregator"] },
+  ai: { default: "ai-agent", all: ["ai-agent", "ai-react", "ai-rag", "ai-chat"] },
+  api: { default: "webhook", all: ["webhook"] },
+  automation: { default: "conditional", all: ["conditional", "error-handler"] },
+  cicd: { default: "cicd-test-deploy", all: ["cicd-test-deploy", "cicd-docker", "cicd-multi-env", "cicd-matrix"] },
+  minimal: { default: "sequential", all: ["sequential"] }
+};
+function selectTemplateForPersona(persona, useCase) {
+  const mapping = USE_CASE_TEMPLATES[useCase];
+  if (!mapping) {
+    return { template: "sequential" };
+  }
+  if (persona === "lowcode" && mapping.all.length > 1) {
+    return { template: mapping.default, choices: mapping.all };
+  }
+  return { template: mapping.default };
+}
+function getTemplateSubChoices(templateIds) {
+  return templateIds.map((id) => {
+    const tmpl = workflowTemplates.find((t) => t.id === id);
+    return {
+      value: id,
+      name: id,
+      description: tmpl?.description ?? ""
+    };
+  });
+}
+function extractWorkflowPreview(workflowCode) {
+  const pathMatches = workflowCode.match(/@path\s+(.+)/g);
+  if (pathMatches && pathMatches.length > 0) {
+    const raw = pathMatches[0].replace(/@path\s+/, "").trim();
+    const steps = raw.split(/\s*->\s*/);
+    const labelMap = buildLabelMap(workflowCode);
+    const labeled = steps.map((step) => labelMap.get(step) ?? step);
+    return labeled.join(" \u2500\u2500\u25B6 ");
+  }
+  const nodeAnnotations = workflowCode.match(/@node\s+(\w+)\s+\w+/g);
+  if (nodeAnnotations && nodeAnnotations.length > 0) {
+    const labelMap = buildLabelMap(workflowCode);
+    const names = nodeAnnotations.map((m) => {
+      const id = m.replace(/@node\s+/, "").split(/\s+/)[0];
+      return labelMap.get(id) ?? id;
+    });
+    return ["Start", ...names, "Exit"].join(" \u2500\u2500\u25B6 ");
+  }
+  return null;
+}
+function buildLabelMap(code) {
+  const map3 = /* @__PURE__ */ new Map();
+  map3.set("Start", "Start");
+  map3.set("Exit", "Exit");
+  const nodeRegex = /@node\s+(\w+)\s+(\w+)/g;
+  const instanceToType = /* @__PURE__ */ new Map();
+  let match2;
+  while ((match2 = nodeRegex.exec(code)) !== null) {
+    instanceToType.set(match2[1], match2[2]);
+  }
+  const labelRegex = /@label\s+(.+)\n[\s\S]*?function\s+(\w+)/g;
+  const typeToLabel = /* @__PURE__ */ new Map();
+  while ((match2 = labelRegex.exec(code)) !== null) {
+    typeToLabel.set(match2[2], match2[1].trim());
+  }
+  for (const [instanceId, typeName] of instanceToType) {
+    const label = typeToLabel.get(typeName);
+    if (label) {
+      map3.set(instanceId, label);
+    }
+  }
+  return map3;
+}
+var FILE_DESCRIPTIONS = {
+  "package.json": "Dependencies and npm scripts",
+  "tsconfig.json": "TypeScript configuration",
+  ".gitignore": "Git ignore rules",
+  ".flowweaver/config.yaml": "Flow Weaver project settings",
+  "src/main.ts": "Runs the workflow with sample input"
+};
+function workflowFileDesc(persona) {
+  if (persona === "nocode") return "Your workflow (AI will modify this for you)";
+  return "Your workflow definition";
+}
+function generateReadme(projectName, persona, _template) {
+  const lines = [`# ${projectName}`, ""];
+  if (persona === "nocode") {
+    lines.push(
+      "A Flow Weaver workflow project configured for AI-assisted development.",
+      "",
+      "## Working with AI",
+      "",
+      "Open this project in your AI editor (Claude Code, Cursor, VS Code) and describe",
+      "what you want to build:",
+      "",
+      '- "Create a workflow that processes customer orders"',
+      '- "Add retry logic to the data pipeline"',
+      '- "Show me a diagram of the current workflow"',
+      "",
+      "The AI has access to Flow Weaver's 48 tools and will create, modify, and validate",
+      "workflows for you.",
+      ""
+    );
+  } else if (persona === "vibecoder") {
+    lines.push(
+      "A Flow Weaver workflow project.",
+      "",
+      "## Development",
+      "",
+      "```sh",
+      "npm run dev       # Compile and run",
+      "npm run compile   # Compile only",
+      "npm run validate  # Check for errors",
+      "```",
+      "",
+      "## AI-Assisted Editing",
+      "",
+      "With your AI editor connected, you can describe changes in plain language:",
+      "",
+      '- "Add error handling to the pipeline"',
+      '- "Replace the mock LLM with OpenAI"',
+      '- "Add a validation step before processing"',
+      ""
+    );
+  } else if (persona === "lowcode") {
+    lines.push(
+      "A Flow Weaver workflow project.",
+      "",
+      "## Development",
+      "",
+      "```sh",
+      "npm run dev       # Compile and run",
+      "npm run compile   # Compile only",
+      "npm run validate  # Check for errors",
+      "```",
+      "",
+      "## Templates",
+      "",
+      "Browse and add more workflows:",
+      "",
+      "```sh",
+      "flow-weaver templates                         # List all templates",
+      "flow-weaver create workflow <template> <file>  # Add a workflow",
+      "flow-weaver describe src/*.ts --format ascii   # See workflow structure",
+      "```",
+      ""
+    );
+  } else {
+    lines.push(
+      "A Flow Weaver workflow project.",
+      "",
+      "## Commands",
+      "",
+      "```sh",
+      "npm run dev       # Compile and run",
+      "npm run compile   # Compile only",
+      "npm run validate  # Check for errors",
+      "```",
+      ""
+    );
+  }
+  lines.push(
+    "## Learn more",
+    "",
+    "- `flow-weaver docs` to browse reference documentation",
+    "- `flow-weaver mcp-setup` to connect AI editors",
+    ""
+  );
+  return lines.join("\n");
+}
+function generateExampleWorkflow(projectName) {
+  const name = projectName.replace(/[-_.]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[^a-zA-Z_$]+/, "").replace(/^./, (c) => c.toLowerCase());
+  const fnName = (name || "example") + "Example";
+  return `/**
+ * Example: a minimal workflow to study and experiment with.
+ * Copy patterns from here into your main workflow.
+ */
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Greet
+ * @input name [order:0] - Name to greet
+ * @output greeting [order:0] - Greeting message
+ */
+function greet(name: string): { greeting: string } {
+  return { greeting: \`Hello, \${name}!\` };
+}
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Uppercase
+ * @input text [order:0] - Text to uppercase
+ * @output result [order:0] - Uppercased text
+ */
+function uppercase(text: string): { result: string } {
+  return { result: text.toUpperCase() };
+}
+
+/**
+ * @flowWeaver workflow
+ * @node greeter greet [position: -200 0]
+ * @node upper uppercase [position: 100 0]
+ * @position Start -500 0
+ * @position Exit 400 0
+ * @path Start -> greeter -> upper -> Exit
+ * @connect greeter.greeting -> upper.text
+ * @param execute [order:0] - Execute
+ * @param name [order:1] - Name to greet
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns result [order:2] - Final greeting
+ */
+export function ${fnName}(
+  execute: boolean,
+  params: { name: string }
+): { onSuccess: boolean; onFailure: boolean; result: string } {
+  throw new Error("Compile with: flow-weaver compile <file>");
+}
+`;
+}
+function printNextSteps(opts) {
+  const { projectName, persona, displayDir, installSkipped, workflowCode, workflowFile, agentLaunched } = opts;
+  if (workflowCode) {
+    const preview = extractWorkflowPreview(workflowCode);
+    if (preview) {
+      logger.newline();
+      logger.log(`  ${logger.bold("Your workflow")}`);
+      logger.newline();
+      logger.log(`    ${logger.dim(preview)}`);
+    }
+  }
+  if (persona !== "expert") {
+    logger.newline();
+    logger.log(`  ${logger.bold("Project files")}`);
+    logger.newline();
+    const wfDesc = workflowFileDesc(persona);
+    logger.log(`    ${logger.highlight(`src/${workflowFile}`)}${pad(`src/${workflowFile}`, 32)}${wfDesc}`);
+    logger.log(`    ${logger.highlight("src/main.ts")}${pad("src/main.ts", 32)}${FILE_DESCRIPTIONS["src/main.ts"]}`);
+    logger.log(`    ${logger.highlight("package.json")}${pad("package.json", 32)}${FILE_DESCRIPTIONS["package.json"]}`);
+    logger.log(`    ${logger.highlight("tsconfig.json")}${pad("tsconfig.json", 32)}${FILE_DESCRIPTIONS["tsconfig.json"]}`);
+  }
+  logger.newline();
+  logger.log(`  ${logger.bold("Next steps")}`);
+  logger.newline();
+  if (displayDir) {
+    logger.log(`    cd ${displayDir}`);
+  }
+  if (installSkipped) {
+    logger.log("    npm install");
+  }
+  logger.log("    npm run dev");
+  if (!agentLaunched) {
+    if (persona === "nocode") {
+      printNocodeGuidance(projectName);
+    } else if (persona === "vibecoder") {
+      printVibecoderGuidance();
+    } else if (persona === "lowcode") {
+      printLowcodeGuidance();
+    } else {
+      printExpertGuidance();
+    }
+  }
+  logger.newline();
+}
+function printNocodeGuidance(_projectName) {
+  logger.newline();
+  logger.log(`  ${logger.bold("Your project is ready for AI-assisted building.")}`);
+  logger.log("  Open it in your AI editor and describe what you want:");
+  logger.newline();
+  logger.log(`    ${logger.dim('"Change this to fetch data from an API and validate the response"')}`);
+  logger.log(`    ${logger.dim('"Add error handling so failures get logged and retried"')}`);
+  logger.log(`    ${logger.dim('"Show me a diagram of my workflow"')}`);
+  logger.newline();
+  logger.log(`  ${logger.bold("Useful commands")}`);
+  logger.newline();
+  logger.log(`    flow-weaver run src/*.ts         ${logger.dim("Run your workflow")}`);
+  logger.log(`    flow-weaver diagram src/*.ts     ${logger.dim("See a visual diagram")}`);
+  logger.log(`    flow-weaver mcp-setup            ${logger.dim("Connect more AI editors")}`);
+}
+function printVibecoderGuidance() {
+  logger.newline();
+  logger.log("  With your AI editor connected, try:");
+  logger.newline();
+  logger.log(`    ${logger.dim('"Add a retry loop when the model call fails"')}`);
+  logger.log(`    ${logger.dim('"Add a tool that searches a knowledge base"')}`);
+  logger.newline();
+  logger.log(`  ${logger.bold("Commands you'll use")}`);
+  logger.newline();
+  logger.log(`    flow-weaver diagram src/*.ts     ${logger.dim("See a visual diagram")}`);
+  logger.log(`    flow-weaver validate src/*.ts    ${logger.dim("Check for errors")}`);
+  logger.log(`    flow-weaver templates            ${logger.dim("Browse all templates")}`);
+}
+function printLowcodeGuidance() {
+  logger.newline();
+  logger.log(`  ${logger.bold("Explore and learn")}`);
+  logger.newline();
+  logger.log(`    flow-weaver templates            ${logger.dim("List all 16 workflow templates")}`);
+  logger.log(`    flow-weaver create workflow ...   ${logger.dim("Add another workflow")}`);
+  logger.log(`    flow-weaver describe src/*.ts     ${logger.dim("See workflow structure")}`);
+  logger.log(`    flow-weaver docs annotations     ${logger.dim("Read the annotation reference")}`);
+  logger.newline();
+  logger.log(`  Your project includes an example in ${logger.highlight("examples/")} to study.`);
+}
+function printExpertGuidance() {
+  logger.newline();
+  logger.log(`    flow-weaver mcp-setup            ${logger.dim("Connect AI editors (Claude, Cursor, VS Code)")}`);
+  logger.log(`    flow-weaver docs                 ${logger.dim("Browse reference docs")}`);
+}
+function pad(displayName, width) {
+  const padding = Math.max(1, width - displayName.length);
+  return " ".repeat(padding);
+}
+var AGENT_CONTEXT_PRESETS = {
+  nocode: "core",
+  vibecoder: "authoring",
+  lowcode: "authoring",
+  expert: "authoring"
+};
+var AGENT_PROMPTS = {
+  nocode: `Before doing anything else, call fw_context(preset="core", profile="assistant") to learn Flow Weaver's annotation syntax and workflow conventions.
+
+I just created a new Flow Weaver project called "{name}" using the {template} template.
+Help me set it up step by step:
+
+1. Show the current workflow as a diagram (use fw_diagram, ascii-compact)
+2. Walk me through what each step does in plain language
+3. Ask me what I want this workflow to do
+4. Based on my answer:
+   - Customize the workflow (add/remove/rename steps with fw_modify)
+   - Implement each step with real working code (fw_implement_node)
+   - Set up supporting files if needed (.env template, basic tests)
+5. Show the final result as a step list and diagram
+
+Keep everything in plain language. Don't show code unless I ask.`,
+  vibecoder: `Before doing anything else, call fw_context(preset="authoring", profile="assistant") to load Flow Weaver reference.
+
+I just created a new Flow Weaver project called "{name}" using the {template} template.
+Let's set it up together:
+
+1. Show the workflow diagram and briefly explain the structure
+2. Ask what I want to build, then iterate with me
+3. Customize the workflow, implement the nodes, add supporting files
+4. Show code when it's relevant, I'm comfortable reading and tweaking it
+5. Show the final diagram when we're done`,
+  lowcode: `Before doing anything else, call fw_context(preset="authoring", profile="assistant") to load Flow Weaver reference.
+
+I just created a new Flow Weaver project called "{name}" using the {template} template.
+Help me customize it:
+
+1. Show the workflow diagram and explain what the template gives me
+2. Ask what I want this workflow to do
+3. Customize: rename nodes, adjust connections, implement the functions
+4. Add supporting files if needed (.env, tests)
+5. Show the final diagram
+
+I prefer working from templates and making targeted changes.`,
+  expert: `Before doing anything else, call fw_context(preset="authoring", profile="assistant") to load Flow Weaver reference.
+
+New Flow Weaver project "{name}" (template: {template}).
+Show the workflow diagram and current implementation status (fw_workflow_status).
+Then ask what I'd like to build.`
+};
+function generateAgentPrompt(projectName, persona, template) {
+  return AGENT_PROMPTS[persona].replace(/\{name\}/g, projectName).replace(/\{template\}/g, template);
+}
+function generateEditorPrompt(projectName, persona, template) {
+  const preset = AGENT_CONTEXT_PRESETS[persona];
+  const bootstrap = `Start by calling fw_context(preset="${preset}", profile="assistant") to learn Flow Weaver.`;
+  if (persona === "nocode") {
+    return `${bootstrap}
+This is a Flow Weaver project called "${projectName}" using the ${template} template. Show me the workflow diagram, walk me through what each step does in plain language, then ask me what I want to build. Keep it simple, no code.`;
+  }
+  if (persona === "vibecoder") {
+    return `${bootstrap}
+This is a Flow Weaver project called "${projectName}" using the ${template} template. Show me the workflow diagram, then let's iterate on it together. I'll describe what I want and you handle the implementation.`;
+  }
+  if (persona === "lowcode") {
+    return `${bootstrap}
+This is a Flow Weaver project called "${projectName}" using the ${template} template. Show me the workflow diagram and explain the template, then help me customize it for my use case.`;
+  }
+  return `${bootstrap}
+Flow Weaver project "${projectName}" (template: ${template}). Show the workflow diagram and implementation status.`;
+}
+function generateSetupPromptFile(projectName, persona, template, filesCreated) {
+  const prompt = generateAgentPrompt(projectName, persona, template);
+  const contextResult = buildContext({ preset: "core", profile: "assistant" });
+  const lines = [
+    `# ${projectName} Setup`,
+    "",
+    'Paste this into your AI editor chat, or ask it to "follow the instructions in PROJECT_SETUP.md".',
+    "",
+    "---",
+    "",
+    prompt,
+    "",
+    "---",
+    "",
+    "## Flow Weaver Reference",
+    "",
+    "The following is embedded Flow Weaver documentation so you can work with this project",
+    "even before MCP tools are connected. For deeper topics, call `fw_docs` once MCP is available.",
+    "",
+    contextResult.content,
+    "",
+    "---",
+    "",
+    "## Project context",
+    "",
+    `- **Template**: ${template}`,
+    `- **Persona**: ${persona}`,
+    "",
+    "### Files created",
+    "",
+    ...filesCreated.map((f) => `- \`${f}\``),
+    "",
+    "### Available Flow Weaver MCP tools",
+    "",
+    "Your AI editor has access to 48 Flow Weaver tools including:",
+    "- `fw_diagram` - Generate workflow diagrams",
+    "- `fw_modify` / `fw_modify_batch` - Add/remove/rename nodes and connections",
+    "- `fw_implement_node` - Write function bodies for stub nodes",
+    "- `fw_validate` - Check for errors",
+    "- `fw_compile` - Generate executable code",
+    "- `fw_describe` - Inspect workflow structure",
+    "",
+    "*Delete this file after your initial setup is complete.*",
+    ""
+  ];
+  return lines.join("\n");
+}
+function printCopyablePrompt(prompt) {
+  const maxInner = 70;
+  const wrapped = [];
+  for (const raw of prompt.split("\n")) {
+    if (raw.length <= maxInner) {
+      wrapped.push(raw);
+    } else {
+      let remaining = raw;
+      while (remaining.length > maxInner) {
+        let breakAt = remaining.lastIndexOf(" ", maxInner);
+        if (breakAt <= 0) breakAt = maxInner;
+        wrapped.push(remaining.slice(0, breakAt));
+        remaining = remaining.slice(breakAt).replace(/^ /, "");
+      }
+      if (remaining) wrapped.push(remaining);
+    }
+  }
+  const width = maxInner + 2;
+  logger.newline();
+  logger.log(`  ${logger.bold("Paste this into your AI editor to get started:")}`);
+  logger.newline();
+  logger.log(`  ${"\u250C" + "\u2500".repeat(width) + "\u2510"}`);
+  for (const line of wrapped) {
+    const padded = line + " ".repeat(Math.max(0, maxInner - line.length));
+    logger.log(`  \u2502 ${padded} \u2502`);
+  }
+  logger.log(`  ${"\u2514" + "\u2500".repeat(width) + "\u2518"}`);
+}
+var AGENT_LAUNCH_DEFAULTS = {
+  nocode: true,
+  vibecoder: true,
+  lowcode: true,
+  expert: false
+};
+
+// src/cli/commands/init.ts
 var PROJECT_NAME_RE = /^[a-zA-Z0-9][-a-zA-Z0-9_.]*$/;
 function validateProjectName(name) {
   if (!name) return "Project name cannot be empty";
@@ -80787,14 +82001,17 @@ function isNonInteractive() {
   return !process.stdin.isTTY;
 }
 var VALID_TEMPLATES = workflowTemplates.map((t) => t.id);
+var VALID_PERSONAS = ["nocode", "vibecoder", "lowcode", "expert"];
+var VALID_USE_CASES = ["data", "ai", "api", "automation", "cicd", "minimal"];
 async function resolveInitConfig(dirArg, options) {
   const skipPrompts = options.yes || isNonInteractive();
   const force = options.force ?? false;
+  const hasExplicitTemplate = !!options.template;
   let projectName;
   if (options.name) {
     projectName = options.name;
   } else if (dirArg) {
-    projectName = path16.basename(dirArg);
+    projectName = path18.basename(dirArg);
   } else if (skipPrompts) {
     projectName = "my-project";
   } else {
@@ -80808,49 +82025,113 @@ async function resolveInitConfig(dirArg, options) {
   if (valid !== true) {
     throw new Error(valid);
   }
-  const targetDir = path16.resolve(dirArg ?? projectName);
+  const targetDir = path18.resolve(dirArg ?? projectName);
+  let persona;
+  if (options.preset) {
+    if (!VALID_PERSONAS.includes(options.preset)) {
+      throw new Error(`Unknown preset "${options.preset}". Available: ${VALID_PERSONAS.join(", ")}`);
+    }
+    persona = options.preset;
+  } else if (skipPrompts || hasExplicitTemplate) {
+    persona = "expert";
+  } else {
+    persona = await dist_default5({
+      message: "How do you plan to build?",
+      choices: PERSONA_CHOICES,
+      default: "vibecoder"
+    });
+  }
+  if (!skipPrompts) {
+    const confirmation = PERSONA_CONFIRMATIONS[persona];
+    if (confirmation) {
+      logger.log(`  ${logger.dim(confirmation)}`);
+      logger.newline();
+    }
+  }
   let template;
-  if (options.template) {
+  let useCase;
+  if (hasExplicitTemplate) {
     template = options.template;
     if (!VALID_TEMPLATES.includes(template)) {
       throw new Error(`Unknown template "${template}". Available: ${VALID_TEMPLATES.join(", ")}`);
     }
-  } else if (skipPrompts) {
-    template = "sequential";
+  } else if (persona === "expert") {
+    if (skipPrompts) {
+      template = "sequential";
+    } else {
+      template = await dist_default5({
+        message: "Workflow template:",
+        choices: [
+          new Separator("\u2500\u2500 Data Processing \u2500\u2500"),
+          { value: "sequential", name: "sequential", description: "Linear pipeline" },
+          { value: "foreach", name: "foreach", description: "Batch iteration" },
+          { value: "aggregator", name: "aggregator", description: "Collect and aggregate results" },
+          new Separator("\u2500\u2500 Automation \u2500\u2500"),
+          { value: "conditional", name: "conditional", description: "Route by condition" },
+          new Separator("\u2500\u2500 AI \u2500\u2500"),
+          { value: "ai-agent", name: "ai-agent", description: "LLM agent with tool calling" },
+          { value: "ai-react", name: "ai-react", description: "ReAct pattern" },
+          { value: "ai-rag", name: "ai-rag", description: "Retrieval-Augmented Generation" },
+          { value: "ai-chat", name: "ai-chat", description: "Conversational AI" },
+          new Separator("\u2500\u2500 Durable \u2500\u2500"),
+          { value: "ai-agent-durable", name: "ai-agent-durable", description: "Durable agent with approval gate" },
+          { value: "ai-pipeline-durable", name: "ai-pipeline-durable", description: "Durable data pipeline" },
+          new Separator("\u2500\u2500 Integration \u2500\u2500"),
+          { value: "webhook", name: "webhook", description: "HTTP webhook handler" },
+          new Separator("\u2500\u2500 Utility \u2500\u2500"),
+          { value: "error-handler", name: "error-handler", description: "Error handling and recovery" },
+          new Separator("\u2500\u2500 CI/CD \u2500\u2500"),
+          { value: "cicd-test-deploy", name: "cicd-test-deploy", description: "Test and deploy pipeline" },
+          { value: "cicd-docker", name: "cicd-docker", description: "Docker build and push" },
+          { value: "cicd-multi-env", name: "cicd-multi-env", description: "Multi-environment deploy" },
+          { value: "cicd-matrix", name: "cicd-matrix", description: "Matrix build strategy" }
+        ],
+        default: "sequential"
+      });
+    }
   } else {
-    template = await dist_default5({
-      message: "Workflow template:",
-      choices: [
-        new Separator("\u2500\u2500 Data Processing \u2500\u2500"),
-        { value: "sequential", name: "sequential", description: "Linear pipeline" },
-        { value: "foreach", name: "foreach", description: "Batch iteration" },
-        { value: "aggregator", name: "aggregator", description: "Collect and aggregate results" },
-        new Separator("\u2500\u2500 Automation \u2500\u2500"),
-        { value: "conditional", name: "conditional", description: "Route by condition" },
-        new Separator("\u2500\u2500 AI \u2500\u2500"),
-        { value: "ai-agent", name: "ai-agent", description: "LLM agent with tool calling" },
-        { value: "ai-react", name: "ai-react", description: "ReAct pattern" },
-        { value: "ai-rag", name: "ai-rag", description: "Retrieval-Augmented Generation" },
-        { value: "ai-chat", name: "ai-chat", description: "Conversational AI" },
-        new Separator("\u2500\u2500 Durable \u2500\u2500"),
-        { value: "ai-agent-durable", name: "ai-agent-durable", description: "Durable agent with approval gate" },
-        { value: "ai-pipeline-durable", name: "ai-pipeline-durable", description: "Durable data pipeline" },
-        new Separator("\u2500\u2500 Integration \u2500\u2500"),
-        { value: "webhook", name: "webhook", description: "HTTP webhook handler" },
-        new Separator("\u2500\u2500 Utility \u2500\u2500"),
-        {
-          value: "error-handler",
-          name: "error-handler",
-          description: "Error handling and recovery"
-        }
-      ],
-      default: "sequential"
+    if (options.useCase) {
+      if (!VALID_USE_CASES.includes(options.useCase)) {
+        throw new Error(`Unknown use case "${options.useCase}". Available: ${VALID_USE_CASES.join(", ")}`);
+      }
+      useCase = options.useCase;
+    } else if (skipPrompts) {
+      useCase = "data";
+    } else {
+      useCase = await dist_default5({
+        message: "What are you building?",
+        choices: USE_CASE_CHOICES,
+        default: "data"
+      });
+    }
+    const selection = selectTemplateForPersona(persona, useCase);
+    if (selection.choices && !skipPrompts) {
+      template = await dist_default5({
+        message: "Pick a template:",
+        choices: getTemplateSubChoices(selection.choices),
+        default: selection.template
+      });
+    } else {
+      template = selection.template;
+    }
+  }
+  let mcp;
+  if (options.mcp !== void 0) {
+    mcp = options.mcp;
+  } else if (skipPrompts) {
+    mcp = false;
+  } else if (persona === "nocode" || persona === "vibecoder") {
+    mcp = await dist_default6({
+      message: "Set up AI editor integration? (Claude Code, Cursor, VS Code, etc.)",
+      default: true
     });
+  } else {
+    mcp = false;
   }
   let installDeps;
   if (options.install !== void 0) {
     installDeps = options.install;
-  } else if (skipPrompts) {
+  } else if (skipPrompts || persona !== "expert") {
     installDeps = true;
   } else {
     installDeps = await dist_default6({ message: "Install dependencies (npm install)?", default: true });
@@ -80858,7 +82139,7 @@ async function resolveInitConfig(dirArg, options) {
   let gitInit;
   if (options.git !== void 0) {
     gitInit = options.git;
-  } else if (skipPrompts) {
+  } else if (skipPrompts || persona !== "expert") {
     gitInit = true;
   } else {
     gitInit = await dist_default6({ message: "Initialize a git repository?", default: true });
@@ -80869,22 +82150,14 @@ async function resolveInitConfig(dirArg, options) {
     if (format !== "esm" && format !== "cjs") {
       throw new Error(`Invalid format "${format}". Use "esm" or "cjs".`);
     }
-  } else if (skipPrompts) {
+  } else if (skipPrompts || persona !== "expert") {
     format = "esm";
   } else {
     format = await dist_default5({
       message: "Module format:",
       choices: [
-        {
-          value: "esm",
-          name: "ESM (Recommended)",
-          description: "ECMAScript modules (import/export)"
-        },
-        {
-          value: "cjs",
-          name: "CommonJS",
-          description: "CommonJS modules (require/module.exports)"
-        }
+        { value: "esm", name: "ESM (Recommended)", description: "ECMAScript modules (import/export)" },
+        { value: "cjs", name: "CommonJS", description: "CommonJS modules (require/module.exports)" }
       ],
       default: "esm"
     });
@@ -80896,10 +82169,13 @@ async function resolveInitConfig(dirArg, options) {
     format,
     install: installDeps,
     git: gitInit,
-    force
+    force,
+    persona,
+    useCase,
+    mcp
   };
 }
-function generateProjectFiles(projectName, template, format = "esm") {
+function generateProjectFiles(projectName, template, format = "esm", persona = "expert") {
   const workflowName = toWorkflowName(projectName);
   const workflowFile = `${projectName}-workflow.ts`;
   const tmpl = getWorkflowTemplate(template);
@@ -80907,16 +82183,20 @@ function generateProjectFiles(projectName, template, format = "esm") {
     throw new Error(`Unknown template "${template}"`);
   }
   const workflowCode = tmpl.generate({ workflowName });
+  const scripts = {
+    dev: `npx flow-weaver compile src/${workflowFile} -o src && npx tsx src/main.ts`,
+    start: "npx tsx src/main.ts",
+    compile: `npx flow-weaver compile src/${workflowFile} -o src`,
+    validate: `npx flow-weaver validate src/${workflowFile}`,
+    doctor: "npx flow-weaver doctor"
+  };
+  if (persona !== "expert") {
+    scripts.diagram = `npx flow-weaver diagram src/${workflowFile} --format ascii-compact`;
+  }
   const packageJsonContent = {
     name: projectName,
     version: "1.0.0",
-    scripts: {
-      dev: `npx flow-weaver compile src/${workflowFile} -o src && npx tsx src/main.ts`,
-      start: "npx tsx src/main.ts",
-      compile: `npx flow-weaver compile src/${workflowFile} -o src`,
-      validate: `npx flow-weaver validate src/${workflowFile}`,
-      doctor: "npx flow-weaver doctor"
-    },
+    scripts,
     dependencies: {
       "@synergenius/flow-weaver": "latest"
     },
@@ -81004,7 +82284,7 @@ dist/
 `;
   const configYaml = `defaultFileType: ts
 `;
-  return {
+  const files = {
     "package.json": packageJson,
     "tsconfig.json": tsconfigJson,
     [`src/${workflowFile}`]: workflowCode,
@@ -81012,26 +82292,31 @@ dist/
     ".gitignore": gitignore,
     ".flowweaver/config.yaml": configYaml
   };
+  files["README.md"] = generateReadme(projectName, persona, template);
+  if (persona === "lowcode") {
+    files["examples/example-workflow.ts"] = generateExampleWorkflow(projectName);
+  }
+  return files;
 }
 function scaffoldProject(targetDir, files, options) {
   const filesCreated = [];
   const filesSkipped = [];
   for (const [relativePath, content] of Object.entries(files)) {
-    const absPath = path16.join(targetDir, relativePath);
-    const dir = path16.dirname(absPath);
-    fs17.mkdirSync(dir, { recursive: true });
-    if (fs17.existsSync(absPath) && !options.force) {
+    const absPath = path18.join(targetDir, relativePath);
+    const dir = path18.dirname(absPath);
+    fs19.mkdirSync(dir, { recursive: true });
+    if (fs19.existsSync(absPath) && !options.force) {
       filesSkipped.push(relativePath);
       continue;
     }
-    fs17.writeFileSync(absPath, content, "utf8");
+    fs19.writeFileSync(absPath, content, "utf8");
     filesCreated.push(relativePath);
   }
   return { filesCreated, filesSkipped };
 }
 function runNpmInstall(targetDir) {
   try {
-    execSync2("npm install", { cwd: targetDir, stdio: "pipe", timeout: 12e4 });
+    execSync3("npm install", { cwd: targetDir, stdio: "pipe", timeout: 12e4 });
     return { success: true };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -81040,23 +82325,83 @@ function runNpmInstall(targetDir) {
 }
 function runGitInit(targetDir) {
   try {
-    execSync2("git init", { cwd: targetDir, stdio: "pipe", timeout: 1e4 });
+    execSync3("git init", { cwd: targetDir, stdio: "pipe", timeout: 1e4 });
     return { success: true };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { success: false, error: message };
   }
 }
+async function handleAgentHandoff(opts) {
+  const { projectName, persona, template, targetDir, cliTools, guiTools, filesCreated } = opts;
+  if (cliTools.length > 0) {
+    const toolId = cliTools[0];
+    const binary2 = CLI_TOOL_BINARY[toolId];
+    const displayName = toolId === "claude" ? "Claude Code" : "Codex";
+    const launchDefault = AGENT_LAUNCH_DEFAULTS[persona];
+    const shouldLaunch = await dist_default6({
+      message: `Launch ${displayName} to set up your project?`,
+      default: launchDefault
+    });
+    if (shouldLaunch && binary2) {
+      const prompt = generateAgentPrompt(projectName, persona, template);
+      logger.newline();
+      logger.log(`  ${logger.dim(`Starting ${displayName}...`)}`);
+      logger.newline();
+      const child = spawn(binary2, [prompt], {
+        cwd: targetDir,
+        stdio: "inherit",
+        env: { ...process.env }
+      });
+      child.on("error", (err) => {
+        logger.error(`Failed to start ${displayName}: ${err.message}`);
+      });
+      return true;
+    }
+  }
+  if (guiTools.length > 0 || cliTools.length > 0) {
+    const promptAction = await dist_default5({
+      message: "Generate a setup prompt for your editor?",
+      choices: [
+        { value: "terminal", name: "Print to terminal", description: "Copy and paste into your editor" },
+        { value: "file", name: "Save as file", description: "Write PROJECT_SETUP.md to your project" },
+        { value: "both", name: "Both" },
+        { value: "skip", name: "Skip" }
+      ],
+      default: "terminal"
+    });
+    if (promptAction === "skip") return false;
+    const editorPrompt = generateEditorPrompt(projectName, persona, template);
+    if (promptAction === "terminal" || promptAction === "both") {
+      printCopyablePrompt(editorPrompt);
+    }
+    if (promptAction === "file" || promptAction === "both") {
+      const setupContent = generateSetupPromptFile(projectName, persona, template, filesCreated);
+      const setupPath = path18.join(targetDir, "PROJECT_SETUP.md");
+      fs19.writeFileSync(setupPath, setupContent, "utf8");
+      const gitignorePath = path18.join(targetDir, ".gitignore");
+      if (fs19.existsSync(gitignorePath)) {
+        const existing = fs19.readFileSync(gitignorePath, "utf8");
+        if (!existing.includes("PROJECT_SETUP.md")) {
+          fs19.appendFileSync(gitignorePath, "PROJECT_SETUP.md\n", "utf8");
+        }
+      }
+      logger.newline();
+      logger.success(`Wrote ${logger.highlight("PROJECT_SETUP.md")} ${logger.dim("(delete after first setup)")}`);
+    }
+  }
+  return false;
+}
 async function initCommand(dirArg, options) {
   try {
     const config2 = await resolveInitConfig(dirArg, options);
-    const pkgPath = path16.join(config2.targetDir, "package.json");
-    if (fs17.existsSync(pkgPath) && !config2.force) {
+    const pkgPath = path18.join(config2.targetDir, "package.json");
+    if (fs19.existsSync(pkgPath) && !config2.force) {
       throw new Error(
         `${config2.targetDir} already contains a package.json. Use --force to overwrite.`
       );
     }
-    const files = generateProjectFiles(config2.projectName, config2.template, config2.format);
+    const files = generateProjectFiles(config2.projectName, config2.template, config2.format, config2.persona);
     const { filesCreated, filesSkipped } = scaffoldProject(config2.targetDir, files, {
       force: config2.force
     });
@@ -81074,9 +82419,9 @@ async function initCommand(dirArg, options) {
       gitResult = runGitInit(config2.targetDir);
     }
     const workflowFile = `${config2.projectName}-workflow.ts`;
-    const workflowPath = path16.join(config2.targetDir, "src", workflowFile);
+    const workflowPath = path18.join(config2.targetDir, "src", workflowFile);
     let compileResult;
-    if (!options.json && fs17.existsSync(workflowPath)) {
+    if (!options.json && fs19.existsSync(workflowPath)) {
       try {
         await compileCommand(workflowPath, { format: config2.format });
         compileResult = { success: true };
@@ -81085,14 +82430,42 @@ async function initCommand(dirArg, options) {
         compileResult = { success: false, error: message };
       }
     }
+    let mcpConfigured;
+    let mcpResult;
+    if (config2.mcp && !options.json) {
+      const spinner = logger.spinner("Configuring AI editors...");
+      try {
+        mcpResult = await runMcpSetupFromInit();
+        mcpConfigured = mcpResult.configured;
+        if (mcpResult.configured.length > 0) {
+          spinner.stop(`${mcpResult.configured.join(", ")} configured`);
+        } else if (mcpResult.failed.length > 0) {
+          spinner.fail("MCP setup failed");
+        } else {
+          spinner.stop("No AI editors detected");
+        }
+      } catch {
+        spinner.fail("MCP setup failed");
+      }
+    }
+    let agentLaunched = false;
+    let mcpCliTools = [];
+    let mcpGuiTools = [];
+    if (mcpResult) {
+      mcpCliTools = mcpResult.cliTools;
+      mcpGuiTools = mcpResult.guiTools;
+    }
     const report = {
       projectDir: config2.targetDir,
       filesCreated,
       filesSkipped,
       template: config2.template,
       format: config2.format,
+      persona: config2.persona,
       installResult,
-      gitResult
+      gitResult,
+      mcpConfigured,
+      agentLaunched: false
     };
     if (options.json) {
       console.log(JSON.stringify(report, null, 2));
@@ -81100,10 +82473,16 @@ async function initCommand(dirArg, options) {
     }
     logger.newline();
     logger.success(`Created ${logger.highlight(config2.projectName)} ${logger.dim(`(${config2.template}, ${config2.format.toUpperCase()})`)}`);
-    logger.log(`  ${filesCreated.join(", ")}`);
     if (filesSkipped.length > 0) {
       logger.warn(`Skipped ${filesSkipped.length} existing file(s)`);
     }
+    if (installResult) {
+      if (installResult.success) {
+        logger.success("Dependencies installed");
+      } else {
+        logger.warn(`npm install failed: ${installResult.error}`);
+      }
+    }
     if (gitResult) {
       if (gitResult.success) {
         logger.success("Git initialized");
@@ -81118,18 +82497,40 @@ async function initCommand(dirArg, options) {
         logger.warn(`Compile failed: ${compileResult.error}`);
       }
     }
-    logger.newline();
-    logger.log(`  ${logger.bold("Next steps")}`);
-    const relDir = path16.relative(process.cwd(), config2.targetDir);
+    const workflowCode = files[`src/${workflowFile}`] ?? null;
+    const relDir = path18.relative(process.cwd(), config2.targetDir);
     const displayDir = !relDir || relDir === "." ? null : relDir.startsWith("../../") ? config2.targetDir : relDir;
-    if (displayDir) {
-      logger.log(`  cd ${displayDir}`);
+    const skipAgent = options.agent === false || options.yes || isNonInteractive();
+    if (mcpConfigured && mcpConfigured.length > 0 && !skipAgent) {
+      try {
+        agentLaunched = await handleAgentHandoff({
+          projectName: config2.projectName,
+          persona: config2.persona,
+          template: config2.template,
+          targetDir: config2.targetDir,
+          cliTools: mcpCliTools,
+          guiTools: mcpGuiTools,
+          filesCreated
+        });
+        report.agentLaunched = agentLaunched;
+      } catch (err) {
+        if (err instanceof ExitPromptError4) return;
+      }
     }
-    if (!config2.install) {
-      logger.log("  npm install");
+    if (agentLaunched) {
+      return;
     }
-    logger.log(compileResult?.success ? "  npm start" : "  npm run dev");
-    logger.newline();
+    printNextSteps({
+      projectName: config2.projectName,
+      persona: config2.persona,
+      template: config2.template,
+      displayDir,
+      installSkipped: !config2.install,
+      workflowCode,
+      workflowFile,
+      mcpConfigured,
+      agentLaunched
+    });
   } catch (err) {
     if (err instanceof ExitPromptError4) {
       return;
@@ -81140,7 +82541,7 @@ async function initCommand(dirArg, options) {
 
 // src/cli/commands/watch.ts
 init_esm5();
-import * as path17 from "path";
+import * as path19 from "path";
 init_error_utils();
 function timestamp2() {
   const now = /* @__PURE__ */ new Date();
@@ -81166,7 +82567,7 @@ async function watchCommand(input, options = {}) {
   });
   watcher.on("change", async (file) => {
     logger.newline();
-    logger.info(`${timestamp2()} File changed: ${path17.basename(file)}`);
+    logger.info(`${timestamp2()} File changed: ${path19.basename(file)}`);
     logger.info(`${timestamp2()} Recompiling...`);
     logger.newline();
     try {
@@ -81199,10 +82600,10 @@ async function watchCommand(input, options = {}) {
 
 // src/cli/commands/dev.ts
 init_esm5();
-import * as path19 from "path";
-import * as fs19 from "fs";
-import * as os from "os";
-import { spawn } from "child_process";
+import * as path21 from "path";
+import * as fs21 from "fs";
+import * as os2 from "os";
+import { spawn as spawn2 } from "child_process";
 init_workflow_executor();
 init_error_utils();
 function timestamp3() {
@@ -81214,11 +82615,11 @@ function timestamp3() {
 }
 function cycleSeparator(file) {
   const ts5 = timestamp3();
-  const pad = "\u2500".repeat(40);
+  const pad2 = "\u2500".repeat(40);
   logger.log(`
-  ${logger.dim(`\u2500\u2500\u2500 ${ts5} ${pad}`)}`);
+  ${logger.dim(`\u2500\u2500\u2500 ${ts5} ${pad2}`)}`);
   if (file) {
-    logger.log(`  ${logger.dim("File changed:")} ${path19.basename(file)}`);
+    logger.log(`  ${logger.dim("File changed:")} ${path21.basename(file)}`);
   }
 }
 function parseParams(options) {
@@ -81230,12 +82631,12 @@ function parseParams(options) {
     }
   }
   if (options.paramsFile) {
-    const paramsFilePath = path19.resolve(options.paramsFile);
-    if (!fs19.existsSync(paramsFilePath)) {
+    const paramsFilePath = path21.resolve(options.paramsFile);
+    if (!fs21.existsSync(paramsFilePath)) {
       throw new Error(`Params file not found: ${paramsFilePath}`);
     }
     try {
-      const content = fs19.readFileSync(paramsFilePath, "utf8");
+      const content = fs21.readFileSync(paramsFilePath, "utf8");
       return JSON.parse(content);
     } catch {
       throw new Error(`Failed to parse params file: ${options.paramsFile}`);
@@ -81318,7 +82719,7 @@ function checkDependency(pkg, cwd) {
   }
 }
 function generateDevServerEntry(inngestOutputPath, framework, port) {
-  const relImport = `./${path19.basename(inngestOutputPath).replace(/\.ts$/, ".js")}`;
+  const relImport = `./${path21.basename(inngestOutputPath).replace(/\.ts$/, ".js")}`;
   if (framework === "express") {
     return `import express from 'express';
 import { handler } from '${relImport}';
@@ -81357,7 +82758,7 @@ serve({ fetch: app.fetch, port: ${port} }, () => {
 async function runInngestDevMode(filePath, options) {
   const framework = options.framework ?? "express";
   const port = options.port ?? 3e3;
-  const cwd = path19.dirname(filePath);
+  const cwd = path21.dirname(filePath);
   const missingDeps = [];
   if (!checkDependency("inngest", cwd)) missingDeps.push("inngest");
   if (framework === "express" && !checkDependency("express", cwd)) missingDeps.push("express");
@@ -81368,8 +82769,8 @@ async function runInngestDevMode(filePath, options) {
   if (missingDeps.length > 0) {
     throw new Error(`Missing dependencies: ${missingDeps.join(", ")}. Install them with: npm install ${missingDeps.join(" ")}`);
   }
-  const tmpDir = fs19.mkdtempSync(path19.join(os.tmpdir(), "fw-inngest-dev-"));
-  const inngestOutputPath = path19.join(tmpDir, path19.basename(filePath).replace(/\.ts$/, ".inngest.ts"));
+  const tmpDir = fs21.mkdtempSync(path21.join(os2.tmpdir(), "fw-inngest-dev-"));
+  const inngestOutputPath = path21.join(tmpDir, path21.basename(filePath).replace(/\.ts$/, ".inngest.ts"));
   let serverProcess = null;
   const compileInngest = async () => {
     try {
@@ -81381,10 +82782,10 @@ async function runInngestDevMode(filePath, options) {
         typedEvents: true
       });
       const sourceOutput2 = filePath.replace(/\.ts$/, ".inngest.ts");
-      if (fs19.existsSync(sourceOutput2)) {
-        fs19.copyFileSync(sourceOutput2, inngestOutputPath);
+      if (fs21.existsSync(sourceOutput2)) {
+        fs21.copyFileSync(sourceOutput2, inngestOutputPath);
         try {
-          fs19.unlinkSync(sourceOutput2);
+          fs21.unlinkSync(sourceOutput2);
         } catch {
         }
       }
@@ -81395,11 +82796,11 @@ async function runInngestDevMode(filePath, options) {
     }
   };
   const startServer = () => {
-    const entryPath = path19.join(tmpDir, "dev-server.ts");
+    const entryPath = path21.join(tmpDir, "dev-server.ts");
     const entryCode = generateDevServerEntry(inngestOutputPath, framework, port);
-    fs19.writeFileSync(entryPath, entryCode, "utf8");
-    serverProcess = spawn("npx", ["tsx", entryPath], {
-      cwd: path19.dirname(filePath),
+    fs21.writeFileSync(entryPath, entryCode, "utf8");
+    serverProcess = spawn2("npx", ["tsx", entryPath], {
+      cwd: path21.dirname(filePath),
       stdio: "inherit",
       shell: true
     });
@@ -81427,7 +82828,7 @@ async function runInngestDevMode(filePath, options) {
     }
   };
   logger.section("Inngest Dev Mode");
-  logger.info(`File: ${path19.basename(filePath)}`);
+  logger.info(`File: ${path21.basename(filePath)}`);
   logger.info(`Framework: ${framework}`);
   logger.info(`Port: ${port}`);
   logger.newline();
@@ -81441,7 +82842,7 @@ async function runInngestDevMode(filePath, options) {
   }
   logger.newline();
   logger.success("Watching for file changes... (Ctrl+C to stop)");
-  const files = await glob(path19.resolve(filePath), { absolute: true });
+  const files = await glob(path21.resolve(filePath), { absolute: true });
   const chokidar = await import("chokidar");
   const watcher = chokidar.watch(files, {
     persistent: true,
@@ -81459,11 +82860,11 @@ async function runInngestDevMode(filePath, options) {
     stopServer();
     watcher.close();
     try {
-      fs19.rmSync(tmpDir, { recursive: true, force: true });
+      fs21.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
     try {
-      fs19.unlinkSync(sourceOutput);
+      fs21.unlinkSync(sourceOutput);
     } catch {
     }
     process.exit(0);
@@ -81474,8 +82875,8 @@ async function runInngestDevMode(filePath, options) {
   });
 }
 async function devCommand(input, options = {}) {
-  const filePath = path19.resolve(input);
-  if (!fs19.existsSync(filePath)) {
+  const filePath = path21.resolve(input);
+  if (!fs21.existsSync(filePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   if (options.target === "inngest") {
@@ -81484,7 +82885,7 @@ async function devCommand(input, options = {}) {
   const params = parseParams(options);
   if (!options.json) {
     logger.section("Dev Mode");
-    logger.info(`File: ${path19.basename(filePath)}`);
+    logger.info(`File: ${path21.basename(filePath)}`);
     if (Object.keys(params).length > 0) {
       logger.info(`Params: ${JSON.stringify(params)}`);
     }
@@ -85051,7 +86452,7 @@ async function listenCommand(options) {
 }
 
 // src/cli/commands/tunnel.ts
-import * as path26 from "node:path";
+import * as path28 from "node:path";
 
 // node_modules/ws/wrapper.mjs
 var import_stream2 = __toESM(require_stream2(), 1);
@@ -85062,18 +86463,18 @@ var import_websocket_server2 = __toESM(require_websocket_server2(), 1);
 var wrapper_default = import_websocket4.default;
 
 // src/cli/tunnel/handlers/file-ops.ts
-import * as fs20 from "node:fs/promises";
-import * as path21 from "node:path";
+import * as fs22 from "node:fs/promises";
+import * as path23 from "node:path";
 
 // src/cli/tunnel/path-resolver.ts
-import * as path20 from "node:path";
+import * as path22 from "node:path";
 function resolvePath(workspaceRoot, studioPath) {
   if (studioPath.includes("\0")) {
     throw new Error("Path traversal blocked");
   }
-  if (studioPath.startsWith(workspaceRoot + path20.sep) || studioPath === workspaceRoot) {
-    const resolved2 = path20.resolve(studioPath);
-    if (!resolved2.startsWith(workspaceRoot + path20.sep) && resolved2 !== workspaceRoot) {
+  if (studioPath.startsWith(workspaceRoot + path22.sep) || studioPath === workspaceRoot) {
+    const resolved2 = path22.resolve(studioPath);
+    if (!resolved2.startsWith(workspaceRoot + path22.sep) && resolved2 !== workspaceRoot) {
       throw new Error("Path traversal blocked");
     }
     return resolved2;
@@ -85086,16 +86487,16 @@ function resolvePath(workspaceRoot, studioPath) {
   if (!normalized) {
     return workspaceRoot;
   }
-  const resolved = path20.resolve(workspaceRoot, normalized);
-  if (!resolved.startsWith(workspaceRoot + path20.sep) && resolved !== workspaceRoot) {
+  const resolved = path22.resolve(workspaceRoot, normalized);
+  if (!resolved.startsWith(workspaceRoot + path22.sep) && resolved !== workspaceRoot) {
     throw new Error("Path traversal blocked");
   }
   return resolved;
 }
 function toVirtualPath(workspaceRoot, realPath) {
-  const rel = path20.relative(workspaceRoot, realPath);
+  const rel = path22.relative(workspaceRoot, realPath);
   if (rel.startsWith("..")) {
-    return "/" + path20.basename(realPath);
+    return "/" + path22.basename(realPath);
   }
   return "/" + rel;
 }
@@ -85108,14 +86509,14 @@ async function collectFileInfos(dir, root2) {
   async function walk(currentDir) {
     let entries;
     try {
-      entries = await fs20.readdir(currentDir, { withFileTypes: true });
+      entries = await fs22.readdir(currentDir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
       if (SKIP_FILES.has(entry.name)) continue;
-      const fullPath = path21.join(currentDir, entry.name);
+      const fullPath = path23.join(currentDir, entry.name);
       const isDir = entry.isDirectory();
       results.push({
         path: toVirtualPath(root2, fullPath),
@@ -85136,7 +86537,7 @@ var fileOpsHandlers = {
     const filePath = params.filePath;
     if (!filePath) throw new Error("filePath is required");
     const resolved = resolvePath(ctx.workspaceRoot, filePath);
-    return fs20.readFile(resolved, "utf-8");
+    return fs22.readFile(resolved, "utf-8");
   },
   writeFile: async (params, ctx) => {
     const filePath = params.filePath || params.path;
@@ -85144,8 +86545,8 @@ var fileOpsHandlers = {
     if (!filePath) throw new Error("filePath is required");
     if (content === void 0 || content === null) throw new Error("content is required");
     const resolved = resolvePath(ctx.workspaceRoot, filePath);
-    await fs20.mkdir(path21.dirname(resolved), { recursive: true });
-    await fs20.writeFile(resolved, content, "utf-8");
+    await fs22.mkdir(path23.dirname(resolved), { recursive: true });
+    await fs22.writeFile(resolved, content, "utf-8");
     return { saved: true };
   },
   saveFile: async (params, ctx) => {
@@ -85156,7 +86557,7 @@ var fileOpsHandlers = {
     if (!filePath) return false;
     const resolved = resolvePath(ctx.workspaceRoot, filePath);
     try {
-      await fs20.access(resolved);
+      await fs22.access(resolved);
       return true;
     } catch {
       return false;
@@ -85166,7 +86567,7 @@ var fileOpsHandlers = {
     const filePath = params.filePath;
     if (!filePath) throw new Error("filePath is required");
     const resolved = resolvePath(ctx.workspaceRoot, filePath);
-    await fs20.unlink(resolved);
+    await fs22.unlink(resolved);
     return { deleted: true };
   },
   getFilesStructure: async (_params, ctx) => {
@@ -85179,12 +86580,12 @@ var fileOpsHandlers = {
     let dirPath = params.dirPath || params.path || params.directory;
     if (dirPath?.startsWith("/cloud")) dirPath = dirPath.slice("/cloud".length) || void 0;
     const resolved = dirPath && dirPath !== "/" && dirPath !== "" ? resolvePath(ctx.workspaceRoot, dirPath) : ctx.workspaceRoot;
-    const entries = await fs20.readdir(resolved, { withFileTypes: true });
+    const entries = await fs22.readdir(resolved, { withFileTypes: true });
     const results = [];
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === "package-lock.json") continue;
-      const fullPath = path21.join(resolved, entry.name);
-      const stat2 = await fs20.stat(fullPath);
+      const fullPath = path23.join(resolved, entry.name);
+      const stat2 = await fs22.stat(fullPath);
       const isDir = entry.isDirectory();
       results.push({
         name: entry.name,
@@ -85198,7 +86599,7 @@ var fileOpsHandlers = {
     return results;
   },
   findWorkflows: async (_params, ctx) => {
-    const entries = await fs20.readdir(ctx.workspaceRoot, { withFileTypes: true });
+    const entries = await fs22.readdir(ctx.workspaceRoot, { withFileTypes: true });
     const paths = [];
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".ts")) {
@@ -85211,7 +86612,7 @@ var fileOpsHandlers = {
     const dirPath = params.dirPath;
     if (!dirPath) throw new Error("dirPath is required");
     const resolved = resolvePath(ctx.workspaceRoot, dirPath);
-    await fs20.mkdir(resolved, { recursive: true });
+    await fs22.mkdir(resolved, { recursive: true });
     return { created: true };
   },
   renameFile: async (params, ctx) => {
@@ -85220,14 +86621,14 @@ var fileOpsHandlers = {
     if (!oldPath || !newPath) throw new Error("oldPath and newPath are required");
     const resolvedOld = resolvePath(ctx.workspaceRoot, oldPath);
     const resolvedNew = resolvePath(ctx.workspaceRoot, newPath);
-    await fs20.rename(resolvedOld, resolvedNew);
+    await fs22.rename(resolvedOld, resolvedNew);
     return { renamed: true };
   },
   getFileStats: async (params, ctx) => {
     const filePath = params.filePath;
     if (!filePath) throw new Error("filePath is required");
     const resolved = resolvePath(ctx.workspaceRoot, filePath);
-    const stat2 = await fs20.stat(resolved);
+    const stat2 = await fs22.stat(resolved);
     return {
       size: stat2.size,
       created: stat2.birthtime.toISOString(),
@@ -85243,8 +86644,8 @@ var fileOpsHandlers = {
   copyDirectory: async () => ({ success: true }),
   checkLibraryStatus: async (_params, ctx) => {
     try {
-      const pkgPath = path21.join(ctx.workspaceRoot, "node_modules", "@synergenius", "flow-weaver", "package.json");
-      const raw = await fs20.readFile(pkgPath, "utf-8");
+      const pkgPath = path23.join(ctx.workspaceRoot, "node_modules", "@synergenius", "flow-weaver", "package.json");
+      const raw = await fs22.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       return {
         installed: true,
@@ -85269,7 +86670,7 @@ var fileOpsHandlers = {
   },
   getPackages: async (_params, ctx) => {
     try {
-      const raw = await fs20.readFile(path21.join(ctx.workspaceRoot, "package.json"), "utf-8");
+      const raw = await fs22.readFile(path23.join(ctx.workspaceRoot, "package.json"), "utf-8");
       const pkg = JSON.parse(raw);
       const deps = pkg.dependencies || {};
       return Object.entries(deps).map(([name, version3]) => ({ name, version: version3 }));
@@ -85282,8 +86683,8 @@ var fileOpsHandlers = {
 // src/cli/tunnel/handlers/ast-ops.ts
 init_parser2();
 init_validate();
-import * as fs21 from "node:fs/promises";
-import * as path22 from "node:path";
+import * as fs23 from "node:fs/promises";
+import * as path24 from "node:path";
 function ensureASTDefaults(ast) {
   return {
     ...ast,
@@ -85338,15 +86739,15 @@ async function loadWorkflowAST(filePath, functionName) {
   if (!target) {
     throw new Error(`Workflow "${functionName}" not found in ${filePath}`);
   }
-  return resolveNpmNodeTypes(target, path22.dirname(filePath));
+  return resolveNpmNodeTypes(target, path24.dirname(filePath));
 }
 async function loadAllWorkflowsAST(wsPath) {
-  const entries = await fs21.readdir(wsPath, { withFileTypes: true });
+  const entries = await fs23.readdir(wsPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".ts")) continue;
     if (entry.name === "tsconfig.json" || entry.name === "package.json") continue;
-    const fullPath = path22.join(wsPath, entry.name);
+    const fullPath = path24.join(wsPath, entry.name);
     try {
       const parsed = parser.parse(fullPath);
       const workflows = parsed.workflows || [];
@@ -85431,7 +86832,7 @@ var astOpsHandlers = {
     if (!filePath) return { availableWorkflows: [] };
     try {
       const resolved = resolvePath(ctx.workspaceRoot, filePath);
-      const source = await fs21.readFile(resolved, "utf-8");
+      const source = await fs23.readFile(resolved, "utf-8");
       const results = parseWorkflowFromContent(source);
       return {
         availableWorkflows: results.map((w) => ({
@@ -85454,7 +86855,7 @@ var astOpsHandlers = {
       source = params.content;
     } else if (filePath) {
       const resolved = resolvePath(ctx.workspaceRoot, filePath);
-      source = await fs21.readFile(resolved, "utf-8");
+      source = await fs23.readFile(resolved, "utf-8");
     }
     if (!source) throw new Error("No source provided for diagnostics");
     const { errors: errors2, warnings } = getDiagnostics(source);
@@ -85507,14 +86908,14 @@ init_nodes();
 init_connections();
 init_node_types();
 init_ports();
-import * as fs22 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as fs24 from "node:fs/promises";
+import * as path26 from "node:path";
 
 // src/cli/tunnel/file-lock.ts
-import * as path23 from "node:path";
+import * as path25 from "node:path";
 var fileMutationLocks = /* @__PURE__ */ new Map();
 function withFileLock(filePath, operation) {
-  const normalizedPath = path23.resolve(filePath);
+  const normalizedPath = path25.resolve(filePath);
   const existingChain = fileMutationLocks.get(normalizedPath) || Promise.resolve();
   let resolve37;
   let reject2;
@@ -85546,7 +86947,7 @@ async function mutateWorkflowFile({
   mutator
 }) {
   return withFileLock(filePath, async () => {
-    const sourceCode = await fs22.readFile(filePath, "utf-8");
+    const sourceCode = await fs24.readFile(filePath, "utf-8");
     const parsed = parser.parse(filePath);
     const workflows = parsed.workflows || [];
     if (workflows.length === 0) {
@@ -85582,8 +86983,8 @@ async function mutateWorkflowFile({
       nodeTypes: [...updatedNodeTypes, ...missingTypes]
     };
     const result = generateInPlace(sourceCode, workflowForGeneration);
-    await fs22.writeFile(filePath, result.code, "utf-8");
-    return resolveNpmNodeTypes(updated, path24.dirname(filePath));
+    await fs24.writeFile(filePath, result.code, "utf-8");
+    return resolveNpmNodeTypes(updated, path26.dirname(filePath));
   });
 }
 function makeMutationHandler(extractMutator) {
@@ -85793,8 +87194,8 @@ var mutationHandlers = {
 // src/cli/tunnel/handlers/templates.ts
 init_parser2();
 init_templates();
-import * as fs23 from "node:fs/promises";
-import * as path25 from "node:path";
+import * as fs25 from "node:fs/promises";
+import * as path27 from "node:path";
 function mapTemplate(t) {
   return {
     id: t.id,
@@ -85886,15 +87287,15 @@ var templateHandlers = {
     const code = template.generate(genOpts);
     const targetFileName = fileName || `${workflowName}.ts`;
     const resolved = resolvePath(ctx.workspaceRoot, targetFileName);
-    await fs23.mkdir(path25.dirname(resolved), { recursive: true });
-    await fs23.writeFile(resolved, code, "utf-8");
+    await fs25.mkdir(path27.dirname(resolved), { recursive: true });
+    await fs25.writeFile(resolved, code, "utf-8");
     return { success: true, filePath: "/" + targetFileName };
   }
 };
 
 // src/cli/tunnel/handlers/execution.ts
 init_compile();
-import * as fs24 from "node:fs/promises";
+import * as fs26 from "node:fs/promises";
 var sourceToSVG2;
 async function loadDiagram() {
   if (sourceToSVG2) return sourceToSVG2;
@@ -85945,7 +87346,7 @@ var executionHandlers = {
       source = content;
     } else if (filePath) {
       const resolved = resolvePath(ctx.workspaceRoot, filePath);
-      source = await fs24.readFile(resolved, "utf-8");
+      source = await fs26.readFile(resolved, "utf-8");
     } else {
       throw new Error("filePath or content is required");
     }
@@ -86131,7 +87532,7 @@ async function dispatch(method, params, ctx) {
 // src/cli/commands/tunnel.ts
 async function tunnelCommand(options) {
   const cloudUrl = options.cloud || "https://flowweaver.dev";
-  const workspaceRoot = path26.resolve(options.dir || process.cwd());
+  const workspaceRoot = path28.resolve(options.dir || process.cwd());
   const createWs = options.createWs ?? ((url2) => new wrapper_default(url2));
   logger.section("Flow Weaver Tunnel");
   logger.info(`Cloud:     ${cloudUrl}`);
@@ -100266,7 +101667,7 @@ var StdioServerTransport = class {
 };
 
 // src/mcp/event-buffer.ts
-import * as fs25 from "fs";
+import * as fs27 from "fs";
 
 // src/mcp/types.ts
 var DEFAULT_EVENT_FILTER = {
@@ -100366,7 +101767,7 @@ var EventBuffer = class {
   appendToFile(entry) {
     if (!this.eventsFilePath) return;
     try {
-      fs25.appendFileSync(this.eventsFilePath, JSON.stringify(entry) + "\n");
+      fs27.appendFileSync(this.eventsFilePath, JSON.stringify(entry) + "\n");
     } catch {
     }
   }
@@ -101019,7 +102420,7 @@ function registerEditorTools(mcp, connection, buffer) {
 // src/mcp/tools-query.ts
 init_api6();
 init_query();
-import * as path27 from "path";
+import * as path29 from "path";
 init_inngest();
 init_parser2();
 function parseErrorCode(errors2) {
@@ -101040,7 +102441,7 @@ function registerQueryTools(mcp) {
     },
     async (args) => {
       try {
-        const filePath = path27.resolve(args.filePath);
+        const filePath = path29.resolve(args.filePath);
         const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
         if (parseResult.errors.length > 0 && parseResult.errors.some((e) => typeof e === "string" && e.includes("No workflows found"))) {
           try {
@@ -101089,7 +102490,7 @@ ${parseResult.errors.join("\n")}`
     },
     async (args) => {
       try {
-        const filePath = path27.resolve(args.filePath);
+        const filePath = path29.resolve(args.filePath);
         const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
         if (parseResult.errors.length > 0 && parseResult.errors.some((e) => typeof e === "string" && e.includes("No workflows found"))) {
           try {
@@ -101169,7 +102570,7 @@ ${parseResult.errors.join("\n")}`
     },
     async (args) => {
       try {
-        const filePath = path27.resolve(args.filePath);
+        const filePath = path29.resolve(args.filePath);
         if (args.target === "inngest") {
           const parser3 = new AnnotationParser();
           const parseResult = parser3.parse(filePath);
@@ -101245,8 +102646,8 @@ ${parseResult.errors.join("\n")}`);
     async (args) => {
       try {
         const [result1, result2] = await Promise.all([
-          parseWorkflow(path27.resolve(args.file1), { workflowName: args.workflowName }),
-          parseWorkflow(path27.resolve(args.file2), { workflowName: args.workflowName })
+          parseWorkflow(path29.resolve(args.file1), { workflowName: args.workflowName }),
+          parseWorkflow(path29.resolve(args.file2), { workflowName: args.workflowName })
         ]);
         if (result1.errors.length > 0) {
           return makeErrorResult(
@@ -101308,7 +102709,7 @@ Query types:
     },
     async (args) => {
       try {
-        const filePath = path27.resolve(args.filePath);
+        const filePath = path29.resolve(args.filePath);
         let parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
         if (parseResult.errors.length > 0 && args.query === "node-types" && parseResult.errors.some((e) => typeof e === "string" && e.includes("No workflows found"))) {
           try {
@@ -101407,7 +102808,7 @@ ${parseResult.errors.join("\n")}`
     },
     async (args) => {
       try {
-        const dir = path27.resolve(args.directory ?? process.cwd());
+        const dir = path29.resolve(args.directory ?? process.cwd());
         const report = runDoctorChecks(dir);
         return makeToolResult(report);
       } catch (err) {
@@ -101422,8 +102823,8 @@ ${parseResult.errors.join("\n")}`
 
 // src/mcp/tools-template.ts
 init_templates2();
-import * as path28 from "path";
-import * as fs26 from "fs";
+import * as path30 from "path";
+import * as fs28 from "fs";
 function registerTemplateTools(mcp) {
   mcp.tool(
     "fw_list_templates",
@@ -101465,7 +102866,7 @@ function registerTemplateTools(mcp) {
     },
     async (args) => {
       try {
-        const outPath = path28.resolve(args.filePath);
+        const outPath = path30.resolve(args.filePath);
         const wt = getWorkflowTemplate2(args.template);
         if (wt) {
           const code = generateWorkflowFromTemplate(args.template, {
@@ -101481,10 +102882,10 @@ function registerTemplateTools(mcp) {
               code
             });
           }
-          if (fs26.existsSync(outPath)) {
-            fs26.appendFileSync(outPath, "\n\n" + code, "utf8");
+          if (fs28.existsSync(outPath)) {
+            fs28.appendFileSync(outPath, "\n\n" + code, "utf8");
           } else {
-            fs26.writeFileSync(outPath, code, "utf8");
+            fs28.writeFileSync(outPath, code, "utf8");
           }
           return makeToolResult({
             success: true,
@@ -101505,10 +102906,10 @@ function registerTemplateTools(mcp) {
               code
             });
           }
-          if (fs26.existsSync(outPath)) {
-            fs26.appendFileSync(outPath, "\n\n" + code, "utf8");
+          if (fs28.existsSync(outPath)) {
+            fs28.appendFileSync(outPath, "\n\n" + code, "utf8");
           } else {
-            fs26.writeFileSync(outPath, code, "utf8");
+            fs28.writeFileSync(outPath, code, "utf8");
           }
           return makeToolResult({
             success: true,
@@ -101536,8 +102937,8 @@ init_esm5();
 init_api6();
 init_patterns();
 init_generate_in_place();
-import * as path29 from "path";
-import * as fs27 from "fs";
+import * as path31 from "path";
+import * as fs29 from "fs";
 
 // src/migration/registry.ts
 var migrations = [];
@@ -101741,7 +103142,7 @@ function registerPatternTools(mcp) {
     },
     async (args) => {
       try {
-        const filePath = path29.resolve(args.filePath);
+        const filePath = path31.resolve(args.filePath);
         const patterns = listPatterns(filePath);
         return makeToolResult(patterns);
       } catch (err) {
@@ -101764,8 +103165,8 @@ function registerPatternTools(mcp) {
     },
     async (args) => {
       try {
-        const patternFilePath = path29.resolve(args.patternFile);
-        const targetFilePath = path29.resolve(args.targetFile);
+        const patternFilePath = path31.resolve(args.patternFile);
+        const targetFilePath = path31.resolve(args.targetFile);
         const annotationParser = new AnnotationParser();
         const patternResult = annotationParser.parse(patternFilePath);
         if (patternResult.patterns.length === 0) {
@@ -101783,7 +103184,7 @@ function registerPatternTools(mcp) {
         } else {
           pattern = patternResult.patterns[0];
         }
-        const targetContent = fs27.readFileSync(targetFilePath, "utf8");
+        const targetContent = fs29.readFileSync(targetFilePath, "utf8");
         const targetResult = annotationParser.parse(targetFilePath);
         const existingNodeTypes = new Set(targetResult.nodeTypes.map((nt) => nt.name));
         const result = applyPattern({
@@ -101804,7 +103205,7 @@ function registerPatternTools(mcp) {
             content: result.modifiedContent
           });
         }
-        fs27.writeFileSync(targetFilePath, result.modifiedContent, "utf8");
+        fs29.writeFileSync(targetFilePath, result.modifiedContent, "utf8");
         return makeToolResult({
           success: true,
           nodesAdded: result.nodesAdded,
@@ -101830,7 +103231,7 @@ function registerPatternTools(mcp) {
     },
     async (args) => {
       try {
-        const dir = path29.resolve(args.directory);
+        const dir = path31.resolve(args.directory);
         const results = await findWorkflows(dir, args.pattern);
         return makeToolResult(results);
       } catch (err) {
@@ -101867,8 +103268,8 @@ function registerPatternTools(mcp) {
         if (!paramValidation.success) {
           return makeErrorResult("INVALID_PARAMS", paramValidation.error);
         }
-        const filePath = path29.resolve(args.filePath);
-        const sourceCode = fs27.readFileSync(filePath, "utf8");
+        const filePath = path31.resolve(args.filePath);
+        const sourceCode = fs29.readFileSync(filePath, "utf8");
         const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
         if (parseResult.errors.length > 0) {
           return makeErrorResult("PARSE_ERROR", `Parse errors:
@@ -102057,7 +103458,7 @@ ${parseResult.errors.join("\n")}`);
           });
         }
         if (genResult.hasChanges) {
-          fs27.writeFileSync(filePath, genResult.code, "utf8");
+          fs29.writeFileSync(filePath, genResult.code, "utf8");
         }
         let validation;
         let description;
@@ -102160,8 +103561,8 @@ ${parseResult.errors.join("\n")}`);
             );
           }
         }
-        const filePath = path29.resolve(args.filePath);
-        const sourceCode = fs27.readFileSync(filePath, "utf8");
+        const filePath = path31.resolve(args.filePath);
+        const sourceCode = fs29.readFileSync(filePath, "utf8");
         const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
         if (parseResult.errors.length > 0) {
           return makeErrorResult("PARSE_ERROR", `Parse errors:
@@ -102195,7 +103596,7 @@ ${parseResult.errors.join("\n")}`);
           });
         }
         if (genResult.hasChanges) {
-          fs27.writeFileSync(filePath, genResult.code, "utf8");
+          fs29.writeFileSync(filePath, genResult.code, "utf8");
         }
         let validation;
         let description;
@@ -102271,7 +103672,7 @@ ${parseResult.errors.join("\n")}`);
     },
     async (args) => {
       try {
-        const filePath = path29.resolve(args.sourceFile);
+        const filePath = path31.resolve(args.sourceFile);
         const parseResult = await parseWorkflow(filePath);
         if (parseResult.errors.length > 0) {
           return makeErrorResult("PARSE_ERROR", `Parse errors:
@@ -102287,8 +103688,8 @@ ${parseResult.errors.join("\n")}`);
           name: args.name
         });
         if (args.outputFile) {
-          const outPath = path29.resolve(args.outputFile);
-          fs27.writeFileSync(outPath, result.patternCode, "utf8");
+          const outPath = path31.resolve(args.outputFile);
+          fs29.writeFileSync(outPath, result.patternCode, "utf8");
           return makeToolResult({
             success: true,
             filePath: outPath,
@@ -102332,9 +103733,9 @@ ${parseResult.errors.join("\n")}`);
         }
         const results = [];
         for (const file of files) {
-          const filePath = path29.resolve(file);
+          const filePath = path31.resolve(file);
           try {
-            const sourceCode = fs27.readFileSync(filePath, "utf8");
+            const sourceCode = fs29.readFileSync(filePath, "utf8");
             const parseResult = await parseWorkflow(filePath);
             if (parseResult.errors.length > 0) {
               results.push({ file, status: "error", error: parseResult.errors.join("; ") });
@@ -102350,7 +103751,7 @@ ${parseResult.errors.join("\n")}`);
               continue;
             }
             if (!args.dryRun) {
-              fs27.writeFileSync(filePath, genResult.code, "utf8");
+              fs29.writeFileSync(filePath, genResult.code, "utf8");
             }
             results.push({ file, status: "migrated" });
           } catch (err) {
@@ -102380,8 +103781,8 @@ ${parseResult.errors.join("\n")}`);
 // src/mcp/tools-export.ts
 init_api6();
 init_deployment();
-import * as path35 from "path";
-import * as fs31 from "fs";
+import * as path37 from "path";
+import * as fs33 from "fs";
 function registerExportTools(mcp) {
   mcp.tool(
     "fw_export",
@@ -102399,12 +103800,12 @@ function registerExportTools(mcp) {
     },
     async (args) => {
       try {
-        const filePath = path35.resolve(args.filePath);
-        const outputDir = path35.resolve(args.outputDir);
+        const filePath = path37.resolve(args.filePath);
+        const outputDir = path37.resolve(args.outputDir);
         const preview = args.preview ?? false;
         const includeDocs = args.includeDocs ?? true;
         try {
-          await fs31.promises.access(filePath);
+          await fs33.promises.access(filePath);
         } catch {
           return makeErrorResult("FILE_NOT_FOUND", `File not found: ${filePath}`);
         }
@@ -102442,7 +103843,7 @@ function registerExportTools(mcp) {
           }
         }
         if (!exportTarget.generateBundle) {
-          const serviceName2 = args.serviceName || path35.basename(filePath, ".ts").replace(/[^a-zA-Z0-9-]/g, "-");
+          const serviceName2 = args.serviceName || path37.basename(filePath, ".ts").replace(/[^a-zA-Z0-9-]/g, "-");
           const artifacts2 = await exportTarget.generate({
             sourceFile: filePath,
             workflowName: args.workflows?.[0] || serviceName2,
@@ -102451,11 +103852,11 @@ function registerExportTools(mcp) {
             production: true
           });
           if (!preview) {
-            await fs31.promises.mkdir(outputDir, { recursive: true });
+            await fs33.promises.mkdir(outputDir, { recursive: true });
             for (const file of artifacts2.files) {
-              const fullPath = path35.join(outputDir, file.relativePath);
-              await fs31.promises.mkdir(path35.dirname(fullPath), { recursive: true });
-              await fs31.promises.writeFile(fullPath, file.content, "utf-8");
+              const fullPath = path37.join(outputDir, file.relativePath);
+              await fs33.promises.mkdir(path37.dirname(fullPath), { recursive: true });
+              await fs33.promises.writeFile(fullPath, file.content, "utf-8");
             }
           }
           const instructions2 = exportTarget.getDeployInstructions(artifacts2);
@@ -102482,7 +103883,7 @@ function registerExportTools(mcp) {
         const uniqueNodeTypes = [
           ...new Map(allNodeTypes.map((nt) => [nt.name, nt])).values()
         ];
-        const serviceName = args.serviceName || path35.basename(filePath, ".ts").replace(/[^a-zA-Z0-9-]/g, "-");
+        const serviceName = args.serviceName || path37.basename(filePath, ".ts").replace(/[^a-zA-Z0-9-]/g, "-");
         const bundleWorkflows = allWorkflows.filter((w) => args.workflows ? args.workflows.includes(w.name) : true).map((w) => ({
           name: w.name,
           functionName: w.functionName,
@@ -102531,11 +103932,11 @@ function registerExportTools(mcp) {
           }
         );
         if (!preview) {
-          await fs31.promises.mkdir(outputDir, { recursive: true });
+          await fs33.promises.mkdir(outputDir, { recursive: true });
           for (const file of artifacts.files) {
-            const fullPath = path35.join(outputDir, file.relativePath);
-            await fs31.promises.mkdir(path35.dirname(fullPath), { recursive: true });
-            await fs31.promises.writeFile(fullPath, file.content, "utf-8");
+            const fullPath = path37.join(outputDir, file.relativePath);
+            await fs33.promises.mkdir(path37.dirname(fullPath), { recursive: true });
+            await fs33.promises.writeFile(fullPath, file.content, "utf-8");
           }
         }
         const instructions = exportTarget.getDeployInstructions(artifacts);
@@ -102574,13 +103975,13 @@ function registerExportTools(mcp) {
 }
 
 // src/mcp/tools-marketplace.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 
 // src/marketplace/manifest.ts
 init_esm5();
 init_parser2();
-import * as fs32 from "fs";
-import * as path36 from "path";
+import * as fs34 from "fs";
+import * as path38 from "path";
 function toManifestPort(port) {
   return {
     dataType: port.dataType,
@@ -102651,17 +104052,17 @@ function patternToManifest(pat, relativeFile) {
 }
 async function generateManifest(options) {
   const { directory, srcDir = "src", distDir = "dist" } = options;
-  const pkgPath = path36.join(directory, "package.json");
-  if (!fs32.existsSync(pkgPath)) {
+  const pkgPath = path38.join(directory, "package.json");
+  if (!fs34.existsSync(pkgPath)) {
     return {
       manifest: emptyManifest("unknown", "0.0.0"),
       parsedFiles: [],
       errors: ["package.json not found"]
     };
   }
-  const pkg = JSON.parse(fs32.readFileSync(pkgPath, "utf-8"));
-  const srcRoot = path36.join(directory, srcDir);
-  const pattern = path36.join(srcRoot, "**/*.ts").replace(/\\/g, "/");
+  const pkg = JSON.parse(fs34.readFileSync(pkgPath, "utf-8"));
+  const srcRoot = path38.join(directory, srcDir);
+  const pattern = path38.join(srcRoot, "**/*.ts").replace(/\\/g, "/");
   const files = await glob(pattern, { absolute: true });
   const tsFiles = files.filter((f) => !f.endsWith(".d.ts") && !f.includes("node_modules"));
   const parser3 = new AnnotationParser();
@@ -102674,8 +104075,8 @@ async function generateManifest(options) {
     try {
       const result = parser3.parse(file);
       parsedFiles.push(file);
-      const relFromSrc = path36.relative(srcRoot, file);
-      const distRelative = path36.join(distDir, relFromSrc.replace(/\.ts$/, ".js"));
+      const relFromSrc = path38.relative(srcRoot, file);
+      const distRelative = path38.join(distDir, relFromSrc.replace(/\.ts$/, ".js"));
       for (const nt of result.nodeTypes) {
         allNodeTypes.push(nodeTypeToManifest(nt, distRelative));
       }
@@ -102711,14 +104112,14 @@ async function generateManifest(options) {
   return { manifest, parsedFiles, errors: errors2 };
 }
 function writeManifest(directory, manifest) {
-  const outPath = path36.join(directory, "flowweaver.manifest.json");
-  fs32.writeFileSync(outPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  const outPath = path38.join(directory, "flowweaver.manifest.json");
+  fs34.writeFileSync(outPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
   return outPath;
 }
 function readManifest(directory) {
-  const manifestPath = path36.join(directory, "flowweaver.manifest.json");
-  if (!fs32.existsSync(manifestPath)) return null;
-  return JSON.parse(fs32.readFileSync(manifestPath, "utf-8"));
+  const manifestPath = path38.join(directory, "flowweaver.manifest.json");
+  if (!fs34.existsSync(manifestPath)) return null;
+  return JSON.parse(fs34.readFileSync(manifestPath, "utf-8"));
 }
 function emptyManifest(name, version3) {
   return {
@@ -102733,8 +104134,8 @@ function emptyManifest(name, version3) {
 
 // src/marketplace/validator.ts
 init_api6();
-import * as fs33 from "fs";
-import * as path37 from "path";
+import * as fs35 from "fs";
+import * as path39 from "path";
 function issue2(code, severity, message) {
   return { code, severity, message };
 }
@@ -102781,7 +104182,7 @@ function validatePackageJson(pkg, directory) {
   if (pkg.private === true) {
     issues.push(issue2("PKG-004", "error", 'Package must not be "private: true"'));
   }
-  if (!fs33.existsSync(path37.join(directory, "README.md"))) {
+  if (!fs35.existsSync(path39.join(directory, "README.md"))) {
     issues.push(issue2("PKG-007", "warning", "README.md should exist"));
   }
   return issues;
@@ -102856,11 +104257,11 @@ function validateManifestContents(manifest) {
 async function validateWorkflows(manifest, directory) {
   const issues = [];
   for (const wf of manifest.workflows) {
-    const srcFile = path37.join(
+    const srcFile = path39.join(
       directory,
       wf.file.replace(/^dist\//, "src/").replace(/\.js$/, ".ts")
     );
-    if (!fs33.existsSync(srcFile)) continue;
+    if (!fs35.existsSync(srcFile)) continue;
     try {
       const parseResult = await parseWorkflow(srcFile, { workflowName: wf.functionName });
       if (parseResult.errors.length > 0) continue;
@@ -102880,14 +104281,14 @@ async function validateWorkflows(manifest, directory) {
   return issues;
 }
 async function validatePackage(directory, manifest) {
-  const pkgPath = path37.join(directory, "package.json");
-  if (!fs33.existsSync(pkgPath)) {
+  const pkgPath = path39.join(directory, "package.json");
+  if (!fs35.existsSync(pkgPath)) {
     return {
       valid: false,
       issues: [issue2("PKG-000", "error", "package.json not found")]
     };
   }
-  const pkg = JSON.parse(fs33.readFileSync(pkgPath, "utf-8"));
+  const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
   const issues = [
     ...validatePackageJson(pkg, directory),
     ...validateManifestContents(manifest),
@@ -102944,7 +104345,7 @@ function registerMarketplaceTools(mcp) {
     },
     async (args) => {
       try {
-        execSync3(`npm install ${args.package}`, {
+        execSync4(`npm install ${args.package}`, {
           cwd: process.cwd(),
           stdio: "pipe"
         });
@@ -103030,8 +104431,8 @@ function resolvePackageName(spec) {
 
 // src/mcp/tools-diagram.ts
 init_diagram();
-import * as fs34 from "fs";
-import * as path38 from "path";
+import * as fs36 from "fs";
+import * as path40 from "path";
 var ASCII_FORMATS2 = /* @__PURE__ */ new Set(["ascii", "ascii-compact", "text"]);
 function registerDiagramTools(mcp) {
   mcp.tool(
@@ -103068,8 +104469,8 @@ function registerDiagramTools(mcp) {
             result = sourceToSVG(args.source, diagramOptions);
           }
         } else {
-          const resolvedPath = path38.resolve(args.filePath);
-          if (!fs34.existsSync(resolvedPath)) {
+          const resolvedPath = path40.resolve(args.filePath);
+          if (!fs36.existsSync(resolvedPath)) {
             return makeErrorResult("FILE_NOT_FOUND", `File not found: ${resolvedPath}`);
           }
           if (ASCII_FORMATS2.has(format)) {
@@ -103081,8 +104482,8 @@ function registerDiagramTools(mcp) {
           }
         }
         if (args.outputPath) {
-          const outputResolved = path38.resolve(args.outputPath);
-          fs34.writeFileSync(outputResolved, result, "utf-8");
+          const outputResolved = path40.resolve(args.outputPath);
+          fs36.writeFileSync(outputResolved, result, "utf-8");
           return makeToolResult({ written: outputResolved, size: result.length });
         }
         return makeToolResult(result);
@@ -103096,217 +104497,6 @@ function registerDiagramTools(mcp) {
   );
 }
 
-// src/docs/index.ts
-import * as fs35 from "fs";
-import * as path39 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-function getDocsDir() {
-  const thisFile = fileURLToPath3(import.meta.url);
-  const packageRoot = path39.resolve(path39.dirname(thisFile), "..", "..");
-  return path39.join(packageRoot, "docs", "reference");
-}
-function parseFrontmatter(raw) {
-  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!fmMatch) {
-    return {
-      frontmatter: { name: "", description: "", keywords: [] },
-      body: raw
-    };
-  }
-  const fmBlock = fmMatch[1];
-  const body = fmMatch[2];
-  let name = "";
-  let description = "";
-  let keywords = [];
-  for (const line of fmBlock.split("\n")) {
-    const nameMatch = line.match(/^name:\s*(.+)$/);
-    if (nameMatch) {
-      name = nameMatch[1].trim();
-      continue;
-    }
-    const descMatch = line.match(/^description:\s*(.+)$/);
-    if (descMatch) {
-      description = descMatch[1].trim();
-      continue;
-    }
-    const kwMatch = line.match(/^keywords:\s*\[(.+)\]$/);
-    if (kwMatch) {
-      keywords = kwMatch[1].split(",").map((k) => k.trim().replace(/^['"]|['"]$/g, ""));
-      continue;
-    }
-  }
-  return { frontmatter: { name, description, keywords }, body };
-}
-function splitSections(body) {
-  const lines = body.split("\n");
-  const sections = [];
-  let currentHeading = "";
-  let currentLevel = 0;
-  let currentLines = [];
-  function flush() {
-    if (currentHeading || currentLines.length > 0) {
-      const content = currentLines.join("\n").trim();
-      const codeBlocks = [];
-      const codeRe = /```[\s\S]*?```/g;
-      let m;
-      while ((m = codeRe.exec(content)) !== null) {
-        codeBlocks.push(m[0]);
-      }
-      sections.push({
-        heading: currentHeading,
-        level: currentLevel,
-        content,
-        codeBlocks
-      });
-    }
-  }
-  for (const line of lines) {
-    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
-    if (headingMatch) {
-      flush();
-      currentLevel = headingMatch[1].length;
-      currentHeading = headingMatch[2];
-      currentLines = [];
-    } else {
-      currentLines.push(line);
-    }
-  }
-  flush();
-  return sections;
-}
-function listTopics() {
-  const docsDir = getDocsDir();
-  if (!fs35.existsSync(docsDir)) return [];
-  const files = fs35.readdirSync(docsDir).filter((f) => f.endsWith(".md")).sort();
-  return files.map((file) => {
-    const raw = fs35.readFileSync(path39.join(docsDir, file), "utf-8");
-    const { frontmatter } = parseFrontmatter(raw);
-    return {
-      slug: file.replace(/\.md$/, ""),
-      name: frontmatter.name,
-      description: frontmatter.description,
-      keywords: frontmatter.keywords
-    };
-  });
-}
-function readTopic(slug, compact2) {
-  const docsDir = getDocsDir();
-  const filePath = path39.join(docsDir, `${slug}.md`);
-  if (!fs35.existsSync(filePath)) return null;
-  const raw = fs35.readFileSync(filePath, "utf-8");
-  const { frontmatter, body } = parseFrontmatter(raw);
-  const content = compact2 ? buildCompactContent(frontmatter, body) : body.trim();
-  return {
-    slug,
-    name: frontmatter.name,
-    description: frontmatter.description,
-    keywords: frontmatter.keywords,
-    content
-  };
-}
-function readTopicStructured(slug) {
-  const docsDir = getDocsDir();
-  const filePath = path39.join(docsDir, `${slug}.md`);
-  if (!fs35.existsSync(filePath)) return null;
-  const raw = fs35.readFileSync(filePath, "utf-8");
-  const { frontmatter, body } = parseFrontmatter(raw);
-  const sections = splitSections(body);
-  return {
-    slug,
-    name: frontmatter.name,
-    description: frontmatter.description,
-    keywords: frontmatter.keywords,
-    sections
-  };
-}
-function searchDocs(query) {
-  const topics = listTopics();
-  const docsDir = getDocsDir();
-  const queryLower = query.toLowerCase();
-  const queryTerms = queryLower.split(/\s+/).filter(Boolean);
-  const results = [];
-  for (const topic of topics) {
-    const keywordMatch = topic.keywords.some(
-      (kw) => queryTerms.some((term) => kw.toLowerCase().includes(term))
-    );
-    const filePath = path39.join(docsDir, `${topic.slug}.md`);
-    const raw = fs35.readFileSync(filePath, "utf-8");
-    const { body } = parseFrontmatter(raw);
-    const sections = splitSections(body);
-    for (const section of sections) {
-      const sectionLower = section.content.toLowerCase();
-      const headingLower = section.heading.toLowerCase();
-      let relevance = 0;
-      if (sectionLower.includes(queryLower)) {
-        relevance += 10;
-      }
-      for (const term of queryTerms) {
-        if (headingLower.includes(term)) relevance += 5;
-        if (sectionLower.includes(term)) relevance += 2;
-      }
-      if (keywordMatch) relevance += 3;
-      if (relevance > 0) {
-        const lines = section.content.split("\n");
-        const matchingLines = [];
-        for (const line of lines) {
-          if (queryTerms.some((term) => line.toLowerCase().includes(term))) {
-            matchingLines.push(line.trim());
-            if (matchingLines.length >= 3) break;
-          }
-        }
-        results.push({
-          topic: topic.name,
-          slug: topic.slug,
-          section: section.heading,
-          heading: section.heading,
-          excerpt: matchingLines.join("\n") || section.content.slice(0, 200),
-          relevance
-        });
-      }
-    }
-  }
-  results.sort((a, b) => b.relevance - a.relevance);
-  return results;
-}
-function buildCompactContent(frontmatter, body) {
-  const lines = body.split("\n");
-  const output = [];
-  output.push(`# ${frontmatter.name}`);
-  output.push(frontmatter.description);
-  output.push("");
-  let inCodeBlock = false;
-  let inTable = false;
-  for (const line of lines) {
-    if (line.trimStart().startsWith("```")) {
-      inCodeBlock = !inCodeBlock;
-      output.push(line);
-      continue;
-    }
-    if (inCodeBlock) {
-      output.push(line);
-      continue;
-    }
-    if (line.match(/^#{1,6}\s/)) {
-      output.push("");
-      output.push(line);
-      continue;
-    }
-    if (line.trim().startsWith("|")) {
-      inTable = true;
-      output.push(line);
-      continue;
-    }
-    if (inTable && !line.trim().startsWith("|")) {
-      inTable = false;
-    }
-    if (line.trim().startsWith("- ") || line.trim().startsWith("* ") || line.trim().startsWith("> ")) {
-      output.push(line);
-      continue;
-    }
-  }
-  return output.join("\n").replace(/\n{3,}/g, "\n\n").trim();
-}
-
 // src/mcp/tools-docs.ts
 function registerDocsTools(mcp) {
   mcp.tool(
@@ -103380,8 +104570,8 @@ function registerDocsTools(mcp) {
 // src/mcp/tools-model.ts
 init_api6();
 init_annotation_generator();
-import * as fs36 from "fs";
-import * as path40 from "path";
+import * as fs37 from "fs";
+import * as path41 from "path";
 var stepSchema = external_exports.object({
   name: external_exports.string().describe("Function name for this node"),
   description: external_exports.string().optional().describe("Brief description of what this node does"),
@@ -103418,7 +104608,7 @@ function registerModelTools(mcp) {
     },
     async (args) => {
       try {
-        const outputPath = path40.resolve(args.filePath);
+        const outputPath = path41.resolve(args.filePath);
         const lines = [];
         for (const step of args.steps) {
           lines.push("/** @flowWeaver node */");
@@ -103446,11 +104636,11 @@ function registerModelTools(mcp) {
         lines.push(...jsdocLines);
         lines.push("");
         const content = lines.join("\n");
-        const dir = path40.dirname(outputPath);
-        if (!fs36.existsSync(dir)) {
-          fs36.mkdirSync(dir, { recursive: true });
+        const dir = path41.dirname(outputPath);
+        if (!fs37.existsSync(dir)) {
+          fs37.mkdirSync(dir, { recursive: true });
         }
-        fs36.writeFileSync(outputPath, content, "utf8");
+        fs37.writeFileSync(outputPath, content, "utf8");
         return makeToolResult({
           filePath: outputPath,
           workflowName: args.name,
@@ -103474,7 +104664,7 @@ function registerModelTools(mcp) {
     },
     async (args) => {
       try {
-        const filePath = path40.resolve(args.filePath);
+        const filePath = path41.resolve(args.filePath);
         const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
         if (parseResult.errors.length > 0) {
           return makeErrorResult("PARSE_ERROR", `Parse errors:
@@ -103543,8 +104733,8 @@ ${parseResult.errors.join("\n")}`);
     },
     async (args) => {
       try {
-        const filePath = path40.resolve(args.filePath);
-        if (!fs36.existsSync(filePath)) {
+        const filePath = path41.resolve(args.filePath);
+        if (!fs37.existsSync(filePath)) {
           return makeErrorResult("FILE_NOT_FOUND", `File not found: ${args.filePath}`);
         }
         const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
@@ -103569,7 +104759,7 @@ ${parseResult.errors.join("\n")}`);
             `Stub "${args.nodeName}" not found. Available stubs: ${stubs.join(", ") || "none"}`
           );
         }
-        const source = fs36.readFileSync(filePath, "utf8");
+        const source = fs37.readFileSync(filePath, "utf8");
         const found = findDeclareFunction(source, stubNt.functionName);
         if (!found) {
           return makeErrorResult(
@@ -103586,7 +104776,7 @@ ${parseResult.errors.join("\n")}`);
           replacement = signatureLines.map((line) => found.indent + line).join("\n");
         }
         const updated = source.replace(found.match, replacement);
-        fs36.writeFileSync(filePath, updated, "utf8");
+        fs37.writeFileSync(filePath, updated, "utf8");
         return makeToolResult({
           nodeName: stubNt.functionName,
           filePath,
@@ -103625,8 +104815,8 @@ function escapeRegex2(str2) {
 // src/mcp/tools-debug.ts
 init_api6();
 init_query();
-import * as path42 from "path";
-import * as fs38 from "fs";
+import * as path43 from "path";
+import * as fs39 from "fs";
 
 // src/runtime/debug-controller.ts
 var DebugController = class {
@@ -103853,8 +105043,8 @@ var DebugController = class {
 };
 
 // src/runtime/checkpoint.ts
-import * as fs37 from "fs";
-import * as path41 from "path";
+import * as fs38 from "fs";
+import * as path42 from "path";
 import * as crypto from "crypto";
 function isUnserializableMarker(value2) {
   return typeof value2 === "object" && value2 !== null && value2.__fw_unserializable__ === true;
@@ -103899,7 +105089,7 @@ function serializeValue(key, value2, unsafeNodes) {
   }
 }
 function hashFile(filePath) {
-  const content = fs37.readFileSync(filePath, "utf8");
+  const content = fs38.readFileSync(filePath, "utf8");
   return crypto.createHash("sha256").update(content).digest("hex");
 }
 var CheckpointWriter = class {
@@ -103912,12 +105102,12 @@ var CheckpointWriter = class {
   checkpointPath;
   writeLock = Promise.resolve();
   constructor(workflowFilePath, workflowName, runId, params = {}) {
-    this.filePath = path41.resolve(workflowFilePath);
+    this.filePath = path42.resolve(workflowFilePath);
     this.workflowName = workflowName;
     this.runId = runId;
     this.params = params;
-    this.dir = path41.join(path41.dirname(this.filePath), ".fw-checkpoints");
-    this.checkpointPath = path41.join(this.dir, `${workflowName}-${runId}.json`);
+    this.dir = path42.join(path42.dirname(this.filePath), ".fw-checkpoints");
+    this.checkpointPath = path42.join(this.dir, `${workflowName}-${runId}.json`);
     this.workflowHash = hashFile(this.filePath);
   }
   /**
@@ -103933,13 +105123,13 @@ var CheckpointWriter = class {
   /** Clean up checkpoint file after successful completion */
   cleanup() {
     try {
-      if (fs37.existsSync(this.checkpointPath)) {
-        fs37.unlinkSync(this.checkpointPath);
+      if (fs38.existsSync(this.checkpointPath)) {
+        fs38.unlinkSync(this.checkpointPath);
       }
-      if (fs37.existsSync(this.dir)) {
-        const remaining = fs37.readdirSync(this.dir);
+      if (fs38.existsSync(this.dir)) {
+        const remaining = fs38.readdirSync(this.dir);
         if (remaining.length === 0) {
-          fs37.rmdirSync(this.dir);
+          fs38.rmdirSync(this.dir);
         }
       }
     } catch {
@@ -103971,21 +105161,21 @@ var CheckpointWriter = class {
       nodeExecutionCounts: serialized.nodeExecutionCounts,
       unsafeNodes: [...unsafeNodes]
     };
-    if (!fs37.existsSync(this.dir)) {
-      fs37.mkdirSync(this.dir, { recursive: true });
+    if (!fs38.existsSync(this.dir)) {
+      fs38.mkdirSync(this.dir, { recursive: true });
     }
-    fs37.writeFileSync(this.checkpointPath, JSON.stringify(data, null, 2), "utf8");
+    fs38.writeFileSync(this.checkpointPath, JSON.stringify(data, null, 2), "utf8");
   }
 };
 function loadCheckpoint(checkpointPath, workflowFilePath) {
-  const raw = fs37.readFileSync(checkpointPath, "utf8");
+  const raw = fs38.readFileSync(checkpointPath, "utf8");
   const data = JSON.parse(raw);
   if (data.version !== 1) {
     throw new Error(`Unsupported checkpoint version: ${data.version}`);
   }
   let stale = false;
   if (workflowFilePath) {
-    const currentHash = hashFile(path41.resolve(workflowFilePath));
+    const currentHash = hashFile(path42.resolve(workflowFilePath));
     stale = currentHash !== data.workflowHash;
   }
   const unsafeSet = new Set(data.unsafeNodes);
@@ -104011,12 +105201,12 @@ function loadCheckpoint(checkpointPath, workflowFilePath) {
   return { data, stale, rerunNodes, skipNodes };
 }
 function findLatestCheckpoint(workflowFilePath, workflowName) {
-  const dir = path41.join(path41.dirname(path41.resolve(workflowFilePath)), ".fw-checkpoints");
-  if (!fs37.existsSync(dir)) return null;
-  const files = fs37.readdirSync(dir).filter((f) => f.endsWith(".json")).filter((f) => !workflowName || f.startsWith(`${workflowName}-`));
+  const dir = path42.join(path42.dirname(path42.resolve(workflowFilePath)), ".fw-checkpoints");
+  if (!fs38.existsSync(dir)) return null;
+  const files = fs38.readdirSync(dir).filter((f) => f.endsWith(".json")).filter((f) => !workflowName || f.startsWith(`${workflowName}-`));
   if (files.length === 0) return null;
-  const sorted = files.map((f) => ({ name: f, mtime: fs37.statSync(path41.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-  return path41.join(dir, sorted[0].name);
+  const sorted = files.map((f) => ({ name: f, mtime: fs38.statSync(path42.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  return path42.join(dir, sorted[0].name);
 }
 
 // src/mcp/tools-debug.ts
@@ -104045,7 +105235,7 @@ function listDebugSessions() {
 
 // src/mcp/tools-debug.ts
 async function getExecutionOrder(filePath, workflowName) {
-  const source = fs38.readFileSync(path42.resolve(filePath), "utf8");
+  const source = fs39.readFileSync(path43.resolve(filePath), "utf8");
   const parsed = await parseWorkflow(source, { workflowName });
   if (parsed.errors.length > 0) {
     throw new Error(`Failed to parse workflow: ${parsed.errors.join(", ")}`);
@@ -104080,7 +105270,7 @@ function cleanupDebugSession(debugId) {
   if (!session) return;
   for (const tmpFile of session.tmpFiles) {
     try {
-      fs38.unlinkSync(tmpFile);
+      fs39.unlinkSync(tmpFile);
     } catch {
     }
   }
@@ -104496,161 +105686,6 @@ function registerDebugTools(mcp) {
   );
 }
 
-// src/context/index.ts
-init_grammar_diagrams();
-var PRESETS = {
-  core: ["concepts", "jsdoc-grammar", "tutorial"],
-  authoring: [
-    "concepts",
-    "jsdoc-grammar",
-    "advanced-annotations",
-    "built-in-nodes",
-    "scaffold",
-    "node-conversion",
-    "patterns"
-  ],
-  ops: [
-    "cli-reference",
-    "compilation",
-    "deployment",
-    "export-interface",
-    "debugging",
-    "error-codes"
-  ],
-  full: [
-    "concepts",
-    "tutorial",
-    "jsdoc-grammar",
-    "advanced-annotations",
-    "built-in-nodes",
-    "cli-reference",
-    "compilation",
-    "debugging",
-    "deployment",
-    "error-codes",
-    "export-interface",
-    "iterative-development",
-    "marketplace",
-    "node-conversion",
-    "patterns",
-    "scaffold"
-  ]
-};
-var PRESET_NAMES = Object.keys(PRESETS);
-var STANDALONE_PREAMBLE = `# Flow Weaver Reference
-
-Flow Weaver is a TypeScript workflow compiler. You write plain .ts files with
-JSDoc annotations (@flowWeaver nodeType, @flowWeaver workflow, @input, @output,
-@connect, @node, @scope). The compiler parses these annotations, validates the
-graph, and generates executable code inline. The source file is the workflow:
-no JSON configs, no YAML, no separate graph files.
-
-Key concepts: node types define reusable processing steps with typed input/output
-ports. Workflows instantiate nodes and connect their ports. Start and Exit are
-implicit boundary nodes. The compiler handles execution ordering, type checking,
-and code generation.`;
-function buildAssistantPreamble() {
-  const allSlugs = listTopics().map((t) => t.slug);
-  return `# Flow Weaver Context
-
-You have Flow Weaver MCP tools available (fw_ prefix). Use them to create,
-modify, validate, compile, and inspect workflows without manual file editing.
-
-For documentation not included below, call fw_docs(action="read", topic="<slug>").
-Available topic slugs: ${allSlugs.join(", ")}.
-
-Tool quick reference:
-- fw_create_model: Build workflow from structured description (steps + flow path)
-- fw_implement_node: Replace a declare stub with a real function body
-- fw_modify / fw_modify_batch: Add/remove nodes, connections, rename, reposition
-- fw_validate: Check for errors after any change
-- fw_describe: Inspect structure. Use format "text" for readable, "json" for data
-- fw_diagram: Visualize. Prefer format "ascii-compact" in chat contexts
-- fw_compile: Generate executable TypeScript from annotations
-- fw_docs: Look up reference docs by topic slug
-- fw_scaffold: Create from templates (sequential, foreach, ai-agent, etc.)
-
-File conventions: .ts extension, camelCase node names, PascalCase workflow names.`;
-}
-function resolveTopics(preset, explicit, add) {
-  const base = explicit ?? PRESETS[preset];
-  const combined = add ? [...base, ...add] : base;
-  return [...new Set(combined)];
-}
-function buildGrammarSection() {
-  const grammars = getAllGrammars();
-  const allProductions = [
-    ...grammars.port,
-    ...grammars.node,
-    ...grammars.connect,
-    ...grammars.position,
-    ...grammars.scope
-  ];
-  const ebnf = serializedToEBNF(allProductions);
-  return `## JSDoc Annotation Grammar (EBNF)
-
-\`\`\`ebnf
-${ebnf}
-\`\`\``;
-}
-function buildContext(options = {}) {
-  const profile = options.profile ?? "standalone";
-  const preset = options.preset ?? "core";
-  const includeGrammar = options.includeGrammar ?? true;
-  const topicSlugs = resolveTopics(preset, options.topics, options.addTopics);
-  const sections = [];
-  if (profile === "standalone") {
-    sections.push(STANDALONE_PREAMBLE);
-  } else {
-    sections.push(buildAssistantPreamble());
-  }
-  if (includeGrammar) {
-    sections.push(buildGrammarSection());
-  }
-  let topicCount = 0;
-  const includedSlugs = [];
-  for (const slug of topicSlugs) {
-    const doc = readTopic(slug, true);
-    if (!doc) continue;
-    let body = doc.content;
-    if (body.startsWith("# ")) {
-      const lines = body.split("\n");
-      let startLine = 1;
-      if (lines.length > 1 && lines[1].trim() && !lines[1].startsWith("#")) {
-        startLine = 2;
-      }
-      body = lines.slice(startLine).join("\n").replace(/^\n+/, "");
-    }
-    const bodyLines = body.split("\n");
-    let inCode = false;
-    for (let i = 0; i < bodyLines.length; i++) {
-      if (bodyLines[i].trimStart().startsWith("```")) {
-        inCode = !inCode;
-        continue;
-      }
-      if (!inCode && bodyLines[i].match(/^#{1,5}\s/)) {
-        bodyLines[i] = "##" + bodyLines[i];
-      }
-    }
-    body = bodyLines.join("\n");
-    const heading = doc.name || slug;
-    sections.push(`## ${heading}
-
-${body}`);
-    topicCount++;
-    includedSlugs.push(slug);
-  }
-  const content = sections.join("\n\n---\n\n");
-  const lineCount = content.split("\n").length;
-  return {
-    content,
-    topicCount,
-    lineCount,
-    topicSlugs: includedSlugs,
-    profile
-  };
-}
-
 // src/mcp/tools-context.ts
 function registerContextTools(mcp) {
   mcp.tool(
@@ -105007,7 +106042,7 @@ async function uiBatch(json2, options) {
 
 // src/cli/commands/grammar.ts
 init_grammar_diagrams();
-import * as fs39 from "fs";
+import * as fs40 from "fs";
 init_error_utils();
 async function grammarCommand(options = {}) {
   const defaultFormat = options.output ? "html" : process.stdout.isTTY ? "ebnf" : "html";
@@ -105028,7 +106063,7 @@ async function grammarCommand(options = {}) {
       content = generateGrammarDiagrams();
     }
     if (output) {
-      fs39.writeFileSync(output, content, "utf-8");
+      fs40.writeFileSync(output, content, "utf-8");
       logger.success(`Grammar written to ${output}`);
     } else {
       process.stdout.write(content);
@@ -105041,14 +106076,14 @@ async function grammarCommand(options = {}) {
 
 // src/cli/commands/run.ts
 init_workflow_executor();
-import * as path43 from "path";
-import * as fs40 from "fs";
+import * as path44 from "path";
+import * as fs41 from "fs";
 import * as readline8 from "readline";
 init_query();
 init_error_utils();
 init_api6();
 function displayPath2(filePath) {
-  const rel = path43.relative(process.cwd(), filePath);
+  const rel = path44.relative(process.cwd(), filePath);
   if (rel && !rel.startsWith("..") && rel.length < filePath.length) {
     return rel;
   }
@@ -105067,8 +106102,8 @@ async function runCommand(input, options) {
   await runCommandInner(input, options);
 }
 async function runCommandInner(input, options) {
-  const filePath = path43.resolve(input);
-  if (!fs40.existsSync(filePath)) {
+  const filePath = path44.resolve(input);
+  if (!fs41.existsSync(filePath)) {
     throw new Error(`File not found: ${displayPath2(filePath)}`);
   }
   let params = {};
@@ -105079,12 +106114,12 @@ async function runCommandInner(input, options) {
       throw new Error(`Invalid JSON in --params: ${options.params}`);
     }
   } else if (options.paramsFile) {
-    const paramsFilePath = path43.resolve(options.paramsFile);
-    if (!fs40.existsSync(paramsFilePath)) {
+    const paramsFilePath = path44.resolve(options.paramsFile);
+    if (!fs41.existsSync(paramsFilePath)) {
       throw new Error(`Params file not found: ${paramsFilePath}`);
     }
     try {
-      const content = fs40.readFileSync(paramsFilePath, "utf8");
+      const content = fs41.readFileSync(paramsFilePath, "utf8");
       params = JSON.parse(content);
     } catch {
       throw new Error(`Failed to parse params file: ${options.paramsFile}`);
@@ -105098,12 +106133,12 @@ async function runCommandInner(input, options) {
       throw new Error(`Invalid JSON in --mocks: ${options.mocks}`);
     }
   } else if (options.mocksFile) {
-    const mocksFilePath = path43.resolve(options.mocksFile);
-    if (!fs40.existsSync(mocksFilePath)) {
+    const mocksFilePath = path44.resolve(options.mocksFile);
+    if (!fs41.existsSync(mocksFilePath)) {
       throw new Error(`Mocks file not found: ${mocksFilePath}`);
     }
     try {
-      const content = fs40.readFileSync(mocksFilePath, "utf8");
+      const content = fs41.readFileSync(mocksFilePath, "utf8");
       mocks = JSON.parse(content);
     } catch {
       throw new Error(`Failed to parse mocks file: ${options.mocksFile}`);
@@ -105173,7 +106208,7 @@ async function runCommandInner(input, options) {
     if (useDebug) {
       let executionOrder = resumeExecutionOrder;
       if (!executionOrder) {
-        const source = fs40.readFileSync(filePath, "utf8");
+        const source = fs41.readFileSync(filePath, "utf8");
         const parsed = await parseWorkflow(source, { workflowName: options.workflow });
         if (parsed.errors.length === 0) {
           executionOrder = getTopologicalOrder(parsed.ast);
@@ -105680,13 +106715,13 @@ function promptForInput(question) {
 }
 
 // src/cli/commands/serve.ts
-import * as path44 from "path";
-import * as fs42 from "fs";
+import * as path45 from "path";
+import * as fs43 from "fs";
 
 // src/server/workflow-registry.ts
 init_esm5();
 init_parser2();
-import * as fs41 from "fs";
+import * as fs42 from "fs";
 var WorkflowRegistry = class {
   constructor(workflowDir, options = {}) {
     this.workflowDir = workflowDir;
@@ -105721,7 +106756,7 @@ var WorkflowRegistry = class {
     this.endpoints.clear();
     for (const file of files) {
       try {
-        const content = fs41.readFileSync(file, "utf8");
+        const content = fs42.readFileSync(file, "utf8");
         if (!content.includes("@flowWeaver")) {
           continue;
         }
@@ -106114,11 +107149,11 @@ var WebhookServer = class {
 
 // src/cli/commands/serve.ts
 async function serveCommand(dir, options) {
-  const workflowDir = path44.resolve(dir || ".");
-  if (!fs42.existsSync(workflowDir)) {
+  const workflowDir = path45.resolve(dir || ".");
+  if (!fs43.existsSync(workflowDir)) {
     throw new Error(`Directory not found: ${workflowDir}`);
   }
-  if (!fs42.statSync(workflowDir).isDirectory()) {
+  if (!fs43.statSync(workflowDir).isDirectory()) {
     throw new Error(`Not a directory: ${workflowDir}`);
   }
   const port = options.port ?? 3e3;
@@ -106163,9 +107198,9 @@ async function serveCommand(dir, options) {
 // src/export/index.ts
 init_compile();
 init_parser2();
-import * as path45 from "path";
-import * as fs43 from "fs";
-import * as os2 from "os";
+import * as path46 from "path";
+import * as fs44 from "fs";
+import * as os3 from "os";
 async function exportWorkflow(options) {
   const { createTargetRegistry: createTargetRegistry2 } = await Promise.resolve().then(() => (init_deployment(), deployment_exports));
   const registry2 = await createTargetRegistry2(process.cwd());
@@ -106176,8 +107211,8 @@ async function exportWorkflow(options) {
       available.length === 0 ? `No export targets installed. Install a target pack (e.g. npm install flowweaver-pack-${options.target})` : `Unknown target "${options.target}". Installed: ${available.join(", ")}`
     );
   }
-  const inputPath = path45.resolve(options.input);
-  const outputDir = path45.resolve(options.output);
+  const inputPath = path46.resolve(options.input);
+  const outputDir = path46.resolve(options.output);
   const isDryRun = options.dryRun ?? false;
   if (options.multi) {
     return exportMultiWorkflowViaRegistry(
@@ -106197,7 +107232,7 @@ async function exportWorkflow(options) {
   );
 }
 async function exportSingleWorkflowViaRegistry(target, inputPath, outputDir, isDryRun, options) {
-  if (!fs43.existsSync(inputPath)) {
+  if (!fs44.existsSync(inputPath)) {
     throw new Error(`Input file not found: ${inputPath}`);
   }
   const parser3 = new AnnotationParser();
@@ -106229,8 +107264,8 @@ async function exportSingleWorkflowViaRegistry(target, inputPath, outputDir, isD
   );
   let compiledContent;
   if (needsCompiledWorkflow) {
-    const workDir = isDryRun ? path45.join(os2.tmpdir(), `fw-export-dryrun-${Date.now()}`) : outputDir;
-    fs43.mkdirSync(workDir, { recursive: true });
+    const workDir = isDryRun ? path46.join(os3.tmpdir(), `fw-export-dryrun-${Date.now()}`) : outputDir;
+    fs44.mkdirSync(workDir, { recursive: true });
     try {
       const compiledPath = await compileToOutput(
         inputPath,
@@ -106238,29 +107273,29 @@ async function exportSingleWorkflowViaRegistry(target, inputPath, outputDir, isD
         workDir,
         options.production
       );
-      compiledContent = fs43.readFileSync(compiledPath, "utf8");
+      compiledContent = fs44.readFileSync(compiledPath, "utf8");
     } finally {
       if (isDryRun) {
         try {
-          fs43.rmSync(workDir, { recursive: true, force: true });
+          fs44.rmSync(workDir, { recursive: true, force: true });
         } catch {
         }
       }
     }
   }
   const files = artifacts.files.map((f) => ({
-    path: path45.join(outputDir, f.relativePath),
+    path: path46.join(outputDir, f.relativePath),
     content: f.content
   }));
   if (compiledContent) {
-    const workflowOutputPath = path45.join(outputDir, "workflow.ts");
+    const workflowOutputPath = path46.join(outputDir, "workflow.ts");
     files.push({ path: workflowOutputPath, content: compiledContent });
   }
   if (!isDryRun) {
     for (const file of files) {
-      const dirPath = path45.dirname(file.path);
-      fs43.mkdirSync(dirPath, { recursive: true });
-      fs43.writeFileSync(file.path, file.content, "utf-8");
+      const dirPath = path46.dirname(file.path);
+      fs44.mkdirSync(dirPath, { recursive: true });
+      fs44.writeFileSync(file.path, file.content, "utf-8");
     }
   }
   return {
@@ -106271,7 +107306,7 @@ async function exportSingleWorkflowViaRegistry(target, inputPath, outputDir, isD
   };
 }
 async function exportMultiWorkflowViaRegistry(target, inputPath, outputDir, isDryRun, options) {
-  if (!fs43.existsSync(inputPath)) {
+  if (!fs44.existsSync(inputPath)) {
     throw new Error(`Input file not found: ${inputPath}`);
   }
   const parser3 = new AnnotationParser();
@@ -106289,7 +107324,7 @@ async function exportMultiWorkflowViaRegistry(target, inputPath, outputDir, isDr
       throw new Error(`None of the requested workflows found. Available: ${available}`);
     }
   }
-  const serviceName = path45.basename(options.input, path45.extname(options.input)) + "-service";
+  const serviceName = path46.basename(options.input, path46.extname(options.input)) + "-service";
   const bundleWorkflows = selectedWorkflows.map((w) => ({
     name: w.name,
     functionName: w.functionName,
@@ -106314,15 +107349,15 @@ async function exportMultiWorkflowViaRegistry(target, inputPath, outputDir, isDr
   });
   const files = artifacts.files.map(
     (f) => ({
-      path: path45.join(outputDir, f.relativePath),
+      path: path46.join(outputDir, f.relativePath),
       content: f.content
     })
   );
   if (!isDryRun) {
     for (const file of files) {
-      const dirPath = path45.dirname(file.path);
-      fs43.mkdirSync(dirPath, { recursive: true });
-      fs43.writeFileSync(file.path, file.content, "utf-8");
+      const dirPath = path46.dirname(file.path);
+      fs44.mkdirSync(dirPath, { recursive: true });
+      fs44.writeFileSync(file.path, file.content, "utf-8");
     }
   }
   return {
@@ -106333,8 +107368,8 @@ async function exportMultiWorkflowViaRegistry(target, inputPath, outputDir, isDr
   };
 }
 async function compileToOutput(inputPath, functionName, outputDir, production) {
-  const outputPath = path45.join(outputDir, "workflow.ts");
-  fs43.copyFileSync(inputPath, outputPath);
+  const outputPath = path46.join(outputDir, "workflow.ts");
+  fs44.copyFileSync(inputPath, outputPath);
   await compileWorkflow(outputPath, {
     write: true,
     inPlace: true,
@@ -106454,15 +107489,15 @@ async function exportCommand(input, options) {
 }
 
 // src/cli/commands/openapi.ts
-import * as path46 from "path";
-import * as fs44 from "fs";
+import * as path47 from "path";
+import * as fs45 from "fs";
 init_generator();
 async function openapiCommand(dir, options) {
-  const workflowDir = path46.resolve(dir);
-  if (!fs44.existsSync(workflowDir)) {
+  const workflowDir = path47.resolve(dir);
+  if (!fs45.existsSync(workflowDir)) {
     throw new Error(`Directory not found: ${workflowDir}`);
   }
-  if (!fs44.statSync(workflowDir).isDirectory()) {
+  if (!fs45.statSync(workflowDir).isDirectory()) {
     throw new Error(`Not a directory: ${workflowDir}`);
   }
   const registry2 = new WorkflowRegistry(workflowDir);
@@ -106483,8 +107518,8 @@ async function openapiCommand(dir, options) {
   const format = options.format || "json";
   const spec = format === "yaml" ? generateOpenAPIYaml(endpoints, generatorOptions) : generateOpenAPIJson(endpoints, generatorOptions);
   if (options.output) {
-    const outputPath = path46.resolve(options.output);
-    fs44.writeFileSync(outputPath, spec);
+    const outputPath = path47.resolve(options.output);
+    fs45.writeFileSync(outputPath, spec);
     logger.success(`OpenAPI specification written to ${outputPath}`);
   } else {
     process.stdout.write(spec + "\n");
@@ -106492,8 +107527,8 @@ async function openapiCommand(dir, options) {
 }
 
 // src/cli/commands/plugin.ts
-import * as fs45 from "fs";
-import * as path47 from "path";
+import * as fs46 from "fs";
+import * as path48 from "path";
 var PLUGIN_NAME_RE = /^[a-zA-Z0-9][-a-zA-Z0-9_.]*$/;
 var VALID_AREAS = ["sidebar", "main", "toolbar", "modal", "panel"];
 function validatePluginName(name) {
@@ -106620,18 +107655,18 @@ async function pluginInitCommand(name, options) {
     }
     return;
   }
-  const targetDir = path47.resolve("plugins", name);
+  const targetDir = path48.resolve("plugins", name);
   const filesCreated = [];
   const filesSkipped = [];
   for (const [relativePath, content] of Object.entries(files)) {
-    const absPath = path47.join(targetDir, relativePath);
-    const dir = path47.dirname(absPath);
-    fs45.mkdirSync(dir, { recursive: true });
-    if (fs45.existsSync(absPath) && !force) {
+    const absPath = path48.join(targetDir, relativePath);
+    const dir = path48.dirname(absPath);
+    fs46.mkdirSync(dir, { recursive: true });
+    if (fs46.existsSync(absPath) && !force) {
       filesSkipped.push(relativePath);
       continue;
     }
-    fs45.writeFileSync(absPath, content, "utf8");
+    fs46.writeFileSync(absPath, content, "utf8");
     filesCreated.push(relativePath);
   }
   logger.section("Plugin scaffolded");
@@ -106652,8 +107687,8 @@ async function pluginInitCommand(name, options) {
 init_esm5();
 init_api6();
 init_generate_in_place();
-import * as fs46 from "fs";
-import * as path48 from "path";
+import * as fs47 from "fs";
+import * as path49 from "path";
 init_error_utils();
 async function migrateCommand(globPattern, options = {}) {
   const { dryRun = false, diff = false } = options;
@@ -106671,9 +107706,9 @@ async function migrateCommand(globPattern, options = {}) {
   let skippedCount = 0;
   let errorCount = 0;
   for (const file of files) {
-    const filePath = path48.resolve(file);
+    const filePath = path49.resolve(file);
     try {
-      const sourceCode = fs46.readFileSync(filePath, "utf8");
+      const sourceCode = fs47.readFileSync(filePath, "utf8");
       const parseResult = await parseWorkflow(filePath);
       if (parseResult.errors.length > 0) {
         logger.error(`  ${file}: parse errors \u2014 skipping`);
@@ -106706,7 +107741,7 @@ ${file}:`);
         migratedCount++;
         continue;
       }
-      fs46.writeFileSync(filePath, genResult.code, "utf8");
+      fs47.writeFileSync(filePath, genResult.code, "utf8");
       logger.success(`  ${file}: migrated`);
       migratedCount++;
     } catch (error2) {
@@ -106723,7 +107758,7 @@ ${file}:`);
 }
 
 // src/cli/commands/changelog.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 var CATEGORIES2 = [
   { name: "Grammar", match: (f) => /parser|chevrotain|grammar/.test(f) },
   { name: "Code Generation", match: (f) => /generator|body-generator|generate/.test(f) },
@@ -106750,7 +107785,7 @@ function getGitRange(options) {
   }
   if (options.lastTag) {
     try {
-      const lastTag = execSync4("git describe --tags --abbrev=0", {
+      const lastTag = execSync5("git describe --tags --abbrev=0", {
         encoding: "utf8"
       }).trim();
       return `${lastTag}..HEAD`;
@@ -106775,7 +107810,7 @@ function getCommits(rangeArg) {
   } else {
     logCmd = `git log ${rangeArg} --format="%H %s" --no-merges`;
   }
-  const logOutput = execSync4(logCmd, { encoding: "utf8" }).trim();
+  const logOutput = execSync5(logCmd, { encoding: "utf8" }).trim();
   if (!logOutput) {
     return [];
   }
@@ -106787,7 +107822,7 @@ function getCommits(rangeArg) {
     const message = line.slice(spaceIdx + 1);
     let files;
     try {
-      const filesOutput = execSync4(`git diff-tree --no-commit-id --name-only -r ${hash}`, {
+      const filesOutput = execSync5(`git diff-tree --no-commit-id --name-only -r ${hash}`, {
         encoding: "utf8"
       }).trim();
       files = filesOutput ? filesOutput.split(/\r?\n/) : [];
@@ -106839,21 +107874,21 @@ async function changelogCommand(options = {}) {
 // src/cli/commands/strip.ts
 init_esm5();
 init_generate_in_place();
-import * as fs47 from "fs";
-import * as path49 from "path";
+import * as fs48 from "fs";
+import * as path50 from "path";
 async function stripCommand(input, options = {}) {
   const { output, dryRun = false, verbose = false } = options;
   let pattern = input;
   try {
-    if (fs47.existsSync(input) && fs47.statSync(input).isDirectory()) {
-      pattern = path49.join(input, "**/*.ts");
+    if (fs48.existsSync(input) && fs48.statSync(input).isDirectory()) {
+      pattern = path50.join(input, "**/*.ts");
     }
   } catch {
   }
   const allFiles = await glob(pattern, { absolute: true });
   const files = allFiles.filter((f) => {
     try {
-      return fs47.statSync(f).isFile();
+      return fs48.statSync(f).isFile();
     } catch {
       return false;
     }
@@ -106866,28 +107901,28 @@ async function stripCommand(input, options = {}) {
   let stripped = 0;
   let skipped = 0;
   for (const filePath of files) {
-    const content = fs47.readFileSync(filePath, "utf-8");
+    const content = fs48.readFileSync(filePath, "utf-8");
     if (!hasInPlaceMarkers(content)) {
       skipped++;
       if (verbose) {
-        logger.info(`Skipped (no markers): ${path49.relative(process.cwd(), filePath)}`);
+        logger.info(`Skipped (no markers): ${path50.relative(process.cwd(), filePath)}`);
       }
       continue;
     }
     const result = stripGeneratedSections(content);
     if (dryRun) {
-      logger.info(`Would strip: ${path49.relative(process.cwd(), filePath)}`);
+      logger.info(`Would strip: ${path50.relative(process.cwd(), filePath)}`);
       stripped++;
       continue;
     }
-    const outPath = output ? path49.join(path49.resolve(output), path49.basename(filePath)) : filePath;
+    const outPath = output ? path50.join(path50.resolve(output), path50.basename(filePath)) : filePath;
     if (output) {
-      fs47.mkdirSync(path49.dirname(outPath), { recursive: true });
+      fs48.mkdirSync(path50.dirname(outPath), { recursive: true });
     }
-    fs47.writeFileSync(outPath, result);
+    fs48.writeFileSync(outPath, result);
     stripped++;
     if (verbose) {
-      logger.success(`Stripped: ${path49.relative(process.cwd(), outPath)}`);
+      logger.success(`Stripped: ${path50.relative(process.cwd(), outPath)}`);
     }
   }
   const verb = dryRun ? "would be stripped" : "stripped";
@@ -106968,7 +108003,7 @@ async function docsSearchCommand(query, options) {
 }
 
 // src/cli/commands/context.ts
-import * as fs48 from "fs";
+import * as fs49 from "fs";
 async function contextCommand(preset, options) {
   if (options.list) {
     logger.section("Context Presets");
@@ -107003,7 +108038,7 @@ async function contextCommand(preset, options) {
     includeGrammar: options.grammar !== false
   });
   if (options.output) {
-    fs48.writeFileSync(options.output, result.content, "utf-8");
+    fs49.writeFileSync(options.output, result.content, "utf-8");
     logger.success(`Context written to ${options.output}`);
   } else {
     process.stdout.write(result.content);
@@ -107016,8 +108051,8 @@ async function contextCommand(preset, options) {
 // src/cli/commands/status.ts
 init_api6();
 init_validator();
-import * as fs49 from "fs";
-import * as path50 from "path";
+import * as fs50 from "fs";
+import * as path51 from "path";
 init_error_utils();
 function formatPortList(ports) {
   return Object.entries(ports).filter(([name]) => name !== "execute" && name !== "onSuccess" && name !== "onFailure").map(([name, port]) => `${name}(${port.dataType.toLowerCase()})`);
@@ -107025,8 +108060,8 @@ function formatPortList(ports) {
 async function statusCommand(input, options = {}) {
   const { workflowName, json: json2 = false } = options;
   try {
-    const filePath = path50.resolve(input);
-    if (!fs49.existsSync(filePath)) {
+    const filePath = path51.resolve(input);
+    if (!fs50.existsSync(filePath)) {
       if (json2) {
         console.log(JSON.stringify({ error: `File not found: ${input}` }));
       } else {
@@ -107120,8 +108155,8 @@ async function statusCommand(input, options = {}) {
 // src/cli/commands/implement.ts
 init_api6();
 init_annotation_generator();
-import * as fs50 from "fs";
-import * as path51 from "path";
+import * as fs51 from "fs";
+import * as path52 from "path";
 init_error_utils();
 function findDeclareFunction2(source, functionName) {
   const lines = source.split("\n");
@@ -107144,8 +108179,8 @@ function findDeclareFunction2(source, functionName) {
 async function implementCommand(input, nodeName, options = {}) {
   const { workflowName, preview = false } = options;
   try {
-    const filePath = path51.resolve(input);
-    if (!fs50.existsSync(filePath)) {
+    const filePath = path52.resolve(input);
+    if (!fs51.existsSync(filePath)) {
       logger.error(`File not found: ${input}`);
       process.exit(1);
     }
@@ -107175,7 +108210,7 @@ async function implementCommand(input, nodeName, options = {}) {
       }
       process.exit(1);
     }
-    const source = fs50.readFileSync(filePath, "utf8");
+    const source = fs51.readFileSync(filePath, "utf8");
     const found = findDeclareFunction2(source, stubNodeType.functionName);
     if (!found) {
       logger.error(`Could not find "declare function ${stubNodeType.functionName}" in source file.`);
@@ -107190,8 +108225,8 @@ async function implementCommand(input, nodeName, options = {}) {
       console.log(replacement);
     } else {
       const updated = source.replace(found.match, replacement);
-      fs50.writeFileSync(filePath, updated, "utf8");
-      logger.success(`Implemented ${stubNodeType.functionName} in ${path51.basename(filePath)}`);
+      fs51.writeFileSync(filePath, updated, "utf8");
+      logger.success(`Implemented ${stubNodeType.functionName} in ${path52.basename(filePath)}`);
     }
   } catch (error2) {
     logger.error(`Implement failed: ${getErrorMessage(error2)}`);
@@ -107200,9 +108235,9 @@ async function implementCommand(input, nodeName, options = {}) {
 }
 
 // src/cli/commands/market.ts
-import * as fs51 from "fs";
-import * as path52 from "path";
-import { execSync as execSync5 } from "child_process";
+import * as fs52 from "fs";
+import * as path53 from "path";
+import { execSync as execSync6 } from "child_process";
 init_error_utils();
 async function marketInitCommand(name, options = {}) {
   if (!name.startsWith("flowweaver-pack-")) {
@@ -107210,11 +108245,11 @@ async function marketInitCommand(name, options = {}) {
     logger.warn(`Name should follow "flowweaver-pack-*" convention, using "${suggested}"`);
     name = suggested;
   }
-  const targetDir = path52.resolve(name);
-  if (fs51.existsSync(targetDir)) {
-    const stat2 = fs51.statSync(targetDir);
+  const targetDir = path53.resolve(name);
+  if (fs52.existsSync(targetDir)) {
+    const stat2 = fs52.statSync(targetDir);
     if (stat2.isDirectory()) {
-      const contents = fs51.readdirSync(targetDir);
+      const contents = fs52.readdirSync(targetDir);
       if (contents.length > 0) {
         logger.error(`Directory "${name}" already exists and is not empty`);
         process.exit(1);
@@ -107229,13 +108264,13 @@ async function marketInitCommand(name, options = {}) {
   logger.newline();
   const dirs = [
     targetDir,
-    path52.join(targetDir, "src"),
-    path52.join(targetDir, "src", "node-types"),
-    path52.join(targetDir, "src", "workflows"),
-    path52.join(targetDir, "src", "patterns")
+    path53.join(targetDir, "src"),
+    path53.join(targetDir, "src", "node-types"),
+    path53.join(targetDir, "src", "workflows"),
+    path53.join(targetDir, "src", "patterns")
   ];
   for (const dir of dirs) {
-    fs51.mkdirSync(dir, { recursive: true });
+    fs52.mkdirSync(dir, { recursive: true });
   }
   const shortName = name.replace(/^flowweaver-pack-/, "");
   const pkg = {
@@ -107266,8 +108301,8 @@ async function marketInitCommand(name, options = {}) {
     },
     files: ["dist", "flowweaver.manifest.json", "README.md", "LICENSE"]
   };
-  fs51.writeFileSync(
-    path52.join(targetDir, "package.json"),
+  fs52.writeFileSync(
+    path53.join(targetDir, "package.json"),
     JSON.stringify(pkg, null, 2) + "\n"
   );
   const tsconfig = {
@@ -107285,8 +108320,8 @@ async function marketInitCommand(name, options = {}) {
     include: ["src"],
     exclude: ["node_modules", "dist"]
   };
-  fs51.writeFileSync(
-    path52.join(targetDir, "tsconfig.json"),
+  fs52.writeFileSync(
+    path53.join(targetDir, "tsconfig.json"),
     JSON.stringify(tsconfig, null, 2) + "\n"
   );
   const sampleNodeType = `/**
@@ -107304,21 +108339,21 @@ export function sample(execute: () => void, data: string): { result: string } {
   return { result: data.toUpperCase() };
 }
 `;
-  fs51.writeFileSync(path52.join(targetDir, "src", "node-types", "sample.ts"), sampleNodeType);
-  fs51.writeFileSync(
-    path52.join(targetDir, "src", "node-types", "index.ts"),
+  fs52.writeFileSync(path53.join(targetDir, "src", "node-types", "sample.ts"), sampleNodeType);
+  fs52.writeFileSync(
+    path53.join(targetDir, "src", "node-types", "index.ts"),
     "export { sample } from './sample.js';\n"
   );
-  fs51.writeFileSync(
-    path52.join(targetDir, "src", "workflows", "index.ts"),
+  fs52.writeFileSync(
+    path53.join(targetDir, "src", "workflows", "index.ts"),
     "// Export workflows here\n"
   );
-  fs51.writeFileSync(
-    path52.join(targetDir, "src", "patterns", "index.ts"),
+  fs52.writeFileSync(
+    path53.join(targetDir, "src", "patterns", "index.ts"),
     "// Export patterns here\n"
   );
-  fs51.writeFileSync(
-    path52.join(targetDir, "src", "index.ts"),
+  fs52.writeFileSync(
+    path53.join(targetDir, "src", "index.ts"),
     [
       "export * from './node-types/index.js';",
       "export * from './workflows/index.js';",
@@ -107351,9 +108386,9 @@ npm run pack    # Generate flowweaver.manifest.json
 npm publish     # Publish to npm
 \`\`\`
 `;
-  fs51.writeFileSync(path52.join(targetDir, "README.md"), readme);
-  fs51.writeFileSync(
-    path52.join(targetDir, ".gitignore"),
+  fs52.writeFileSync(path53.join(targetDir, "README.md"), readme);
+  fs52.writeFileSync(
+    path53.join(targetDir, ".gitignore"),
     ["node_modules", "dist", "*.tgz", ""].join("\n")
   );
   logger.success("Created package.json");
@@ -107373,7 +108408,7 @@ npm publish     # Publish to npm
   logger.newline();
 }
 async function marketPackCommand(directory, options = {}) {
-  const dir = path52.resolve(directory ?? ".");
+  const dir = path53.resolve(directory ?? ".");
   const { json: json2 = false, verbose = false } = options;
   if (!json2) {
     logger.section("Packing Marketplace Package");
@@ -107414,28 +108449,28 @@ async function marketPackCommand(directory, options = {}) {
   }
   const outPath = writeManifest(dir, manifest);
   logger.newline();
-  logger.success(`Manifest written to ${path52.relative(dir, outPath)}`);
+  logger.success(`Manifest written to ${path53.relative(dir, outPath)}`);
   if (warnings.length > 0) {
     logger.warn(`${warnings.length} warning(s) \u2014 consider fixing before publishing`);
   }
   logger.newline();
 }
 async function marketPublishCommand(directory, options = {}) {
-  const dir = path52.resolve(directory ?? ".");
+  const dir = path53.resolve(directory ?? ".");
   const { dryRun = false, tag } = options;
   logger.section("Publishing Marketplace Package");
   await marketPackCommand(dir, { json: false });
-  if (!fs51.existsSync(path52.join(dir, "LICENSE"))) {
+  if (!fs52.existsSync(path53.join(dir, "LICENSE"))) {
     logger.warn("LICENSE file not found \u2014 consider adding one");
   }
-  const pkg = JSON.parse(fs51.readFileSync(path52.join(dir, "package.json"), "utf-8"));
+  const pkg = JSON.parse(fs52.readFileSync(path53.join(dir, "package.json"), "utf-8"));
   logger.info(`Publishing ${pkg.name}@${pkg.version}`);
   const npmArgs = ["publish"];
   if (dryRun) npmArgs.push("--dry-run");
   if (tag) npmArgs.push("--tag", tag);
   try {
     logger.newline();
-    execSync5(`npm ${npmArgs.join(" ")}`, { cwd: dir, stdio: "inherit" });
+    execSync6(`npm ${npmArgs.join(" ")}`, { cwd: dir, stdio: "inherit" });
     if (!dryRun) {
       logger.newline();
       logger.success(`Published ${pkg.name}@${pkg.version} to npm`);
@@ -107453,7 +108488,7 @@ async function marketInstallCommand(packageSpec, options = {}) {
     logger.newline();
   }
   try {
-    execSync5(`npm install ${packageSpec}`, { stdio: json2 ? "pipe" : "inherit" });
+    execSync6(`npm install ${packageSpec}`, { stdio: json2 ? "pipe" : "inherit" });
   } catch (err) {
     if (json2) {
       console.log(JSON.stringify({ success: false, error: getErrorMessage(err) }));
@@ -107464,7 +108499,7 @@ async function marketInstallCommand(packageSpec, options = {}) {
     return;
   }
   const packageName = resolvePackageName2(packageSpec);
-  const manifest = readManifest(path52.join(process.cwd(), "node_modules", packageName));
+  const manifest = readManifest(path53.join(process.cwd(), "node_modules", packageName));
   if (json2) {
     console.log(JSON.stringify({
       success: true,
@@ -107555,7 +108590,7 @@ async function marketListCommand(options = {}) {
 }
 function resolvePackageName2(spec) {
   if (spec.endsWith(".tgz") || spec.endsWith(".tar.gz")) {
-    const base = path52.basename(spec, spec.endsWith(".tar.gz") ? ".tar.gz" : ".tgz");
+    const base = path53.basename(spec, spec.endsWith(".tar.gz") ? ".tar.gz" : ".tgz");
     const match2 = base.match(/^(.+)-\d+\.\d+\.\d+/);
     return match2 ? match2[1] : base;
   }
@@ -107603,334 +108638,9 @@ function displayInstalledPackage(pkg) {
   logger.newline();
 }
 
-// src/cli/commands/mcp-setup.ts
-import { execSync as execSync6 } from "child_process";
-import * as fs52 from "fs";
-import * as path53 from "path";
-import * as os3 from "os";
-var MCP_COMMAND = "npx";
-var MCP_ARGS = ["@synergenius/flow-weaver@latest", "mcp-server", "--stdio"];
-var MCP_ENTRY = { command: MCP_COMMAND, args: [...MCP_ARGS] };
-function defaultDeps() {
-  return {
-    execCommand: async (cmd) => {
-      try {
-        const stdout = execSync6(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-        return { stdout: stdout.trim(), exitCode: 0 };
-      } catch {
-        return { stdout: "", exitCode: 1 };
-      }
-    },
-    fileExists: async (filePath) => {
-      try {
-        await fs52.promises.access(filePath);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    readFile: async (filePath) => {
-      try {
-        return await fs52.promises.readFile(filePath, "utf8");
-      } catch {
-        return null;
-      }
-    },
-    writeFile: async (filePath, content) => {
-      await fs52.promises.writeFile(filePath, content, "utf8");
-    },
-    mkdir: async (dirPath) => {
-      await fs52.promises.mkdir(dirPath, { recursive: true });
-    },
-    cwd: () => process.cwd(),
-    homedir: () => os3.homedir(),
-    log: (msg) => process.stdout.write(msg + "\n")
-  };
-}
-function whichCmd(binary2) {
-  return process.platform === "win32" ? `where ${binary2}` : `which ${binary2}`;
-}
-async function binaryExists(binary2, deps) {
-  const result = await deps.execCommand(whichCmd(binary2));
-  return result.exitCode === 0;
-}
-async function mergeJsonConfig(deps, filePath, rootKey) {
-  const existing = await deps.readFile(filePath);
-  if (existing === null) {
-    const dir = path53.dirname(filePath);
-    await deps.mkdir(dir);
-    const config3 = { [rootKey]: { "flow-weaver": MCP_ENTRY } };
-    await deps.writeFile(filePath, JSON.stringify(config3, null, 2) + "\n");
-    return { action: "created", detail: `created ${filePath}` };
-  }
-  let config2;
-  try {
-    config2 = JSON.parse(existing);
-  } catch {
-    throw new Error(`invalid JSON in ${filePath}`);
-  }
-  if (!config2[rootKey] || typeof config2[rootKey] !== "object") {
-    config2[rootKey] = {};
-  }
-  const servers = config2[rootKey];
-  if (servers["flow-weaver"]) {
-    return { action: "already-configured", detail: `already in ${filePath}` };
-  }
-  servers["flow-weaver"] = MCP_ENTRY;
-  await deps.writeFile(filePath, JSON.stringify(config2, null, 2) + "\n");
-  return { action: "added", detail: `added to ${filePath}` };
-}
-var TOOL_REGISTRY = [
-  // Claude Code
-  {
-    id: "claude",
-    displayName: "Claude Code",
-    detect: (deps) => binaryExists("claude", deps),
-    isConfigured: async (deps) => {
-      const result = await deps.execCommand("claude mcp list");
-      return result.exitCode === 0 && result.stdout.includes("flow-weaver");
-    },
-    configure: async (deps) => {
-      const cmd = `claude mcp add --scope project flow-weaver -- ${MCP_COMMAND} ${MCP_ARGS.join(" ")}`;
-      const result = await deps.execCommand(cmd);
-      if (result.exitCode !== 0) {
-        throw new Error("claude mcp add failed");
-      }
-      return "registered via claude mcp add";
-    }
-  },
-  // Cursor
-  {
-    id: "cursor",
-    displayName: "Cursor",
-    detect: async (deps) => {
-      const dirExists = await deps.fileExists(path53.join(deps.cwd(), ".cursor"));
-      if (dirExists) return true;
-      return binaryExists("cursor", deps);
-    },
-    isConfigured: async (deps) => {
-      const filePath = path53.join(deps.cwd(), ".cursor", "mcp.json");
-      const content = await deps.readFile(filePath);
-      if (!content) return false;
-      try {
-        const config2 = JSON.parse(content);
-        return !!config2?.mcpServers?.["flow-weaver"];
-      } catch {
-        return false;
-      }
-    },
-    configure: async (deps) => {
-      const filePath = path53.join(deps.cwd(), ".cursor", "mcp.json");
-      const result = await mergeJsonConfig(deps, filePath, "mcpServers");
-      return result.detail;
-    }
-  },
-  // VS Code Copilot
-  {
-    id: "vscode",
-    displayName: "VS Code Copilot",
-    detect: (deps) => binaryExists("code", deps),
-    isConfigured: async (deps) => {
-      const filePath = path53.join(deps.cwd(), ".vscode", "mcp.json");
-      const content = await deps.readFile(filePath);
-      if (!content) return false;
-      try {
-        const config2 = JSON.parse(content);
-        return !!config2?.servers?.["flow-weaver"];
-      } catch {
-        return false;
-      }
-    },
-    configure: async (deps) => {
-      const filePath = path53.join(deps.cwd(), ".vscode", "mcp.json");
-      const result = await mergeJsonConfig(deps, filePath, "servers");
-      return result.detail;
-    }
-  },
-  // Windsurf
-  {
-    id: "windsurf",
-    displayName: "Windsurf",
-    detect: async (deps) => {
-      const configDir = path53.join(deps.homedir(), ".codeium", "windsurf");
-      const dirExists = await deps.fileExists(configDir);
-      if (dirExists) return true;
-      return binaryExists("windsurf", deps);
-    },
-    isConfigured: async (deps) => {
-      const filePath = path53.join(deps.homedir(), ".codeium", "windsurf", "mcp_config.json");
-      const content = await deps.readFile(filePath);
-      if (!content) return false;
-      try {
-        const config2 = JSON.parse(content);
-        return !!config2?.mcpServers?.["flow-weaver"];
-      } catch {
-        return false;
-      }
-    },
-    configure: async (deps) => {
-      const filePath = path53.join(deps.homedir(), ".codeium", "windsurf", "mcp_config.json");
-      const result = await mergeJsonConfig(deps, filePath, "mcpServers");
-      return result.detail;
-    }
-  },
-  // Codex (OpenAI)
-  {
-    id: "codex",
-    displayName: "Codex",
-    detect: (deps) => binaryExists("codex", deps),
-    isConfigured: async (deps) => {
-      const result = await deps.execCommand("codex mcp list");
-      return result.exitCode === 0 && result.stdout.includes("flow-weaver");
-    },
-    configure: async (deps) => {
-      const cmd = `codex mcp add flow-weaver -- ${MCP_COMMAND} ${MCP_ARGS.join(" ")}`;
-      const result = await deps.execCommand(cmd);
-      if (result.exitCode !== 0) {
-        throw new Error("codex mcp add failed");
-      }
-      return "registered via codex mcp add";
-    }
-  },
-  // OpenClaw
-  {
-    id: "openclaw",
-    displayName: "OpenClaw",
-    detect: async (deps) => {
-      return deps.fileExists(path53.join(deps.cwd(), "openclaw.json"));
-    },
-    isConfigured: async (deps) => {
-      const filePath = path53.join(deps.cwd(), "openclaw.json");
-      const content = await deps.readFile(filePath);
-      if (!content) return false;
-      try {
-        const config2 = JSON.parse(content);
-        return !!config2?.mcpServers?.["flow-weaver"];
-      } catch {
-        return false;
-      }
-    },
-    configure: async (deps) => {
-      const filePath = path53.join(deps.cwd(), "openclaw.json");
-      const result = await mergeJsonConfig(deps, filePath, "mcpServers");
-      return result.detail;
-    }
-  }
-];
-async function detectTools(deps) {
-  const results = await Promise.all(
-    TOOL_REGISTRY.map(async (tool) => {
-      const detected = await tool.detect(deps);
-      const configured = detected ? await tool.isConfigured(deps) : false;
-      return { id: tool.id, displayName: tool.displayName, detected, configured };
-    })
-  );
-  return results;
-}
-async function configureTool(tool, deps) {
-  try {
-    const already = await tool.isConfigured(deps);
-    if (already) {
-      return { id: tool.id, displayName: tool.displayName, action: "already-configured", detail: "already configured" };
-    }
-    const detail = await tool.configure(deps);
-    return { id: tool.id, displayName: tool.displayName, action: "configured", detail };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { id: tool.id, displayName: tool.displayName, action: "failed", detail: msg };
-  }
-}
-async function mcpSetupCommand(options, deps) {
-  const d = deps ?? defaultDeps();
-  const detected = await detectTools(d);
-  if (options.list) {
-    d.log("");
-    for (const t of detected) {
-      const status = t.detected ? t.configured ? "detected, configured" : "detected" : "not found";
-      const icon = t.detected ? t.configured ? "\u25CF" : "\u25CB" : "\xB7";
-      d.log(`  ${icon} ${t.displayName.padEnd(18)} ${status}`);
-    }
-    d.log("");
-    return;
-  }
-  let toolIds;
-  if (options.tool && options.tool.length > 0) {
-    const valid = new Set(TOOL_REGISTRY.map((t) => t.id));
-    for (const name of options.tool) {
-      if (!valid.has(name)) {
-        d.log(`Unknown tool: "${name}". Valid tools: ${[...valid].join(", ")}`);
-        return;
-      }
-    }
-    toolIds = options.tool;
-  } else if (options.all) {
-    toolIds = detected.filter((t) => t.detected).map((t) => t.id);
-  } else if (isNonInteractive()) {
-    toolIds = detected.filter((t) => t.detected).map((t) => t.id);
-  } else {
-    const detectedTools = detected.filter((t) => t.detected);
-    if (detectedTools.length === 0) {
-      d.log("No AI coding tools detected. You can specify tools manually with --tool.");
-      return;
-    }
-    d.log("");
-    d.log("Detected tools:");
-    for (const t of detected) {
-      const icon = t.detected ? "\u2713" : "\u2717";
-      d.log(`  ${icon} ${t.displayName}`);
-    }
-    d.log("");
-    toolIds = [];
-    try {
-      for (const t of detectedTools) {
-        if (t.configured) {
-          d.log(`  ${t.displayName}: already configured, skipping`);
-          continue;
-        }
-        const yes = await dist_default6({
-          message: `Configure ${t.displayName}?`,
-          default: true
-        });
-        if (yes) toolIds.push(t.id);
-      }
-    } catch (err) {
-      if (err instanceof ExitPromptError4) return;
-      throw err;
-    }
-    d.log("");
-  }
-  if (toolIds.length === 0) {
-    const anyDetected = detected.some((t) => t.detected);
-    if (!anyDetected) {
-      d.log("No AI coding tools detected. You can specify tools manually with --tool.");
-    } else {
-      d.log("No tools selected.");
-    }
-    return;
-  }
-  const toolMap = new Map(TOOL_REGISTRY.map((t) => [t.id, t]));
-  const results = [];
-  for (const id of toolIds) {
-    const tool = toolMap.get(id);
-    const result = await configureTool(tool, d);
-    results.push(result);
-    const icon = result.action === "configured" ? "\u2713" : result.action === "already-configured" ? "\u25CF" : "\u2717";
-    d.log(`${icon} ${result.displayName}: ${result.detail}`);
-  }
-  const configured = results.filter((r) => r.action === "configured").length;
-  const alreadyDone = results.filter((r) => r.action === "already-configured").length;
-  const failed = results.filter((r) => r.action === "failed").length;
-  const parts2 = [];
-  if (configured > 0) parts2.push(`${configured} configured`);
-  if (alreadyDone > 0) parts2.push(`${alreadyDone} already configured`);
-  if (failed > 0) parts2.push(`${failed} failed`);
-  d.log("");
-  d.log(`Done. ${parts2.join(", ")}.`);
-}
-
 // src/cli/index.ts
 init_error_utils();
-var version2 = true ? "0.16.0" : "0.0.0-dev";
+var version2 = true ? "0.17.0" : "0.0.0-dev";
 var program2 = new Command();
 program2.name("flow-weaver").description("Flow Weaver Annotations - Compile and validate workflow files").option("-v, --version", "Output the current version").option("--no-color", "Disable colors").option("--color", "Force colors").on("option:version", () => {
   logger.banner(version2);
@@ -107990,7 +108700,7 @@ program2.command("validate <input>").description("Validate workflow files withou
 program2.command("doctor").description("Check project environment and configuration for flow-weaver compatibility").option("--json", "Output results as JSON", false).action(wrapAction(async (options) => {
   await doctorCommand(options);
 }));
-program2.command("init [directory]").description("Create a new flow-weaver project").option("-n, --name <name>", "Project name (defaults to directory name)").option("-t, --template <template>", "Workflow template (default: sequential)").option("-f, --format <format>", "Module format: esm or cjs (default: esm)").option("-y, --yes", "Skip prompts and use defaults", false).option("--install", "Run npm install after scaffolding").option("--no-install", "Skip npm install").option("--git", "Initialize a git repository").option("--no-git", "Skip git init").option("--force", "Overwrite existing files", false).option("--json", "Output results as JSON", false).action(wrapAction(async (directory, options) => {
+program2.command("init [directory]").description("Create a new flow-weaver project").option("-n, --name <name>", "Project name (defaults to directory name)").option("-t, --template <template>", "Workflow template (default: sequential)").option("-f, --format <format>", "Module format: esm or cjs (default: esm)").option("-y, --yes", "Skip prompts and use defaults", false).option("--preset <persona>", "User preset: nocode, vibecoder, lowcode, expert").option("--use-case <category>", "Use case: data, ai, api, automation, cicd, minimal").option("--mcp", "Auto-configure MCP for AI editors after scaffolding").option("--no-mcp", "Skip MCP setup prompt").option("--no-agent", "Skip post-init agent launch prompt").option("--install", "Run npm install after scaffolding").option("--no-install", "Skip npm install").option("--git", "Initialize a git repository").option("--no-git", "Skip git init").option("--force", "Overwrite existing files", false).option("--json", "Output results as JSON", false).action(wrapAction(async (directory, options) => {
   await initCommand(directory, options);
 }));
 program2.command("watch <input>").description("Watch workflow files and recompile on changes").option("-o, --output <path>", "Output file or directory").option("-p, --production", "Generate production code (no debug events)", false).option("-s, --source-map", "Generate source maps", false).option("--verbose", "Verbose output", false).option("-w, --workflow <name>", "Specific workflow name to compile").option("-f, --format <format>", "Module format: esm, cjs, or auto", "auto").action(wrapAction(async (input, options) => {