@synergenius/flow-weaver 0.23.4 → 0.24.0

package/dist/cli/flow-weaver.mjs

@@ -935,8 +935,8 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter2 = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path54 = __require("path");
-    var fs50 = __require("fs");
+    var path55 = __require("path");
+    var fs48 = __require("fs");
     var process6 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1759,10 +1759,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path54.resolve(baseDir, baseName);
-          if (fs50.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path54.extname(baseName))) return void 0;
-          const foundExt = sourceExt.find((ext2) => fs50.existsSync(`${localBin}${ext2}`));
+          const localBin = path55.resolve(baseDir, baseName);
+          if (fs48.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path55.extname(baseName))) return void 0;
+          const foundExt = sourceExt.find((ext2) => fs48.existsSync(`${localBin}${ext2}`));
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
         }
@@ -1773,23 +1773,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs50.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs48.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path54.resolve(path54.dirname(resolvedScriptPath), executableDir);
+          executableDir = path55.resolve(path55.dirname(resolvedScriptPath), executableDir);
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path54.basename(this._scriptPath, path54.extname(this._scriptPath));
+            const legacyName = path55.basename(this._scriptPath, path55.extname(this._scriptPath));
             if (legacyName !== this._name) {
               localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
             }
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path54.extname(executableFile));
+        launchWithNode = sourceExt.includes(path55.extname(executableFile));
         let proc2;
         if (process6.platform !== "win32") {
           if (launchWithNode) {
@@ -2572,7 +2572,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path54.basename(filename, path54.extname(filename));
+        this._name = path55.basename(filename, path55.extname(filename));
         return this;
       }
       /**
@@ -2586,9 +2586,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {string|null|Command}
        */
-      executableDir(path55) {
-        if (path55 === void 0) return this._executableDir;
-        this._executableDir = path55;
+      executableDir(path56) {
+        if (path56 === void 0) return this._executableDir;
+        this._executableDir = path56;
         return this;
       }
       /**
@@ -7303,12 +7303,12 @@ var init_esm4 = __esm({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path54) {
-        if (!path54) {
+      resolve(path55) {
+        if (!path55) {
           return this;
         }
-        const rootPath = this.getRootString(path54);
-        const dir = path54.substring(rootPath.length);
+        const rootPath = this.getRootString(path55);
+        const dir = path55.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -8060,8 +8060,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path54) {
-        return win32.parse(path54).root;
+      getRootString(path55) {
+        return win32.parse(path55).root;
       }
       /**
        * @internal
@@ -8107,8 +8107,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path54) {
-        return path54.startsWith("/") ? "/" : "";
+      getRootString(path55) {
+        return path55.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -8157,8 +8157,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs: fs50 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs50);
+      constructor(cwd = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs48 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs48);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = fileURLToPath(cwd);
         }
@@ -8168,7 +8168,7 @@ var init_esm4 = __esm({
         this.#resolveCache = new ResolveCache();
         this.#resolvePosixCache = new ResolveCache();
         this.#children = new ChildrenCache(childrenCacheSize);
-        const split = cwdPath.substring(this.rootPath.length).split(sep3);
+        const split = cwdPath.substring(this.rootPath.length).split(sep4);
         if (split.length === 1 && !split[0]) {
           split.pop();
         }
@@ -8197,11 +8197,11 @@ var init_esm4 = __esm({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path54 = this.cwd) {
-        if (typeof path54 === "string") {
-          path54 = this.cwd.resolve(path54);
+      depth(path55 = this.cwd) {
+        if (typeof path55 === "string") {
+          path55 = this.cwd.resolve(path55);
         }
-        return path54.depth();
+        return path55.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -8688,9 +8688,9 @@ var init_esm4 = __esm({
         process6();
         return results;
       }
-      chdir(path54 = this.cwd) {
+      chdir(path55 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path54 === "string" ? this.cwd.resolve(path54) : path54;
+        this.cwd = typeof path55 === "string" ? this.cwd.resolve(path55) : path55;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -8716,8 +8716,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs50) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs50 });
+      newRoot(fs48) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs48 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -8745,8 +8745,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs50) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs50 });
+      newRoot(fs48) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs48 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -9065,8 +9065,8 @@ var init_processor = __esm({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path54, n]) => [
-          path54,
+        return [...this.store.entries()].map(([path55, n]) => [
+          path55,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -9279,9 +9279,9 @@ var init_walker = __esm({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path54, opts) {
+      constructor(patterns, path55, opts) {
         this.patterns = patterns;
-        this.path = path54;
+        this.path = path55;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -9300,11 +9300,11 @@ var init_walker = __esm({
           });
         }
       }
-      #ignored(path54) {
-        return this.seen.has(path54) || !!this.#ignore?.ignored?.(path54);
+      #ignored(path55) {
+        return this.seen.has(path55) || !!this.#ignore?.ignored?.(path55);
       }
-      #childrenIgnored(path54) {
-        return !!this.#ignore?.childrenIgnored?.(path54);
+      #childrenIgnored(path55) {
+        return !!this.#ignore?.childrenIgnored?.(path55);
       }
       // backpressure mechanism
       pause() {
@@ -9519,8 +9519,8 @@ var init_walker = __esm({
     };
     GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path54, opts) {
-        super(patterns, path54, opts);
+      constructor(patterns, path55, opts) {
+        super(patterns, path55, opts);
       }
       matchEmit(e) {
         this.matches.add(e);
@@ -9557,8 +9557,8 @@ var init_walker = __esm({
     };
     GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path54, opts) {
-        super(patterns, path54, opts);
+      constructor(patterns, path55, opts) {
+        super(patterns, path55, opts);
         this.results = new Minipass({
           signal: this.signal,
           objectMode: true
@@ -9886,7 +9886,7 @@ var VERSION;
 var init_generated_version = __esm({
   "src/generated-version.ts"() {
     "use strict";
-    VERSION = "0.23.4";
+    VERSION = "0.24.0";
   }
 });
 
@@ -11472,7 +11472,7 @@ function generateControlFlowWithExecutionContext(workflow, nodeTypes, isAsync2,
         "ctx",
         bundleMode,
         promotedPreDeclared,
-        branchingNodesNeedingSuccessFlag.has(instanceId),
+        branchingNodesNeedingSuccessFlag.has(instanceId) || topLevelSuccessFlags.has(toValidIdentifier(instanceId)),
         production
       );
       if (branchNeedsClose) {
@@ -11888,8 +11888,8 @@ function generateBranchingChainCode(chain, workflow, nodeTypes, branchingNodes,
   const preDeclaredFlags = new Set(alreadyDeclaredFlags);
   for (let i = 0; i < chain.length; i++) {
     const isLast = i === chain.length - 1;
-    if (!isLast || forceTrackSuccessNodes.has(chain[i])) {
-      const safeId = toValidIdentifier(chain[i]);
+    const safeId = toValidIdentifier(chain[i]);
+    if (!isLast || forceTrackSuccessNodes.has(chain[i]) || alreadyDeclaredFlags.has(safeId)) {
       if (!alreadyDeclaredFlags.has(safeId)) {
         lines.push(`${indent}let ${safeId}_success = false;`);
       }
@@ -11942,8 +11942,8 @@ function generateBranchingChainCode(chain, workflow, nodeTypes, branchingNodes,
       ctxVar,
       bundleMode,
       preDeclaredFlags,
-      !isLast || forceTrackSuccessNodes.has(chain[i]),
-      // forceTrackSuccess for non-last chain nodes or nodes with promoted dependents
+      !isLast || forceTrackSuccessNodes.has(chain[i]) || alreadyDeclaredFlags.has(safeId),
+      // forceTrackSuccess for non-last chain nodes, nodes with promoted dependents, or nodes with pre-declared flags
       production
     );
     generateScopedChildrenExecution(
@@ -12269,7 +12269,8 @@ function generateBranchingNodeCode(instance, branchNode, workflow, allNodeTypes,
           ctxVar,
           bundleMode,
           nestedPreDeclared,
-          false,
+          nestedPreDeclared.has(nestedSafeId),
+          // force tracking if flag was pre-declared at higher scope
           production
         );
         successExecutedNodes.push(instanceId2);
@@ -12353,7 +12354,8 @@ function generateBranchingNodeCode(instance, branchNode, workflow, allNodeTypes,
             ctxVar,
             bundleMode,
             nestedPreDeclared,
-            false,
+            nestedPreDeclared.has(nestedSafeId),
+            // force tracking if flag was pre-declared at higher scope
             production
           );
           failureExecutedNodes.push(instanceId2);
@@ -13110,7 +13112,7 @@ var require_util = __commonJS({
     var normalize2 = createSafeHandler((url) => {
     });
     exports2.normalize = normalize2;
-    function join29(aRoot, aPath) {
+    function join28(aRoot, aPath) {
       const pathType = getURLType(aPath);
       const rootType = getURLType(aRoot);
       aRoot = ensureDirectory(aRoot);
@@ -13140,7 +13142,7 @@ var require_util = __commonJS({
       const newPath = withBase(aPath, withBase(aRoot, base));
       return computeRelativeURL(base, newPath);
     }
-    exports2.join = join29;
+    exports2.join = join28;
     function relative10(rootURL, targetURL) {
       const result = relativeIfPossible(rootURL, targetURL);
       return typeof result === "string" ? result : normalize2(targetURL);
@@ -13169,8 +13171,8 @@ var require_util = __commonJS({
         sourceURL = sourceURL.replace(/^\//, "");
       }
       let url = normalize2(sourceURL || "");
-      if (sourceRoot) url = join29(sourceRoot, url);
-      if (sourceMapURL) url = join29(trimFilename(sourceMapURL), url);
+      if (sourceRoot) url = join28(sourceRoot, url);
+      if (sourceMapURL) url = join28(trimFilename(sourceMapURL), url);
       return url;
     }
     exports2.computeSourceURL = computeSourceURL;
@@ -13721,12 +13723,12 @@ var require_binary_search = __commonJS({
 var require_read_wasm = __commonJS({
   "node_modules/source-map/lib/read-wasm.js"(exports2, module2) {
     "use strict";
-    var fs50 = __require("fs");
-    var path54 = __require("path");
+    var fs48 = __require("fs");
+    var path55 = __require("path");
     module2.exports = function readWasm() {
       return new Promise((resolve38, reject2) => {
-        const wasmPath = path54.join(__dirname, "mappings.wasm");
-        fs50.readFile(wasmPath, null, (error2, data) => {
+        const wasmPath = path55.join(__dirname, "mappings.wasm");
+        fs48.readFile(wasmPath, null, (error2, data) => {
           if (error2) {
             reject2(error2);
             return;
@@ -16598,9 +16600,9 @@ ${file}:${line}:${column}: ERROR: ${pluginText}${e.text}`;
       if (regexp.flags) result = `(?${regexp.flags})${result}`;
       return result;
     }
-    var fs50 = __require("fs");
+    var fs48 = __require("fs");
     var os5 = __require("os");
-    var path54 = __require("path");
+    var path55 = __require("path");
     var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
     var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
     var packageDarwin_arm64 = "@esbuild/darwin-arm64";
@@ -16659,19 +16661,19 @@ ${file}:${line}:${column}: ERROR: ${pluginText}${e.text}`;
     }
     function pkgForSomeOtherPlatform() {
       const libMainJS = __require.resolve("esbuild");
-      const nodeModulesDirectory = path54.dirname(path54.dirname(path54.dirname(libMainJS)));
-      if (path54.basename(nodeModulesDirectory) === "node_modules") {
+      const nodeModulesDirectory = path55.dirname(path55.dirname(path55.dirname(libMainJS)));
+      if (path55.basename(nodeModulesDirectory) === "node_modules") {
         for (const unixKey in knownUnixlikePackages) {
           try {
             const pkg = knownUnixlikePackages[unixKey];
-            if (fs50.existsSync(path54.join(nodeModulesDirectory, pkg))) return pkg;
+            if (fs48.existsSync(path55.join(nodeModulesDirectory, pkg))) return pkg;
           } catch {
           }
         }
         for (const windowsKey in knownWindowsPackages) {
           try {
             const pkg = knownWindowsPackages[windowsKey];
-            if (fs50.existsSync(path54.join(nodeModulesDirectory, pkg))) return pkg;
+            if (fs48.existsSync(path55.join(nodeModulesDirectory, pkg))) return pkg;
           } catch {
           }
         }
@@ -16679,12 +16681,12 @@ ${file}:${line}:${column}: ERROR: ${pluginText}${e.text}`;
       return null;
     }
     function downloadedBinPath(pkg, subpath) {
-      const esbuildLibDir = path54.dirname(__require.resolve("esbuild"));
-      return path54.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path54.basename(subpath)}`);
+      const esbuildLibDir = path55.dirname(__require.resolve("esbuild"));
+      return path55.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path55.basename(subpath)}`);
     }
     function generateBinPath() {
       if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
-        if (!fs50.existsSync(ESBUILD_BINARY_PATH)) {
+        if (!fs48.existsSync(ESBUILD_BINARY_PATH)) {
           console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
         } else {
           return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
@@ -16696,7 +16698,7 @@ ${file}:${line}:${column}: ERROR: ${pluginText}${e.text}`;
         binPath = __require.resolve(`${pkg}/${subpath}`);
       } catch (e) {
         binPath = downloadedBinPath(pkg, subpath);
-        if (!fs50.existsSync(binPath)) {
+        if (!fs48.existsSync(binPath)) {
           try {
             __require.resolve(pkg);
           } catch {
@@ -16770,17 +16772,17 @@ for your current platform.`);
         }
         if (pnpapi) {
           const root2 = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
-          const binTargetPath = path54.join(
+          const binTargetPath = path55.join(
             root2,
             "node_modules",
             ".cache",
             "esbuild",
-            `pnpapi-${pkg.replace("/", "-")}-${"0.27.3"}-${path54.basename(subpath)}`
+            `pnpapi-${pkg.replace("/", "-")}-${"0.27.3"}-${path55.basename(subpath)}`
           );
-          if (!fs50.existsSync(binTargetPath)) {
-            fs50.mkdirSync(path54.dirname(binTargetPath), { recursive: true });
-            fs50.copyFileSync(binPath, binTargetPath);
-            fs50.chmodSync(binTargetPath, 493);
+          if (!fs48.existsSync(binTargetPath)) {
+            fs48.mkdirSync(path55.dirname(binTargetPath), { recursive: true });
+            fs48.copyFileSync(binPath, binTargetPath);
+            fs48.chmodSync(binTargetPath, 493);
           }
           return { binPath: binTargetPath, isWASM };
         }
@@ -17830,7 +17832,7 @@ function generateCode(ast, options) {
     sourceMap = false,
     allWorkflows = [],
     moduleFormat = "esm",
-    externalRuntimePath,
+    bundleMode = false,
     constants = [],
     externalNodeTypes = {},
     generateStubs = false,
@@ -17872,7 +17874,6 @@ function generateCode(ast, options) {
       });
     }
   };
-  const bundleMode = !!externalRuntimePath;
   const functionBody = bodyGenerator.generateWithExecutionContext(
     ast,
     ast.nodeTypes,
@@ -17885,26 +17886,7 @@ function generateCode(ast, options) {
   addLine();
   lines.push("");
   addLine();
-  if (externalRuntimePath) {
-    lines.push(`// Runtime imported from shared module`);
-    addLine();
-    lines.push(
-      generateImportStatement(
-        ["GeneratedExecutionContext", "CancellationError"],
-        externalRuntimePath,
-        moduleFormat
-      )
-    );
-    addLine();
-    if (!production) {
-      lines.push(
-        moduleFormat === "cjs" ? `const { TDebugger } = require('${externalRuntimePath}');` : `import type { TDebugger } from '${externalRuntimePath}';`
-      );
-      addLine();
-    }
-    lines.push("");
-    addLine();
-  } else {
+  {
     const inlineRuntime = generateInlineRuntime(production);
     const runtimeLines = inlineRuntime.split("\n");
     runtimeLines.forEach((line) => {
@@ -17966,7 +17948,7 @@ function generateCode(ast, options) {
     lines.push("");
     addLine();
     functionImportsByFile.forEach((nodes, sourceFile) => {
-      if (externalRuntimePath) {
+      if (bundleMode) {
         nodes.forEach((node) => {
           const lowerName = node.functionName.toLowerCase();
           const relativePath = `../node-types/${lowerName}.js`;
@@ -17984,7 +17966,7 @@ function generateCode(ast, options) {
       }
     });
     workflowImportsByFile.forEach((names, sourceFile) => {
-      if (externalRuntimePath) {
+      if (bundleMode) {
         names.forEach((name) => {
           const relativePath = `./${name}.js`;
           lines.push(generateImportStatement([name], relativePath, moduleFormat));
@@ -18280,9 +18262,9 @@ var init_port_tag_utils = __esm({
 });
 
 // src/sugar-optimizer.ts
-function validatePathMacro(path54, connections, instances, nodeTypes, startPorts, exitPorts) {
+function validatePathMacro(path55, connections, instances, nodeTypes, startPorts, exitPorts) {
   const instanceIds = new Set(instances.map((inst) => inst.id));
-  for (const step of path54.steps) {
+  for (const step of path55.steps) {
     if (step.node === "Start" || step.node === "Exit") continue;
     if (!instanceIds.has(step.node)) return false;
   }
@@ -18292,9 +18274,9 @@ function validatePathMacro(path54, connections, instances, nodeTypes, startPorts
       connKeys.add(`${conn.from.node}.${conn.from.port}->${conn.to.node}.${conn.to.port}`);
     }
   }
-  for (let i = 0; i < path54.steps.length - 1; i++) {
-    const current2 = path54.steps[i];
-    const next = path54.steps[i + 1];
+  for (let i = 0; i < path55.steps.length - 1; i++) {
+    const current2 = path55.steps[i];
+    const next = path55.steps[i + 1];
     const route = current2.route || "ok";
     let expectedKey;
     if (current2.node === "Start") {
@@ -18340,7 +18322,7 @@ function validatePathMacro(path54, connections, instances, nodeTypes, startPorts
       const nt = getNodeType2(nodeId);
       return nt?.inputs || {};
     };
-    const { steps } = path54;
+    const { steps } = path55;
     for (let i = 0; i < steps.length - 1; i++) {
       const nextId = steps[i + 1].node;
       if (nextId === "Exit") continue;
@@ -18462,12 +18444,12 @@ function detectSugarPatterns(connections, instances, existingMacros, nodeTypes,
   }
   const candidateRoutes = [];
   const MAX_ROUTES = 20;
-  function dfs(node, path54, visited) {
+  function dfs(node, path55, visited) {
     if (candidateRoutes.length >= MAX_ROUTES) return;
     if (node === "Exit") {
-      path54.push({ node: "Exit" });
-      candidateRoutes.push([...path54]);
-      path54.pop();
+      path55.push({ node: "Exit" });
+      candidateRoutes.push([...path55]);
+      path55.pop();
       return;
     }
     if (visited.has(node)) return;
@@ -18479,15 +18461,15 @@ function detectSugarPatterns(connections, instances, existingMacros, nodeTypes,
     }
     if (edges.ok && !coveredByExistingMacro.has(edges.ok === "Exit" ? "" : edges.ok)) {
       const step = node === "Start" ? { node: "Start" } : { node };
-      path54.push(step);
-      dfs(edges.ok, path54, visited);
-      path54.pop();
+      path55.push(step);
+      dfs(edges.ok, path55, visited);
+      path55.pop();
     }
     if (edges.fail && !coveredByExistingMacro.has(edges.fail === "Exit" ? "" : edges.fail)) {
       const step = { node, route: "fail" };
-      path54.push(step);
-      dfs(edges.fail, path54, visited);
-      path54.pop();
+      path55.push(step);
+      dfs(edges.fail, path55, visited);
+      path55.pop();
     }
     visited.delete(node);
   }
@@ -19164,26 +19146,8 @@ var init_annotation_generator = __esm({
 // src/api/generate-in-place.ts
 import * as ts2 from "typescript";
 import * as path3 from "path";
-import * as fs3 from "fs";
-function isFlowWeaverPackageInstalled(startDir) {
-  let dir = startDir;
-  const root2 = path3.parse(dir).root;
-  while (dir !== root2) {
-    const candidate = path3.join(dir, "node_modules", "@synergenius", "flow-weaver");
-    try {
-      if (fs3.existsSync(candidate)) {
-        return true;
-      }
-    } catch {
-    }
-    const parent = path3.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return false;
-}
 function generateInPlace(sourceCode, ast, options = {}) {
-  const { production = false, allWorkflows, moduleFormat = "esm", inlineRuntime = false, sourceFile, skipParamReturns = false } = options;
+  const { production = false, allWorkflows, moduleFormat = "esm", sourceFile, skipParamReturns = false } = options;
   let result = sourceCode;
   let hasChanges = false;
   for (const nodeType of ast.nodeTypes) {
@@ -19209,13 +19173,7 @@ function generateInPlace(sourceCode, ast, options = {}) {
     result = jsdocResult.code;
     hasChanges = true;
   }
-  let useExternalRuntime = false;
-  if (!inlineRuntime) {
-    const lookupDir = sourceFile ? path3.dirname(sourceFile) : ast.sourceFile ? path3.dirname(ast.sourceFile) : process.cwd();
-    useExternalRuntime = isFlowWeaverPackageInstalled(lookupDir);
-  }
-  const externalRuntimePath = useExternalRuntime ? "@synergenius/flow-weaver/runtime" : void 0;
-  const runtimeCode = generateRuntimeSection(ast.functionName, production, moduleFormat, externalRuntimePath);
+  const runtimeCode = generateRuntimeSection(ast.functionName, production, moduleFormat);
   const runtimeResult = replaceOrInsertSection(
     result,
     MARKERS.RUNTIME_START,
@@ -19257,23 +19215,13 @@ function generateInPlace(sourceCode, ast, options = {}) {
   }
   return { code: result, hasChanges };
 }
-function generateRuntimeSection(functionName, production, moduleFormat = "esm", externalRuntimePath) {
+function generateRuntimeSection(functionName, production, moduleFormat = "esm") {
   const lines = [];
   lines.push("// ============================================================================");
   lines.push("// DO NOT EDIT - This section is auto-generated by Flow Weaver");
   lines.push("// ============================================================================");
   lines.push("");
-  if (externalRuntimePath) {
-    lines.push(`import { GeneratedExecutionContext, CancellationError } from '${externalRuntimePath}';`);
-    if (!production) {
-      lines.push(`import type { TDebugger, TDebugController } from '${externalRuntimePath}';`);
-      lines.push("declare const __flowWeaverDebugger__: TDebugger | undefined;");
-    } else {
-      lines.push(`import type { TDebugController } from '${externalRuntimePath}';`);
-    }
-  } else {
-    lines.push(generateInlineRuntime(production));
-  }
+  lines.push(generateInlineRuntime(production));
   return lines.join("\n");
 }
 function detectFunctionIsAsync(source, functionName) {
@@ -22106,11 +22054,11 @@ var init_toKey = __esm({
 });
 
 // node_modules/lodash-es/_baseGet.js
-function baseGet(object3, path54) {
-  path54 = castPath_default(path54, object3);
-  var index = 0, length = path54.length;
+function baseGet(object3, path55) {
+  path55 = castPath_default(path55, object3);
+  var index = 0, length = path55.length;
   while (object3 != null && index < length) {
-    object3 = object3[toKey_default(path54[index++])];
+    object3 = object3[toKey_default(path55[index++])];
   }
   return index && index == length ? object3 : void 0;
 }
@@ -22124,8 +22072,8 @@ var init_baseGet = __esm({
 });
 
 // node_modules/lodash-es/get.js
-function get(object3, path54, defaultValue) {
-  var result = object3 == null ? void 0 : baseGet_default(object3, path54);
+function get(object3, path55, defaultValue) {
+  var result = object3 == null ? void 0 : baseGet_default(object3, path55);
   return result === void 0 ? defaultValue : result;
 }
 var get_default;
@@ -23488,11 +23436,11 @@ var init_baseHasIn = __esm({
 });
 
 // node_modules/lodash-es/_hasPath.js
-function hasPath(object3, path54, hasFunc) {
-  path54 = castPath_default(path54, object3);
-  var index = -1, length = path54.length, result = false;
+function hasPath(object3, path55, hasFunc) {
+  path55 = castPath_default(path55, object3);
+  var index = -1, length = path55.length, result = false;
   while (++index < length) {
-    var key = toKey_default(path54[index]);
+    var key = toKey_default(path55[index]);
     if (!(result = object3 != null && hasFunc(object3, key))) {
       break;
     }
@@ -23518,8 +23466,8 @@ var init_hasPath = __esm({
 });
 
 // node_modules/lodash-es/hasIn.js
-function hasIn(object3, path54) {
-  return object3 != null && hasPath_default(object3, path54, baseHasIn_default);
+function hasIn(object3, path55) {
+  return object3 != null && hasPath_default(object3, path55, baseHasIn_default);
 }
 var hasIn_default;
 var init_hasIn = __esm({
@@ -23531,13 +23479,13 @@ var init_hasIn = __esm({
 });
 
 // node_modules/lodash-es/_baseMatchesProperty.js
-function baseMatchesProperty(path54, srcValue) {
-  if (isKey_default(path54) && isStrictComparable_default(srcValue)) {
-    return matchesStrictComparable_default(toKey_default(path54), srcValue);
+function baseMatchesProperty(path55, srcValue) {
+  if (isKey_default(path55) && isStrictComparable_default(srcValue)) {
+    return matchesStrictComparable_default(toKey_default(path55), srcValue);
   }
   return function(object3) {
-    var objValue = get_default(object3, path54);
-    return objValue === void 0 && objValue === srcValue ? hasIn_default(object3, path54) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
+    var objValue = get_default(object3, path55);
+    return objValue === void 0 && objValue === srcValue ? hasIn_default(object3, path55) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
   };
 }
 var COMPARE_PARTIAL_FLAG6, COMPARE_UNORDERED_FLAG4, baseMatchesProperty_default;
@@ -23570,9 +23518,9 @@ var init_baseProperty = __esm({
 });
 
 // node_modules/lodash-es/_basePropertyDeep.js
-function basePropertyDeep(path54) {
+function basePropertyDeep(path55) {
   return function(object3) {
-    return baseGet_default(object3, path54);
+    return baseGet_default(object3, path55);
   };
 }
 var basePropertyDeep_default;
@@ -23584,8 +23532,8 @@ var init_basePropertyDeep = __esm({
 });
 
 // node_modules/lodash-es/property.js
-function property(path54) {
-  return isKey_default(path54) ? baseProperty_default(toKey_default(path54)) : basePropertyDeep_default(path54);
+function property(path55) {
+  return isKey_default(path55) ? baseProperty_default(toKey_default(path55)) : basePropertyDeep_default(path55);
 }
 var property_default;
 var init_property = __esm({
@@ -24204,8 +24152,8 @@ var init_baseHas = __esm({
 });
 
 // node_modules/lodash-es/has.js
-function has(object3, path54) {
-  return object3 != null && hasPath_default(object3, path54, baseHas_default);
+function has(object3, path55) {
+  return object3 != null && hasPath_default(object3, path55, baseHas_default);
 }
 var has_default;
 var init_has = __esm({
@@ -24411,14 +24359,14 @@ var init_negate = __esm({
 });
 
 // node_modules/lodash-es/_baseSet.js
-function baseSet(object3, path54, value, customizer) {
+function baseSet(object3, path55, value, customizer) {
   if (!isObject_default(object3)) {
     return object3;
   }
-  path54 = castPath_default(path54, object3);
-  var index = -1, length = path54.length, lastIndex = length - 1, nested = object3;
+  path55 = castPath_default(path55, object3);
+  var index = -1, length = path55.length, lastIndex = length - 1, nested = object3;
   while (nested != null && ++index < length) {
-    var key = toKey_default(path54[index]), newValue = value;
+    var key = toKey_default(path55[index]), newValue = value;
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
       return object3;
     }
@@ -24426,7 +24374,7 @@ function baseSet(object3, path54, value, customizer) {
       var objValue = nested[key];
       newValue = customizer ? customizer(objValue, key, nested) : void 0;
       if (newValue === void 0) {
-        newValue = isObject_default(objValue) ? objValue : isIndex_default(path54[index + 1]) ? [] : {};
+        newValue = isObject_default(objValue) ? objValue : isIndex_default(path55[index + 1]) ? [] : {};
       }
     }
     assignValue_default(nested, key, newValue);
@@ -24450,9 +24398,9 @@ var init_baseSet = __esm({
 function basePickBy(object3, paths, predicate) {
   var index = -1, length = paths.length, result = {};
   while (++index < length) {
-    var path54 = paths[index], value = baseGet_default(object3, path54);
-    if (predicate(value, path54)) {
-      baseSet_default(result, castPath_default(path54, object3), value);
+    var path55 = paths[index], value = baseGet_default(object3, path55);
+    if (predicate(value, path55)) {
+      baseSet_default(result, castPath_default(path55, object3), value);
     }
   }
   return result;
@@ -24476,8 +24424,8 @@ function pickBy(object3, predicate) {
     return [prop];
   });
   predicate = baseIteratee_default(predicate);
-  return basePickBy_default(object3, props, function(value, path54) {
-    return predicate(value, path54[0]);
+  return basePickBy_default(object3, props, function(value, path55) {
+    return predicate(value, path55[0]);
   });
 }
 var pickBy_default;
@@ -27224,12 +27172,12 @@ function assignCategoriesMapProp(tokenTypes) {
     singleAssignCategoriesToksMap([], currTokType);
   });
 }
-function singleAssignCategoriesToksMap(path54, nextNode) {
-  forEach_default(path54, (pathNode) => {
+function singleAssignCategoriesToksMap(path55, nextNode) {
+  forEach_default(path55, (pathNode) => {
     nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;
   });
   forEach_default(nextNode.CATEGORIES, (nextCategory) => {
-    const newPath = path54.concat(nextNode);
+    const newPath = path55.concat(nextNode);
     if (!includes_default(newPath, nextCategory)) {
       singleAssignCategoriesToksMap(newPath, nextCategory);
     }
@@ -28399,10 +28347,10 @@ var init_interpreter = __esm({
     init_rest();
     init_api2();
     AbstractNextPossibleTokensWalker = class extends RestWalker {
-      constructor(topProd, path54) {
+      constructor(topProd, path55) {
         super();
         this.topProd = topProd;
-        this.path = path54;
+        this.path = path55;
         this.possibleTokTypes = [];
         this.nextProductionName = "";
         this.nextProductionOccurrence = 0;
@@ -28446,9 +28394,9 @@ var init_interpreter = __esm({
       }
     };
     NextAfterTokenWalker = class extends AbstractNextPossibleTokensWalker {
-      constructor(topProd, path54) {
-        super(topProd, path54);
-        this.path = path54;
+      constructor(topProd, path55) {
+        super(topProd, path55);
+        this.path = path55;
         this.nextTerminalName = "";
         this.nextTerminalOccurrence = 0;
         this.nextTerminalName = this.path.lastTok.name;
@@ -28689,10 +28637,10 @@ function initializeArrayOfArrays(size) {
   }
   return result;
 }
-function pathToHashKeys(path54) {
+function pathToHashKeys(path55) {
   let keys2 = [""];
-  for (let i = 0; i < path54.length; i++) {
-    const tokType = path54[i];
+  for (let i = 0; i < path55.length; i++) {
+    const tokType = path55[i];
     const longerKeys = [];
     for (let j = 0; j < keys2.length; j++) {
       const currShorterKey = keys2[j];
@@ -28995,7 +28943,7 @@ function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
   }
   return errors2;
 }
-function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path54 = []) {
+function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path55 = []) {
   const errors2 = [];
   const nextNonTerminals = getFirstNoneTerminal(currRule.definition);
   if (isEmpty_default(nextNonTerminals)) {
@@ -29007,15 +28955,15 @@ function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path54 = [])
       errors2.push({
         message: errMsgProvider.buildLeftRecursionError({
           topLevelRule: topRule,
-          leftRecursionPath: path54
+          leftRecursionPath: path55
         }),
         type: ParserDefinitionErrorType.LEFT_RECURSION,
         ruleName
       });
     }
-    const validNextSteps = difference_default(nextNonTerminals, path54.concat([topRule]));
+    const validNextSteps = difference_default(nextNonTerminals, path55.concat([topRule]));
     const errorsFromNextSteps = flatMap_default(validNextSteps, (currRefRule) => {
-      const newPath = clone_default(path54);
+      const newPath = clone_default(path55);
       newPath.push(currRefRule);
       return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
     });
@@ -34006,8 +33954,8 @@ function itemToEBNF(item) {
       const sepName = item.separator?.name || ",";
       return `${definitionToEBNF(item.definition || [])} { "${sepName === "Comma" ? "," : sepName}" ${definitionToEBNF(item.definition || [])} }`;
     case "RepetitionWithSeparator":
-      const sep3 = item.separator?.name || ",";
-      return `[ ${definitionToEBNF(item.definition || [])} { "${sep3 === "Comma" ? "," : sep3}" ${definitionToEBNF(item.definition || [])} } ]`;
+      const sep4 = item.separator?.name || ",";
+      return `[ ${definitionToEBNF(item.definition || [])} { "${sep4 === "Comma" ? "," : sep4}" ${definitionToEBNF(item.definition || [])} } ]`;
     default:
       return `/* ${item.type} */`;
   }
@@ -35277,7 +35225,7 @@ var init_port_ordering = __esm({
 
 // src/resolve-package-types.ts
 import * as path4 from "node:path";
-import * as fs4 from "node:fs";
+import * as fs3 from "node:fs";
 function resolvePackageTypesPath(packageSpecifier, fromDir, nodeModulesOverride) {
   const nodeModulesDirs = nodeModulesOverride ? [nodeModulesOverride] : findNodeModulesDirs(fromDir);
   for (const nmDir of nodeModulesDirs) {
@@ -35292,7 +35240,7 @@ function findNodeModulesDirs(fromDir) {
   const root2 = path4.parse(current2).root;
   while (current2 !== root2) {
     const candidate = path4.join(current2, "node_modules");
-    if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) {
+    if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
       dirs.push(candidate);
     }
     const parent = path4.dirname(current2);
@@ -35309,14 +35257,14 @@ function resolveExportsTypes(exports2, pkgDir) {
     const rootObj = root2;
     if (typeof rootObj.types === "string") {
       const typesPath = path4.resolve(pkgDir, rootObj.types);
-      if (fs4.existsSync(typesPath)) {
+      if (fs3.existsSync(typesPath)) {
         return typesPath;
       }
     }
   }
   if (typeof exportsObj.types === "string") {
     const typesPath = path4.resolve(pkgDir, exportsObj.types);
-    if (fs4.existsSync(typesPath)) {
+    if (fs3.existsSync(typesPath)) {
       return typesPath;
     }
   }
@@ -35325,13 +35273,13 @@ function resolveExportsTypes(exports2, pkgDir) {
 function resolveInNodeModules(packageSpecifier, nmDir) {
   const pkgDir = path4.join(nmDir, packageSpecifier);
   const pkgJsonPath = path4.join(pkgDir, "package.json");
-  if (fs4.existsSync(pkgJsonPath)) {
+  if (fs3.existsSync(pkgJsonPath)) {
     try {
-      const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
       const typesField = pkgJson.types || pkgJson.typings;
       if (typesField) {
         const typesPath = path4.resolve(pkgDir, typesField);
-        if (fs4.existsSync(typesPath)) {
+        if (fs3.existsSync(typesPath)) {
           return typesPath;
         }
       }
@@ -35346,11 +35294,11 @@ function resolveInNodeModules(packageSpecifier, nmDir) {
   }
   const atTypesName = packageSpecifier.startsWith("@") ? packageSpecifier.replace("@", "").replace("/", "__") : packageSpecifier;
   const atTypesPath = path4.join(nmDir, "@types", atTypesName, "index.d.ts");
-  if (fs4.existsSync(atTypesPath)) {
+  if (fs3.existsSync(atTypesPath)) {
     return atTypesPath;
   }
   const indexDtsPath = path4.join(pkgDir, "index.d.ts");
-  if (fs4.existsSync(indexDtsPath)) {
+  if (fs3.existsSync(indexDtsPath)) {
     return indexDtsPath;
   }
   return null;
@@ -35554,7 +35502,7 @@ __export(registry_exports, {
   listInstalledPackages: () => listInstalledPackages,
   searchPackages: () => searchPackages
 });
-import * as fs5 from "fs";
+import * as fs4 from "fs";
 import * as path5 from "path";
 async function searchPackages(options = {}) {
   const { query, limit = 20, registryUrl } = options;
@@ -35581,7 +35529,7 @@ async function searchPackages(options = {}) {
 }
 async function listInstalledPackages(projectDir) {
   const nodeModules = path5.join(projectDir, "node_modules");
-  if (!fs5.existsSync(nodeModules)) return [];
+  if (!fs4.existsSync(nodeModules)) return [];
   const patterns = [
     path5.join(nodeModules, "flow-weaver-pack-*", "flowweaver.manifest.json"),
     path5.join(nodeModules, "@*", "flow-weaver-pack-*", "flowweaver.manifest.json")
@@ -35593,12 +35541,12 @@ async function listInstalledPackages(projectDir) {
       try {
         const pkgDir = path5.dirname(manifestPath);
         const manifest = JSON.parse(
-          fs5.readFileSync(manifestPath, "utf-8")
+          fs4.readFileSync(manifestPath, "utf-8")
         );
         const pkgJsonPath = path5.join(pkgDir, "package.json");
         let version3 = manifest.version;
-        if (fs5.existsSync(pkgJsonPath)) {
-          const pkg = JSON.parse(fs5.readFileSync(pkgJsonPath, "utf-8"));
+        if (fs4.existsSync(pkgJsonPath)) {
+          const pkg = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
           version3 = pkg.version ?? manifest.version;
         }
         results.push({
@@ -35616,9 +35564,9 @@ async function listInstalledPackages(projectDir) {
 function getInstalledPackageManifest(projectDir, packageName) {
   const packageDir = path5.join(projectDir, "node_modules", packageName);
   const manifestPath = path5.join(packageDir, "flowweaver.manifest.json");
-  if (!fs5.existsSync(manifestPath)) return null;
+  if (!fs4.existsSync(manifestPath)) return null;
   try {
-    return JSON.parse(fs5.readFileSync(manifestPath, "utf-8"));
+    return JSON.parse(fs4.readFileSync(manifestPath, "utf-8"));
   } catch {
     return null;
   }
@@ -35757,7 +35705,7 @@ var init_validation_registry = __esm({
 
 // src/parser.ts
 import * as path6 from "node:path";
-import * as fs6 from "node:fs";
+import * as fs5 from "node:fs";
 import { createHash } from "node:crypto";
 function externalToAST(ext2) {
   const inputs = {};
@@ -35910,7 +35858,7 @@ var init_parser2 = __esm({
             warnings: [...cached2.result.warnings, ...warnings]
           };
           this.parseCache.set(filePath, {
-            mtime: fs6.statSync(filePath).mtimeMs,
+            mtime: fs5.statSync(filePath).mtimeMs,
             contentHash: this.computeHash(newContent),
             result
           });
@@ -35920,14 +35868,14 @@ var init_parser2 = __esm({
         }
       }
       parse(filePath, externalNodeTypes) {
-        const stats = fs6.statSync(filePath);
+        const stats = fs5.statSync(filePath);
         const hasExternalTypes = externalNodeTypes && externalNodeTypes.length > 0;
         if (!hasExternalTypes) {
           const cached2 = this.parseCache.get(filePath);
           if (cached2 && cached2.mtime === stats.mtimeMs) {
             return cached2.result;
           }
-          const rawContent2 = fs6.readFileSync(filePath, "utf-8");
+          const rawContent2 = fs5.readFileSync(filePath, "utf-8");
           const content2 = hasInPlaceMarkers(rawContent2) ? stripGeneratedSections(rawContent2) : rawContent2;
           const hash2 = this.computeHash(content2);
           if (cached2 && cached2.contentHash === hash2) {
@@ -35936,7 +35884,7 @@ var init_parser2 = __esm({
           }
           return this.fullParse(filePath, content2, hash2, stats.mtimeMs);
         }
-        const rawContent = fs6.readFileSync(filePath, "utf-8");
+        const rawContent = fs5.readFileSync(filePath, "utf-8");
         const content = hasInPlaceMarkers(rawContent) ? stripGeneratedSections(rawContent) : rawContent;
         const hash = this.computeHash(content);
         return this.fullParse(filePath, content, hash, stats.mtimeMs, externalNodeTypes);
@@ -36029,33 +35977,33 @@ var init_parser2 = __esm({
         const hasExtension = extensions.some((ext2) => moduleSpecifier.endsWith(ext2));
         if (hasExtension) {
           const fullPath = path6.resolve(currentDir, moduleSpecifier);
-          if (fs6.existsSync(fullPath)) return fullPath;
+          if (fs5.existsSync(fullPath)) return fullPath;
           if (moduleSpecifier.endsWith(".js")) {
             const tsPath = fullPath.replace(/\.js$/, ".ts");
-            if (fs6.existsSync(tsPath)) return tsPath;
+            if (fs5.existsSync(tsPath)) return tsPath;
             const tsxPath = fullPath.replace(/\.js$/, ".tsx");
-            if (fs6.existsSync(tsxPath)) return tsxPath;
+            if (fs5.existsSync(tsxPath)) return tsxPath;
           } else if (moduleSpecifier.endsWith(".jsx")) {
             const tsxPath = fullPath.replace(/\.jsx$/, ".tsx");
-            if (fs6.existsSync(tsxPath)) return tsxPath;
+            if (fs5.existsSync(tsxPath)) return tsxPath;
           }
           return null;
         }
         for (const ext2 of extensions) {
           const fullPath = path6.resolve(currentDir, moduleSpecifier + ext2);
-          if (fs6.existsSync(fullPath)) {
+          if (fs5.existsSync(fullPath)) {
             return fullPath;
           }
         }
         const dirPath = path6.resolve(currentDir, moduleSpecifier);
-        if (fs6.existsSync(dirPath) && fs6.statSync(dirPath).isDirectory()) {
+        if (fs5.existsSync(dirPath) && fs5.statSync(dirPath).isDirectory()) {
           const pkgPath = path6.join(dirPath, "package.json");
-          if (fs6.existsSync(pkgPath)) {
+          if (fs5.existsSync(pkgPath)) {
             try {
-              const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+              const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
               if (pkg.main) {
                 const mainPath = path6.resolve(dirPath, pkg.main);
-                if (fs6.existsSync(mainPath)) {
+                if (fs5.existsSync(mainPath)) {
                   return mainPath;
                 }
               }
@@ -36065,7 +36013,7 @@ var init_parser2 = __esm({
           }
           for (const ext2 of extensions) {
             const indexPath = path6.join(dirPath, `index${ext2}`);
-            if (fs6.existsSync(indexPath)) {
+            if (fs5.existsSync(indexPath)) {
               return indexPath;
             }
           }
@@ -36110,7 +36058,7 @@ var init_parser2 = __esm({
             } else {
               this.importStack.add(importedFilePath);
               try {
-                const importedRaw = fs6.readFileSync(importedFilePath, "utf-8");
+                const importedRaw = fs5.readFileSync(importedFilePath, "utf-8");
                 const importedContent = hasInPlaceMarkers(importedRaw) ? stripGeneratedSections(importedRaw) : importedRaw;
                 const importedFile = this.project.createSourceFile(importedFilePath, importedContent, {
                   overwrite: true
@@ -36178,7 +36126,7 @@ var init_parser2 = __esm({
         const dtsPath = resolvePackageTypesPath(moduleSpecifier, currentDir);
         if (!dtsPath) return [];
         try {
-          const dtsContent = fs6.readFileSync(dtsPath, "utf-8");
+          const dtsContent = fs5.readFileSync(dtsPath, "utf-8");
           const dtsFile = this.project.createSourceFile(
             `__npm_dts__/${moduleSpecifier}.d.ts`,
             dtsContent,
@@ -36239,7 +36187,7 @@ var init_parser2 = __esm({
         }
         this.importStack.add(importedFilePath);
         try {
-          const importedContent = fs6.readFileSync(importedFilePath, "utf-8");
+          const importedContent = fs5.readFileSync(importedFilePath, "utf-8");
           const importedFile = this.project.createSourceFile(importedFilePath, importedContent, {
             overwrite: true
           });
@@ -36277,7 +36225,7 @@ var init_parser2 = __esm({
           return this.createImportStub(imp);
         }
         try {
-          const dtsContent = fs6.readFileSync(dtsPath, "utf-8");
+          const dtsContent = fs5.readFileSync(dtsPath, "utf-8");
           const dtsFile = this.project.createSourceFile(
             `__npm_dts__/${imp.importSource}.d.ts`,
             dtsContent,
@@ -39259,13 +39207,13 @@ Add '@param ${fromPort}' to the workflow JSDoc and include it in the params obje
           connections.filter((c) => c.from.node === c.to.node).map((c) => c.from.node)
         );
         const nonSelfLoopConnections = connections.filter((c) => c.from.node !== c.to.node);
-        const dfs = (nodeName, path54) => {
+        const dfs = (nodeName, path55) => {
           if (recursionStack.has(nodeName)) {
             if (selfLoopNodes.has(nodeName)) {
               return false;
             }
-            const cycleStart = path54.indexOf(nodeName);
-            const cyclePath = [...path54.slice(cycleStart), nodeName];
+            const cycleStart = path55.indexOf(nodeName);
+            const cyclePath = [...path55.slice(cycleStart), nodeName];
             const cycleNodes = cyclePath.slice(0, -1);
             const sortedCycle = [...cycleNodes].sort();
             const cycleKey = sortedCycle.join(",");
@@ -39287,7 +39235,7 @@ Add '@param ${fromPort}' to the workflow JSDoc and include it in the params obje
             return false;
           }
           recursionStack.add(nodeName);
-          const newPath = [...path54, nodeName];
+          const newPath = [...path55, nodeName];
           const instance = instances.find((n) => n.id === nodeName);
           if (!instance) {
             recursionStack.delete(nodeName);
@@ -40523,14 +40471,14 @@ __export(serialization_node_exports, {
   saveAST: () => saveAST,
   saveASTAlongside: () => saveASTAlongside
 });
-import * as fs7 from "node:fs/promises";
+import * as fs6 from "node:fs/promises";
 import * as path7 from "node:path";
 async function saveAST(ast, filePath) {
   const json2 = serializeAST(ast, true);
-  await fs7.writeFile(filePath, json2, "utf-8");
+  await fs6.writeFile(filePath, json2, "utf-8");
 }
 async function loadAST(filePath) {
-  const json2 = await fs7.readFile(filePath, "utf-8");
+  const json2 = await fs6.readFile(filePath, "utf-8");
   return deserializeAST(json2);
 }
 async function saveASTAlongside(ast) {
@@ -40555,7 +40503,7 @@ var init_serialization_node = __esm({
 });
 
 // src/api/compile.ts
-import * as fs8 from "node:fs/promises";
+import * as fs7 from "node:fs/promises";
 import * as path8 from "node:path";
 async function compileWorkflow(filePath, options = {}) {
   const startTime = Date.now();
@@ -40577,7 +40525,7 @@ ${errorMessages.join("\n")}`);
   let code;
   let outputFile;
   if (inPlace) {
-    const sourceCode = await fs8.readFile(filePath, "utf-8");
+    const sourceCode = await fs7.readFile(filePath, "utf-8");
     const result2 = generateInPlace(sourceCode, parseResult.ast, {
       ...options.generate,
       allWorkflows: parseResult.allWorkflows,
@@ -40586,13 +40534,13 @@ ${errorMessages.join("\n")}`);
     code = result2.code;
     outputFile = filePath;
     if (options.write !== false) {
-      await fs8.writeFile(filePath, code, "utf-8");
+      await fs7.writeFile(filePath, code, "utf-8");
     }
   } else {
     code = generateCode(parseResult.ast, options.generate);
     outputFile = options.outputFile || getDefaultOutputFile(filePath);
     if (options.write !== false) {
-      await fs8.writeFile(outputFile, code, "utf-8");
+      await fs7.writeFile(outputFile, code, "utf-8");
     }
   }
   if (options.saveAST) {
@@ -40872,7 +40820,7 @@ function processResult(result, scope) {
   }
   return result !== NOTHING ? result : void 0;
 }
-function finalize(rootScope, value, path54) {
+function finalize(rootScope, value, path55) {
   if (isFrozen(value))
     return value;
   const useStrictIteration = rootScope.immer_.shouldUseStrictIteration();
@@ -40880,7 +40828,7 @@ function finalize(rootScope, value, path54) {
   if (!state) {
     each(
       value,
-      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path54),
+      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path55),
       useStrictIteration
     );
     return value;
@@ -40910,16 +40858,16 @@ function finalize(rootScope, value, path54) {
         result,
         key,
         childValue,
-        path54,
+        path55,
         isSet22
       ),
       useStrictIteration
     );
     maybeFreeze(rootScope, result, false);
-    if (path54 && rootScope.patches_) {
+    if (path55 && rootScope.patches_) {
       getPlugin("Patches").generatePatches_(
         state,
-        path54,
+        path55,
         rootScope.patches_,
         rootScope.inversePatches_
       );
@@ -40941,9 +40889,9 @@ function finalizeProperty(rootScope, parentState, targetObject, prop, childValue
   if (process.env.NODE_ENV !== "production" && childValue === targetObject)
     die(5);
   if (isDraft(childValue)) {
-    const path54 = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys.
+    const path55 = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys.
     !has2(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
-    const res = finalize(rootScope, childValue, path54);
+    const res = finalize(rootScope, childValue, path55);
     set(targetObject, prop, res);
     if (isDraft(res)) {
       rootScope.canAutoFreeze_ = false;
@@ -42333,8 +42281,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path54, errorMaps, issueData } = params;
-      const fullPath = [...path54, ...issueData.path || []];
+      const { data, path: path55, errorMaps, issueData } = params;
+      const fullPath = [...path55, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -42642,11 +42590,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path54, key) {
+      constructor(parent, value, path55, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path54;
+        this._path = path55;
         this._key = key;
       }
       get path() {
@@ -54570,7 +54518,7 @@ __export(doctor_exports, {
   runDoctorChecks: () => runDoctorChecks,
   stripJsonComments: () => stripJsonComments
 });
-import * as fs9 from "fs";
+import * as fs8 from "fs";
 import * as path9 from "path";
 import { execSync } from "child_process";
 function stripJsonComments(text) {
@@ -54605,9 +54553,9 @@ function stripJsonComments(text) {
 }
 function detectProjectModuleFormat(cwd) {
   const pkgPath = path9.join(cwd, "package.json");
-  if (fs9.existsSync(pkgPath)) {
+  if (fs8.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
       if (pkg.type === "module") {
         return { format: "esm", source: "package.json", details: '"type": "module"' };
       }
@@ -54622,9 +54570,9 @@ function detectProjectModuleFormat(cwd) {
     }
   }
   const tsconfigPath = path9.join(cwd, "tsconfig.json");
-  if (fs9.existsSync(tsconfigPath)) {
+  if (fs8.existsSync(tsconfigPath)) {
     try {
-      const raw = fs9.readFileSync(tsconfigPath, "utf8");
+      const raw = fs8.readFileSync(tsconfigPath, "utf8");
       const parsed = JSON.parse(stripJsonComments(raw));
       const compilerOptions = parsed.compilerOptions ?? {};
       const mod = typeof compilerOptions.module === "string" ? compilerOptions.module.toLowerCase() : void 0;
@@ -54661,7 +54609,7 @@ function checkNodeVersion() {
 }
 function checkTypeScriptVersion(cwd) {
   const tsPath = path9.join(cwd, "node_modules", "typescript", "package.json");
-  if (!fs9.existsSync(tsPath)) {
+  if (!fs8.existsSync(tsPath)) {
     return {
       name: "TypeScript version",
       status: "fail",
@@ -54670,7 +54618,7 @@ function checkTypeScriptVersion(cwd) {
     };
   }
   try {
-    const tsPkg = JSON.parse(fs9.readFileSync(tsPath, "utf8"));
+    const tsPkg = JSON.parse(fs8.readFileSync(tsPath, "utf8"));
     const major = parseInt(tsPkg.version.split(".")[0], 10);
     if (major >= 5) {
       return {
@@ -54696,7 +54644,7 @@ function checkTypeScriptVersion(cwd) {
 }
 function checkPackageJsonType(cwd) {
   const pkgPath = path9.join(cwd, "package.json");
-  if (!fs9.existsSync(pkgPath)) {
+  if (!fs8.existsSync(pkgPath)) {
     return {
       name: 'package.json "type"',
       status: "fail",
@@ -54705,7 +54653,7 @@ function checkPackageJsonType(cwd) {
     };
   }
   try {
-    const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
     if (pkg.type === "module") {
       return {
         name: 'package.json "type"',
@@ -54737,11 +54685,11 @@ function checkPackageJsonType(cwd) {
 }
 function readTsconfig(cwd) {
   const tsconfigPath = path9.join(cwd, "tsconfig.json");
-  if (!fs9.existsSync(tsconfigPath)) {
+  if (!fs8.existsSync(tsconfigPath)) {
     return { parsed: null, error: "No tsconfig.json found" };
   }
   try {
-    const raw = fs9.readFileSync(tsconfigPath, "utf8");
+    const raw = fs8.readFileSync(tsconfigPath, "utf8");
     const parsed = JSON.parse(stripJsonComments(raw));
     return { parsed };
   } catch {
@@ -54842,9 +54790,9 @@ function checkTsconfigModuleResolution(cwd) {
 }
 function checkFlowWeaverInstalled(cwd) {
   const pkgPath = path9.join(cwd, "node_modules", "@synergenius", "flow-weaver", "package.json");
-  if (fs9.existsSync(pkgPath)) {
+  if (fs8.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
       return {
         name: "@synergenius/flow-weaver installed",
         status: "pass",
@@ -54868,7 +54816,7 @@ function checkFlowWeaverInstalled(cwd) {
 function checkFlowWeaverVersion(cwd) {
   const libraryPath = path9.join(cwd, "node_modules", "@synergenius", "flow-weaver");
   const pkgPath = path9.join(libraryPath, "package.json");
-  if (!fs9.existsSync(pkgPath)) {
+  if (!fs8.existsSync(pkgPath)) {
     return {
       name: "Library version",
       status: "pass",
@@ -54877,8 +54825,8 @@ function checkFlowWeaverVersion(cwd) {
   }
   try {
     const projectPkgPath = path9.join(cwd, "package.json");
-    if (fs9.existsSync(projectPkgPath)) {
-      const projectPkg = JSON.parse(fs9.readFileSync(projectPkgPath, "utf8"));
+    if (fs8.existsSync(projectPkgPath)) {
+      const projectPkg = JSON.parse(fs8.readFileSync(projectPkgPath, "utf8"));
       const depSpec = projectPkg.dependencies?.["@synergenius/flow-weaver"] ?? projectPkg.devDependencies?.["@synergenius/flow-weaver"];
       if (typeof depSpec === "string" && (depSpec.startsWith("file:") || depSpec.startsWith("link:") || depSpec.startsWith("workspace:"))) {
         return {
@@ -54888,7 +54836,7 @@ function checkFlowWeaverVersion(cwd) {
         };
       }
     }
-    if (fs9.lstatSync(libraryPath).isSymbolicLink()) {
+    if (fs8.lstatSync(libraryPath).isSymbolicLink()) {
       return {
         name: "Library version",
         status: "pass",
@@ -54898,7 +54846,7 @@ function checkFlowWeaverVersion(cwd) {
   } catch {
   }
   try {
-    const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
     const currentVersion = pkg.version;
     const latestVersion = execSync("npm view @synergenius/flow-weaver version", {
       timeout: 5e3,
@@ -54927,7 +54875,7 @@ function checkFlowWeaverVersion(cwd) {
 }
 function checkTypesNodeInstalled(cwd) {
   const pkgPath = path9.join(cwd, "node_modules", "@types", "node", "package.json");
-  if (fs9.existsSync(pkgPath)) {
+  if (fs8.existsSync(pkgPath)) {
     return {
       name: "@types/node installed",
       status: "pass",
@@ -54943,7 +54891,7 @@ function checkTypesNodeInstalled(cwd) {
 }
 function checkTsxAvailable(cwd) {
   const localBin = path9.join(cwd, "node_modules", ".bin", "tsx");
-  if (fs9.existsSync(localBin)) {
+  if (fs8.existsSync(localBin)) {
     return {
       name: "tsx available",
       status: "pass",
@@ -54968,7 +54916,7 @@ function checkTsxAvailable(cwd) {
 }
 function readYaml(filePath) {
   try {
-    const content = fs9.readFileSync(filePath, "utf8");
+    const content = fs8.readFileSync(filePath, "utf8");
     return { data: load(content) };
   } catch (e) {
     return { data: null, error: e instanceof Error ? e.message : String(e) };
@@ -54976,7 +54924,7 @@ function readYaml(filePath) {
 }
 function checkProjectConfig(cwd) {
   const configPath = path9.join(cwd, ".flowweaver", "config.yaml");
-  if (!fs9.existsSync(configPath)) {
+  if (!fs8.existsSync(configPath)) {
     return {
       name: "Project config",
       status: "warn",
@@ -55019,7 +54967,7 @@ function checkProjectConfig(cwd) {
 }
 function checkDeploymentManifest(cwd) {
   const deployDir = path9.join(cwd, ".flowweaver", "deployment");
-  if (!fs9.existsSync(deployDir)) {
+  if (!fs8.existsSync(deployDir)) {
     return {
       name: "Deployment manifest",
       status: "pass",
@@ -55027,7 +54975,7 @@ function checkDeploymentManifest(cwd) {
     };
   }
   const manifestPath = path9.join(deployDir, "manifest.yaml");
-  if (!fs9.existsSync(manifestPath)) {
+  if (!fs8.existsSync(manifestPath)) {
     return {
       name: "Deployment manifest",
       status: "fail",
@@ -55077,7 +55025,7 @@ function checkDeploymentManifest(cwd) {
 }
 function checkDeploymentProfiles(cwd) {
   const deployDir = path9.join(cwd, ".flowweaver", "deployment");
-  if (!fs9.existsSync(deployDir)) {
+  if (!fs8.existsSync(deployDir)) {
     return {
       name: "Deployment profiles",
       status: "pass",
@@ -55085,7 +55033,7 @@ function checkDeploymentProfiles(cwd) {
     };
   }
   const manifestPath = path9.join(deployDir, "manifest.yaml");
-  if (!fs9.existsSync(manifestPath)) {
+  if (!fs8.existsSync(manifestPath)) {
     return {
       name: "Deployment profiles",
       status: "pass",
@@ -55105,7 +55053,7 @@ function checkDeploymentProfiles(cwd) {
   const invalid = [];
   for (const profile of profiles) {
     const profilePath = path9.join(deployDir, `${profile}.yaml`);
-    if (!fs9.existsSync(profilePath)) {
+    if (!fs8.existsSync(profilePath)) {
       missing.push(profile);
       continue;
     }
@@ -55205,7 +55153,7 @@ async function doctorCommand(options = {}) {
     }
   }
   if (!report.ok) {
-    process.exit(1);
+    throw new Error("Doctor found issues that need to be fixed");
   }
 }
 var VALID_FILE_TYPES;
@@ -55218,6 +55166,49 @@ var init_doctor = __esm({
   }
 });
 
+// src/cli/utils/safe-write.ts
+import * as fs9 from "fs";
+import * as path10 from "path";
+function ensureDir(dirPath) {
+  if (!fs9.existsSync(dirPath)) {
+    fs9.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function wrapIOError(filePath, error2) {
+  if (error2 instanceof Error) {
+    const code = error2.code;
+    if (code === "EACCES" || code === "EPERM") {
+      throw new Error(`Permission denied: cannot write to ${filePath}. Check file/directory permissions.`);
+    }
+    if (code === "EROFS") {
+      throw new Error(`Read-only file system: cannot write to ${filePath}.`);
+    }
+    throw error2;
+  }
+  throw error2;
+}
+function safeWriteFile(filePath, content, encoding = "utf8") {
+  try {
+    ensureDir(path10.dirname(filePath));
+    fs9.writeFileSync(filePath, content, encoding);
+  } catch (error2) {
+    wrapIOError(filePath, error2);
+  }
+}
+function safeAppendFile(filePath, content, encoding = "utf8") {
+  try {
+    ensureDir(path10.dirname(filePath));
+    fs9.appendFileSync(filePath, content, encoding);
+  } catch (error2) {
+    wrapIOError(filePath, error2);
+  }
+}
+var init_safe_write = __esm({
+  "src/cli/utils/safe-write.ts"() {
+    "use strict";
+  }
+});
+
 // src/cli/commands/compile.ts
 var compile_exports = {};
 __export(compile_exports, {
@@ -55225,9 +55216,9 @@ __export(compile_exports, {
   compileCustomTarget: () => compileCustomTarget
 });
 import * as fs10 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 function displayPath(filePath) {
-  const rel = path10.relative(process.cwd(), filePath);
+  const rel = path11.relative(process.cwd(), filePath);
   if (rel && !rel.startsWith("..") && rel.length < filePath.length) {
     return rel;
   }
@@ -55241,7 +55232,7 @@ function resolveModuleFormat(format, cwd) {
   return detection.format;
 }
 async function compileCommand(input, options = {}) {
-  const { production = false, sourceMap = false, strict = false, verbose = false, workflowName, dryRun = false, format, inlineRuntime = false, clean = false, target } = options;
+  const { production = false, sourceMap = false, strict = false, verbose = false, workflowName, dryRun = false, format, clean = false, target, output } = options;
   if (target && target !== "typescript") {
     return compileCustomTarget(target, input, { production, verbose, workflowName, dryRun, cron: options.cron, serve: options.serve, framework: options.framework, typedEvents: options.typedEvents, retries: options.retries, timeout: options.timeout });
   }
@@ -55250,7 +55241,7 @@ async function compileCommand(input, options = {}) {
   let pattern = input;
   try {
     if (fs10.existsSync(input) && fs10.statSync(input).isDirectory()) {
-      pattern = path10.join(input, "**/*.ts");
+      pattern = path11.join(input, "**/*.ts");
     }
   } catch {
   }
@@ -55265,6 +55256,23 @@ async function compileCommand(input, options = {}) {
   if (files.length === 0) {
     throw new Error(`No files found matching pattern: ${input}`);
   }
+  let outputDir;
+  let outputFile;
+  if (output) {
+    const isOutputDir = output.endsWith("/") || output.endsWith(path11.sep) || fs10.existsSync(output) && fs10.statSync(output).isDirectory();
+    if (isOutputDir) {
+      outputDir = output.endsWith("/") || output.endsWith(path11.sep) ? output.slice(0, -1) : output;
+      if (!fs10.existsSync(outputDir)) {
+        fs10.mkdirSync(outputDir, { recursive: true });
+      }
+    } else if (files.length > 1) {
+      throw new Error(
+        `Cannot use --output with a file path when compiling multiple files. Use a directory path instead (e.g. --output ${output}/)`
+      );
+    } else {
+      outputFile = path11.resolve(output);
+    }
+  }
   const totalTimer = logger.timer();
   logger.section("Compiling Workflows");
   if (verbose) {
@@ -55280,7 +55288,7 @@ async function compileCommand(input, options = {}) {
   let errorCount = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    const fileName = path10.basename(file);
+    const fileName = path11.basename(file);
     const fileTimer = logger.timer();
     try {
       const rawSource = fs10.readFileSync(file, "utf8");
@@ -55349,9 +55357,10 @@ async function compileCommand(input, options = {}) {
         }
       }
       const sourceCode = fs10.readFileSync(file, "utf8");
-      const result = generateInPlace(sourceCode, parseResult.ast, { production, moduleFormat, inlineRuntime, sourceFile: file, skipParamReturns: clean });
+      const result = generateInPlace(sourceCode, parseResult.ast, { production, moduleFormat, sourceFile: file, skipParamReturns: clean });
+      const writePath = outputFile ? outputFile : outputDir ? path11.join(outputDir, path11.basename(file)) : file;
       if (!dryRun) {
-        fs10.writeFileSync(file, result.code, "utf8");
+        safeWriteFile(writePath, result.code);
         if (sourceMap) {
           const mapResult = generateCode(parseResult.ast, {
             production,
@@ -55359,13 +55368,13 @@ async function compileCommand(input, options = {}) {
             moduleFormat
           });
           if (mapResult.sourceMap) {
-            const mapPath = file + ".map";
-            fs10.writeFileSync(mapPath, mapResult.sourceMap, "utf8");
+            const mapPath = writePath + ".map";
+            safeWriteFile(mapPath, mapResult.sourceMap);
             const sourceMappingComment = `
-//# sourceMappingURL=${path10.basename(mapPath)}
+//# sourceMappingURL=${path11.basename(mapPath)}
 `;
             if (!result.code.includes("//# sourceMappingURL=")) {
-              fs10.appendFileSync(file, sourceMappingComment, "utf8");
+              safeAppendFile(writePath, sourceMappingComment);
             }
             if (verbose) {
               logger.info(`    source map: ${displayPath(mapPath)}`);
@@ -55410,7 +55419,7 @@ async function compileCustomTarget(target, input, options) {
     const hint = available.length > 0 ? ` Available targets: typescript, ${available.join(", ")}` : " No custom targets registered.";
     throw new Error(`Unknown compile target: ${target}.${hint}`);
   }
-  const filePath = path10.resolve(input);
+  const filePath = path11.resolve(input);
   if (!fs10.existsSync(filePath)) {
     throw new Error(`File not found: ${displayPath(filePath)}`);
   }
@@ -55465,7 +55474,7 @@ ${msgs}`);
       logger.info(`... (${lines.length - 50} more lines)`);
     }
   } else {
-    fs10.writeFileSync(outputPath, code, "utf8");
+    safeWriteFile(outputPath, code);
     logger.success(`Compiled: ${displayPath(outputPath)}`);
   }
   logger.newline();
@@ -55486,6 +55495,7 @@ var init_compile2 = __esm({
     init_doctor();
     init_compile_target_registry();
     init_parser2();
+    init_safe_write();
   }
 });
 
@@ -55495,13 +55505,13 @@ __export(strip_exports, {
   stripCommand: () => stripCommand
 });
 import * as fs11 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 async function stripCommand(input, options = {}) {
   const { output, dryRun = false, verbose = false } = options;
   let pattern = input;
   try {
     if (fs11.existsSync(input) && fs11.statSync(input).isDirectory()) {
-      pattern = path11.join(input, "**/*.ts");
+      pattern = path12.join(input, "**/*.ts");
     }
   } catch {
   }
@@ -55514,8 +55524,7 @@ async function stripCommand(input, options = {}) {
     }
   });
   if (files.length === 0) {
-    logger.error(`No files found matching pattern: ${input}`);
-    process.exit(1);
+    throw new Error(`No files found matching pattern: ${input}`);
   }
   const t = logger.timer();
   let stripped = 0;
@@ -55525,24 +55534,21 @@ async function stripCommand(input, options = {}) {
     if (!hasInPlaceMarkers(content)) {
       skipped++;
       if (verbose) {
-        logger.info(`Skipped (no markers): ${path11.relative(process.cwd(), filePath)}`);
+        logger.info(`Skipped (no markers): ${path12.relative(process.cwd(), filePath)}`);
       }
       continue;
     }
     const result = stripGeneratedSections(content);
     if (dryRun) {
-      logger.info(`Would strip: ${path11.relative(process.cwd(), filePath)}`);
+      logger.info(`Would strip: ${path12.relative(process.cwd(), filePath)}`);
       stripped++;
       continue;
     }
-    const outPath = output ? path11.join(path11.resolve(output), path11.basename(filePath)) : filePath;
-    if (output) {
-      fs11.mkdirSync(path11.dirname(outPath), { recursive: true });
-    }
-    fs11.writeFileSync(outPath, result);
+    const outPath = output ? path12.join(path12.resolve(output), path12.basename(filePath)) : filePath;
+    safeWriteFile(outPath, result);
     stripped++;
     if (verbose) {
-      logger.success(`Stripped: ${path11.relative(process.cwd(), outPath)}`);
+      logger.success(`Stripped: ${path12.relative(process.cwd(), outPath)}`);
     }
   }
   const verb = dryRun ? "would be stripped" : "stripped";
@@ -55554,6 +55560,7 @@ var init_strip = __esm({
     init_esm5();
     init_generate_in_place();
     init_logger();
+    init_safe_write();
   }
 });
 
@@ -55859,14 +55866,14 @@ function waypointsToSvgPath(waypoints, cornerRadius) {
       radii[i + 1] *= scale;
     }
   }
-  let path54 = `M ${waypoints[0][0]},${waypoints[0][1]}`;
+  let path55 = `M ${waypoints[0][0]},${waypoints[0][1]}`;
   for (let i = 1; i < waypoints.length - 1; i++) {
     const prev = waypoints[i - 1];
     const curr = waypoints[i];
     const next = waypoints[i + 1];
     const r = radii[i];
     if (r < 2) {
-      path54 += ` L ${curr[0]},${curr[1]}`;
+      path55 += ` L ${curr[0]},${curr[1]}`;
       continue;
     }
     const dPrev = [prev[0] - curr[0], prev[1] - curr[1]];
@@ -55879,12 +55886,12 @@ function waypointsToSvgPath(waypoints, cornerRadius) {
     const arcEnd = [curr[0] + uNext[0] * r, curr[1] + uNext[1] * r];
     const cross = dPrev[0] * dNext[1] - dPrev[1] * dNext[0];
     const sweep = cross > 0 ? 0 : 1;
-    path54 += ` L ${arcStart[0]},${arcStart[1]}`;
-    path54 += ` A ${r} ${r} 0 0 ${sweep} ${arcEnd[0]},${arcEnd[1]}`;
+    path55 += ` L ${arcStart[0]},${arcStart[1]}`;
+    path55 += ` A ${r} ${r} 0 0 ${sweep} ${arcEnd[0]},${arcEnd[1]}`;
   }
   const last2 = waypoints[waypoints.length - 1];
-  path54 += ` L ${last2[0]},${last2[1]}`;
-  return path54;
+  path55 += ` L ${last2[0]},${last2[1]}`;
+  return path55;
 }
 function computeWaypoints(from, to, nodeBoxes, sourceNodeId, targetNodeId, padding, exitStub, entryStub, allocator) {
   const isSelfConnection = sourceNodeId === targetNodeId;
@@ -56031,7 +56038,7 @@ function calculateOrthogonalPath(from, to, nodeBoxes, sourceNodeId, targetNodeId
 }
 function calculateOrthogonalPathSafe(from, to, nodeBoxes, sourceNodeId, targetNodeId, options, allocator) {
   try {
-    const path54 = calculateOrthogonalPath(
+    const path55 = calculateOrthogonalPath(
       from,
       to,
       nodeBoxes,
@@ -56040,8 +56047,8 @@ function calculateOrthogonalPathSafe(from, to, nodeBoxes, sourceNodeId, targetNo
       options,
       allocator
     );
-    if (!path54 || path54.length < 5) return null;
-    return path54;
+    if (!path55 || path55.length < 5) return null;
+    return path55;
   } catch {
     return null;
   }
@@ -56265,13 +56272,13 @@ function computeConnectionPath(sx, sy, tx, ty) {
   const deUy = deY / deLen;
   const [cx, cy] = quadCurveControl(bx, by, dx, dy, -deUx, -deUy);
   const [fx, fy] = quadCurveControl(gx, gy, ex, ey, deUx, deUy);
-  let path54 = `M ${cx},${cy} M ${ax},${ay}`;
-  path54 += ` L ${bx},${by}`;
-  path54 += ` Q ${cx},${cy} ${dx},${dy}`;
-  path54 += ` L ${ex},${ey}`;
-  path54 += ` Q ${fx},${fy} ${gx},${gy}`;
-  path54 += ` L ${hx},${hy}`;
-  return path54;
+  let path55 = `M ${cx},${cy} M ${ax},${ay}`;
+  path55 += ` L ${bx},${by}`;
+  path55 += ` Q ${cx},${cy} ${dx},${dy}`;
+  path55 += ` L ${ex},${ey}`;
+  path55 += ` Q ${fx},${fy} ${gx},${gy}`;
+  path55 += ` L ${hx},${hy}`;
+  return path55;
 }
 function orderedPorts(ports, direction) {
   const cloned = {};
@@ -56561,7 +56568,7 @@ function finalizeScopePositions(parentNode, ast, theme = "dark") {
 function buildConnection(fromNode, fromPort, toNode, toPort, sourcePort, targetPort, theme = "dark") {
   const sourceColor = getPortColor(sourcePort.dataType, sourcePort.isFailure, theme);
   const targetColor = getPortColor(targetPort.dataType, targetPort.isFailure, theme);
-  const path54 = computeConnectionPath(sourcePort.cx, sourcePort.cy, targetPort.cx, targetPort.cy);
+  const path55 = computeConnectionPath(sourcePort.cx, sourcePort.cy, targetPort.cx, targetPort.cy);
   return {
     fromNode,
     fromPort,
@@ -56570,7 +56577,7 @@ function buildConnection(fromNode, fromPort, toNode, toPort, sourcePort, targetP
     sourceColor,
     targetColor,
     isStepConnection: sourcePort.dataType === "STEP",
-    path: path54
+    path: path55
   };
 }
 function portsColumnHeight(count) {
@@ -57031,9 +57038,9 @@ function buildDiagramGraph(ast, options = {}) {
       color: targetColor,
       dashed
     };
-    let path54;
+    let path55;
     if (xDistance > STUB_DISTANCE_THRESHOLD) {
-      path54 = "";
+      path55 = "";
     } else if (!useCurve && distance > ORTHOGONAL_DISTANCE_THRESHOLD) {
       const orthoPath = calculateOrthogonalPathSafe(
         [sx, sy],
@@ -57044,9 +57051,9 @@ function buildDiagramGraph(ast, options = {}) {
         { fromPortIndex: pc3.fromPortIndex, toPortIndex: pc3.toPortIndex },
         allocator
       );
-      path54 = orthoPath ?? computeConnectionPath(sx, sy, tx, ty);
+      path55 = orthoPath ?? computeConnectionPath(sx, sy, tx, ty);
     } else {
-      path54 = computeConnectionPath(sx, sy, tx, ty);
+      path55 = computeConnectionPath(sx, sy, tx, ty);
     }
     connections.push({
       fromNode: pc3.fromNodeId,
@@ -57056,7 +57063,7 @@ function buildDiagramGraph(ast, options = {}) {
       sourceColor,
       targetColor,
       isStepConnection: pc3.sourcePort.dataType === "STEP",
-      path: path54,
+      path: path55,
       sourceStub,
       targetStub
     });
@@ -57216,12 +57223,12 @@ function resolveDefaultIcon(nt) {
   if (nt.variant === "WORKFLOW" || nt.variant === "IMPORTED_WORKFLOW") return "flow";
   return "code";
 }
-function pathExtent(path54) {
+function pathExtent(path55) {
   let minX = Infinity, minY = Infinity;
   let maxX = -Infinity, maxY = -Infinity;
   const pattern = /(-?[\d.]+),(-?[\d.]+)/g;
   let m;
-  while ((m = pattern.exec(path54)) !== null) {
+  while ((m = pattern.exec(path55)) !== null) {
     const x = parseFloat(m[1]);
     const y = parseFloat(m[2]);
     minX = Math.min(minX, x);
@@ -57827,7 +57834,7 @@ __export(describe_exports, {
   generateMermaid: () => generateMermaid
 });
 import * as fs12 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 function buildNodeInfo(instance, nodeType) {
   return {
     id: instance.id,
@@ -57860,17 +57867,17 @@ function buildAdjacency(ast) {
 function enumeratePaths(ast) {
   const { fromStart, toExit, edges } = buildAdjacency(ast);
   const paths = [];
-  function dfs(current2, path54, visited) {
+  function dfs(current2, path55, visited) {
     if (toExit.has(current2)) {
-      paths.push([...path54, "Exit"]);
+      paths.push([...path55, "Exit"]);
     }
     const targets = edges.get(current2) || [];
     for (const next of targets) {
       if (!visited.has(next)) {
         visited.add(next);
-        path54.push(next);
-        dfs(next, path54, visited);
-        path54.pop();
+        path55.push(next);
+        dfs(next, path55, visited);
+        path55.pop();
         visited.delete(next);
       }
     }
@@ -57884,22 +57891,22 @@ function enumeratePaths(ast) {
 function buildGraph(ast) {
   const { fromStart, toExit, edges } = buildAdjacency(ast);
   const lines = [];
-  function dfs(current2, path54, visited) {
+  function dfs(current2, path55, visited) {
     if (toExit.has(current2)) {
-      lines.push([...path54, "Exit"].join(" -> "));
+      lines.push([...path55, "Exit"].join(" -> "));
     }
     const targets = edges.get(current2) || [];
     for (const next of targets) {
       if (!visited.has(next)) {
         visited.add(next);
-        path54.push(next);
-        dfs(next, path54, visited);
-        path54.pop();
+        path55.push(next);
+        dfs(next, path55, visited);
+        path55.pop();
         visited.delete(next);
       }
     }
     if (targets.length === 0 && !toExit.has(current2)) {
-      lines.push(path54.join(" -> "));
+      lines.push(path55.join(" -> "));
     }
   }
   fromStart.forEach((startNode) => {
@@ -58121,36 +58128,32 @@ function formatDescribeOutput(ast, output, format) {
 }
 async function describeCommand(input, options = {}) {
   const { format = "json", node: focusNodeId, workflowName, compile = false } = options;
-  const filePath = path12.resolve(input);
+  const filePath = path13.resolve(input);
   if (!fs12.existsSync(filePath)) {
-    logger.error(`File not found: ${filePath}`);
-    process.exit(1);
+    throw new Error(`File not found: ${filePath}`);
   }
   try {
     const parseResult = await parseWorkflow(filePath, { workflowName });
     if (parseResult.errors.length > 0) {
-      logger.error(`Parse errors:`);
-      parseResult.errors.forEach((err) => logger.error(`  ${err}`));
-      process.exit(1);
+      throw new Error(`Parse errors:
+${parseResult.errors.map((err) => `  ${err}`).join("\n")}`);
     }
     const ast = parseResult.ast;
     if (compile) {
       const sourceCode = fs12.readFileSync(filePath, "utf8");
       const generated = generateInPlace(sourceCode, ast, { production: false });
       if (generated.hasChanges) {
-        fs12.writeFileSync(filePath, generated.code, "utf8");
-        logger.info(`Updated runtime markers in ${path12.basename(filePath)}`);
+        safeWriteFile(filePath, generated.code);
+        logger.info(`Updated runtime markers in ${path13.basename(filePath)}`);
       }
     }
     const output = describeWorkflow(ast, { node: focusNodeId });
     console.log(formatDescribeOutput(ast, output, format));
   } catch (error2) {
     if (error2 instanceof Error && error2.message.startsWith("Node not found:")) {
-      logger.error(error2.message);
-      process.exit(1);
+      throw error2;
     }
-    logger.error(`Failed to describe workflow: ${getErrorMessage(error2)}`);
-    process.exit(1);
+    throw new Error(`Failed to describe workflow: ${getErrorMessage(error2)}`);
   }
 }
 var init_describe = __esm({
@@ -58161,6 +58164,7 @@ var init_describe = __esm({
     init_query();
     init_logger();
     init_error_utils();
+    init_safe_write();
     init_geometry();
     init_ascii_renderer();
   }
@@ -60209,33 +60213,27 @@ __export(diagram_exports, {
   diagramCommand: () => diagramCommand
 });
 import * as fs13 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 async function diagramCommand(input, options = {}) {
   const { output, format = "svg", ...diagramOptions } = options;
-  const filePath = path13.resolve(input);
+  const filePath = path14.resolve(input);
   if (!fs13.existsSync(filePath)) {
-    logger.error(`File not found: ${filePath}`);
-    process.exit(1);
+    throw new Error(`File not found: ${filePath}`);
   }
-  try {
-    let result;
-    if (ASCII_FORMATS.has(format)) {
-      result = fileToASCII(filePath, { ...diagramOptions, format });
-    } else if (format === "html") {
-      result = fileToHTML(filePath, diagramOptions);
-    } else {
-      result = fileToSVG(filePath, diagramOptions);
-    }
-    if (output) {
-      const outputPath = path13.resolve(output);
-      fs13.writeFileSync(outputPath, result, "utf-8");
-      logger.success(`Diagram written to ${outputPath}`);
-    } else {
-      process.stdout.write(result);
-    }
-  } catch (error2) {
-    logger.error(`Failed to generate diagram: ${getErrorMessage(error2)}`);
-    process.exit(1);
+  let result;
+  if (ASCII_FORMATS.has(format)) {
+    result = fileToASCII(filePath, { ...diagramOptions, format });
+  } else if (format === "html") {
+    result = fileToHTML(filePath, diagramOptions);
+  } else {
+    result = fileToSVG(filePath, diagramOptions);
+  }
+  if (output) {
+    const outputPath = path14.resolve(output);
+    safeWriteFile(outputPath, result);
+    logger.success(`Diagram written to ${outputPath}`);
+  } else {
+    process.stdout.write(result);
   }
 }
 var ASCII_FORMATS;
@@ -60244,7 +60242,7 @@ var init_diagram2 = __esm({
     "use strict";
     init_diagram();
     init_logger();
-    init_error_utils();
+    init_safe_write();
     ASCII_FORMATS = /* @__PURE__ */ new Set(["ascii", "ascii-compact", "text"]);
   }
 });
@@ -60273,18 +60271,16 @@ __export(diff_exports, {
   diffCommand: () => diffCommand
 });
 import * as fs14 from "fs";
-import * as path14 from "path";
+import * as path15 from "path";
 async function diffCommand(file1, file2, options = {}) {
   const { format = "text", workflowName, exitZero = false } = options;
-  const filePath1 = path14.resolve(file1);
-  const filePath2 = path14.resolve(file2);
+  const filePath1 = path15.resolve(file1);
+  const filePath2 = path15.resolve(file2);
   if (!fs14.existsSync(filePath1)) {
-    logger.error(`File not found: ${filePath1}`);
-    process.exit(1);
+    throw new Error(`File not found: ${filePath1}`);
   }
   if (!fs14.existsSync(filePath2)) {
-    logger.error(`File not found: ${filePath2}`);
-    process.exit(1);
+    throw new Error(`File not found: ${filePath2}`);
   }
   try {
     const [result1, result2] = await Promise.all([
@@ -60292,14 +60288,12 @@ async function diffCommand(file1, file2, options = {}) {
       parseWorkflow(filePath2, { workflowName })
     ]);
     if (result1.errors.length > 0) {
-      logger.error(`Parse errors in ${file1}:`);
-      result1.errors.forEach((err) => logger.error(`  ${err}`));
-      process.exit(1);
+      throw new Error(`Parse errors in ${file1}:
+${result1.errors.map((err) => `  ${err}`).join("\n")}`);
     }
     if (result2.errors.length > 0) {
-      logger.error(`Parse errors in ${file2}:`);
-      result2.errors.forEach((err) => logger.error(`  ${err}`));
-      process.exit(1);
+      throw new Error(`Parse errors in ${file2}:
+${result2.errors.map((err) => `  ${err}`).join("\n")}`);
     }
     const diff = WorkflowDiffer.compare(result1.ast, result2.ast);
     if (diff.identical) {
@@ -60311,12 +60305,11 @@ async function diffCommand(file1, file2, options = {}) {
     } else {
       console.log(formatDiff(diff, format));
       if (!exitZero) {
-        process.exit(1);
+        throw new Error("Workflows have differences");
       }
     }
   } catch (error2) {
-    logger.error(`Failed to diff workflows: ${getErrorMessage(error2)}`);
-    process.exit(1);
+    throw new Error(`Failed to diff workflows: ${getErrorMessage(error2)}`);
   }
 }
 var init_diff2 = __esm({
@@ -60335,14 +60328,14 @@ __export(validate_exports2, {
   validateCommand: () => validateCommand
 });
 import * as fs15 from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 async function validateCommand(input, options = {}) {
   const { verbose = false, quiet = false, workflowName, json: json2 = false, strict = false } = options;
   try {
     let pattern = input;
     try {
       if (fs15.existsSync(input) && fs15.statSync(input).isDirectory()) {
-        pattern = path15.join(input, "**/*.ts");
+        pattern = path16.join(input, "**/*.ts");
       }
     } catch {
     }
@@ -60376,7 +60369,7 @@ async function validateCommand(input, options = {}) {
     const jsonResults = [];
     for (let i = 0; i < files.length; i++) {
       const file = files[i];
-      const fileName = path15.basename(file);
+      const fileName = path16.basename(file);
       if (!json2 && verbose) {
         logger.progress(i + 1, files.length, fileName);
       }
@@ -60561,7 +60554,11 @@ async function validateCommand(input, options = {}) {
       }
     }
     if (totalErrors > 0) {
-      process.exit(1);
+      if (json2) {
+        process.exitCode = 1;
+        return;
+      }
+      throw new Error(`Validation failed with ${totalErrors} error${totalErrors !== 1 ? "s" : ""}`);
     }
   } catch (error2) {
     if (json2) {
@@ -65480,15 +65477,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path54 = [graph[toModel].parent, toModel];
+      const path55 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path54.unshift(graph[cur].parent);
+        path55.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path54;
+      fn.conversion = path55;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -66050,12 +66047,12 @@ var init_esm8 = __esm({
 
 // src/docs/index.ts
 import * as fs16 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getDocsDir() {
   const thisFile = fileURLToPath3(import.meta.url);
-  const packageRoot = path16.resolve(path16.dirname(thisFile), "..", "..");
-  return path16.join(packageRoot, "docs", "reference");
+  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]*)$/);
@@ -66132,7 +66129,7 @@ function listTopics() {
   if (fs16.existsSync(docsDir)) {
     const files = fs16.readdirSync(docsDir).filter((f) => f.endsWith(".md")).sort();
     for (const file of files) {
-      const raw = fs16.readFileSync(path16.join(docsDir, file), "utf-8");
+      const raw = fs16.readFileSync(path17.join(docsDir, file), "utf-8");
       const { frontmatter } = parseFrontmatter(raw);
       coreTopics.push({
         slug: file.replace(/\.md$/, ""),
@@ -66157,7 +66154,7 @@ function listTopics() {
 }
 function readTopic(slug, compact2) {
   const docsDir = getDocsDir();
-  const coreFilePath = path16.join(docsDir, `${slug}.md`);
+  const coreFilePath = path17.join(docsDir, `${slug}.md`);
   if (fs16.existsSync(coreFilePath)) {
     const raw = fs16.readFileSync(coreFilePath, "utf-8");
     const { frontmatter, body } = parseFrontmatter(raw);
@@ -66190,7 +66187,7 @@ function readTopic(slug, compact2) {
 }
 function readTopicStructured(slug) {
   const docsDir = getDocsDir();
-  const filePath = path16.join(docsDir, `${slug}.md`);
+  const filePath = path17.join(docsDir, `${slug}.md`);
   if (!fs16.existsSync(filePath)) return null;
   const raw = fs16.readFileSync(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
@@ -66214,7 +66211,7 @@ function searchDocs(query) {
       (kw) => queryTerms.some((term) => kw.toLowerCase().includes(term))
     );
     const packTopic = packDocTopics.find((p) => p.slug === topic.slug);
-    const filePath = packTopic ? packTopic.filePath : path16.join(docsDir, `${topic.slug}.md`);
+    const filePath = packTopic ? packTopic.filePath : path17.join(docsDir, `${topic.slug}.md`);
     if (!fs16.existsSync(filePath)) continue;
     const raw = fs16.readFileSync(filePath, "utf-8");
     const { body } = parseFrontmatter(raw);
@@ -67084,7 +67081,7 @@ __export(mcp_setup_exports, {
 });
 import { execSync as execSync3 } from "child_process";
 import * as fs17 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 import * as os from "os";
 function defaultDeps() {
   return {
@@ -67132,7 +67129,7 @@ async function binaryExists(binary2, deps) {
 async function mergeJsonConfig(deps, filePath, rootKey) {
   const existing = await deps.readFile(filePath);
   if (existing === null) {
-    const dir = path17.dirname(filePath);
+    const dir = path18.dirname(filePath);
     await deps.mkdir(dir);
     const config3 = { [rootKey]: { "flow-weaver": MCP_ENTRY } };
     await deps.writeFile(filePath, JSON.stringify(config3, null, 2) + "\n");
@@ -67341,12 +67338,12 @@ var init_mcp_setup = __esm({
         id: "cursor",
         displayName: "Cursor",
         detect: async (deps) => {
-          const dirExists = await deps.fileExists(path17.join(deps.cwd(), ".cursor"));
+          const dirExists = await deps.fileExists(path18.join(deps.cwd(), ".cursor"));
           if (dirExists) return true;
           return binaryExists("cursor", deps);
         },
         isConfigured: async (deps) => {
-          const filePath = path17.join(deps.cwd(), ".cursor", "mcp.json");
+          const filePath = path18.join(deps.cwd(), ".cursor", "mcp.json");
           const content = await deps.readFile(filePath);
           if (!content) return false;
           try {
@@ -67357,7 +67354,7 @@ var init_mcp_setup = __esm({
           }
         },
         configure: async (deps) => {
-          const filePath = path17.join(deps.cwd(), ".cursor", "mcp.json");
+          const filePath = path18.join(deps.cwd(), ".cursor", "mcp.json");
           const result = await mergeJsonConfig(deps, filePath, "mcpServers");
           return result.detail;
         }
@@ -67368,7 +67365,7 @@ var init_mcp_setup = __esm({
         displayName: "VS Code Copilot",
         detect: (deps) => binaryExists("code", deps),
         isConfigured: async (deps) => {
-          const filePath = path17.join(deps.cwd(), ".vscode", "mcp.json");
+          const filePath = path18.join(deps.cwd(), ".vscode", "mcp.json");
           const content = await deps.readFile(filePath);
           if (!content) return false;
           try {
@@ -67379,7 +67376,7 @@ var init_mcp_setup = __esm({
           }
         },
         configure: async (deps) => {
-          const filePath = path17.join(deps.cwd(), ".vscode", "mcp.json");
+          const filePath = path18.join(deps.cwd(), ".vscode", "mcp.json");
           const result = await mergeJsonConfig(deps, filePath, "servers");
           return result.detail;
         }
@@ -67389,13 +67386,13 @@ var init_mcp_setup = __esm({
         id: "windsurf",
         displayName: "Windsurf",
         detect: async (deps) => {
-          const configDir = path17.join(deps.homedir(), ".codeium", "windsurf");
+          const configDir = path18.join(deps.homedir(), ".codeium", "windsurf");
           const dirExists = await deps.fileExists(configDir);
           if (dirExists) return true;
           return binaryExists("windsurf", deps);
         },
         isConfigured: async (deps) => {
-          const filePath = path17.join(deps.homedir(), ".codeium", "windsurf", "mcp_config.json");
+          const filePath = path18.join(deps.homedir(), ".codeium", "windsurf", "mcp_config.json");
           const content = await deps.readFile(filePath);
           if (!content) return false;
           try {
@@ -67406,7 +67403,7 @@ var init_mcp_setup = __esm({
           }
         },
         configure: async (deps) => {
-          const filePath = path17.join(deps.homedir(), ".codeium", "windsurf", "mcp_config.json");
+          const filePath = path18.join(deps.homedir(), ".codeium", "windsurf", "mcp_config.json");
           const result = await mergeJsonConfig(deps, filePath, "mcpServers");
           return result.detail;
         }
@@ -67434,10 +67431,10 @@ var init_mcp_setup = __esm({
         id: "openclaw",
         displayName: "OpenClaw",
         detect: async (deps) => {
-          return deps.fileExists(path17.join(deps.cwd(), "openclaw.json"));
+          return deps.fileExists(path18.join(deps.cwd(), "openclaw.json"));
         },
         isConfigured: async (deps) => {
-          const filePath = path17.join(deps.cwd(), "openclaw.json");
+          const filePath = path18.join(deps.cwd(), "openclaw.json");
           const content = await deps.readFile(filePath);
           if (!content) return false;
           try {
@@ -67448,7 +67445,7 @@ var init_mcp_setup = __esm({
           }
         },
         configure: async (deps) => {
-          const filePath = path17.join(deps.cwd(), "openclaw.json");
+          const filePath = path18.join(deps.cwd(), "openclaw.json");
           const result = await mergeJsonConfig(deps, filePath, "mcpServers");
           return result.detail;
         }
@@ -67472,7 +67469,7 @@ __export(init_exports, {
   validateProjectName: () => validateProjectName
 });
 import * as fs18 from "fs";
-import * as path18 from "path";
+import * as path19 from "path";
 import { execSync as execSync4, spawn } from "child_process";
 function validateProjectName(name) {
   if (!name) return "Project name cannot be empty";
@@ -67503,7 +67500,7 @@ async function resolveInitConfig(dirArg, options) {
   if (options.name) {
     projectName = options.name;
   } else if (dirArg) {
-    projectName = path18.basename(dirArg);
+    projectName = path19.basename(dirArg);
   } else if (skipPrompts) {
     projectName = "my-project";
   } else {
@@ -67517,7 +67514,7 @@ async function resolveInitConfig(dirArg, options) {
   if (valid !== true) {
     throw new Error(valid);
   }
-  const targetDir = path18.resolve(dirArg ?? projectName);
+  const targetDir = path19.resolve(dirArg ?? projectName);
   let persona;
   if (options.preset) {
     if (!VALID_PERSONAS.includes(options.preset)) {
@@ -67823,8 +67820,8 @@ function scaffoldProject(targetDir, files, options) {
   const filesCreated = [];
   const filesSkipped = [];
   for (const [relativePath, content] of Object.entries(files)) {
-    const absPath = path18.join(targetDir, relativePath);
-    const dir = path18.dirname(absPath);
+    const absPath = path19.join(targetDir, relativePath);
+    const dir = path19.dirname(absPath);
     fs18.mkdirSync(dir, { recursive: true });
     if (fs18.existsSync(absPath) && !options.force) {
       filesSkipped.push(relativePath);
@@ -67898,9 +67895,9 @@ async function handleAgentHandoff(opts) {
     }
     if (promptAction === "file" || promptAction === "both") {
       const setupContent = generateSetupPromptFile(projectName, persona, template, filesCreated, useCaseDescription);
-      const setupPath = path18.join(targetDir, "PROJECT_SETUP.md");
+      const setupPath = path19.join(targetDir, "PROJECT_SETUP.md");
       fs18.writeFileSync(setupPath, setupContent, "utf8");
-      const gitignorePath = path18.join(targetDir, ".gitignore");
+      const gitignorePath = path19.join(targetDir, ".gitignore");
       if (fs18.existsSync(gitignorePath)) {
         const existing = fs18.readFileSync(gitignorePath, "utf8");
         if (!existing.includes("PROJECT_SETUP.md")) {
@@ -67917,7 +67914,7 @@ async function initCommand(dirArg, options) {
   try {
     await loadPackTemplates(process.cwd());
     const config2 = await resolveInitConfig(dirArg, options);
-    const pkgPath = path18.join(config2.targetDir, "package.json");
+    const pkgPath = path19.join(config2.targetDir, "package.json");
     if (fs18.existsSync(pkgPath) && !config2.force) {
       throw new Error(
         `${config2.targetDir} already contains a package.json. Use --force to overwrite.`
@@ -67941,7 +67938,7 @@ async function initCommand(dirArg, options) {
       gitResult = runGitInit(config2.targetDir);
     }
     const workflowFile = `${config2.projectName}-workflow.ts`;
-    const workflowPath = path18.join(config2.targetDir, "src", workflowFile);
+    const workflowPath = path19.join(config2.targetDir, "src", workflowFile);
     let compileResult;
     if (!options.json && fs18.existsSync(workflowPath)) {
       try {
@@ -68042,7 +68039,7 @@ async function initCommand(dirArg, options) {
       logger.newline();
     }
     const workflowCode = files[`src/${workflowFile}`] ?? null;
-    const relDir = path18.relative(process.cwd(), config2.targetDir);
+    const relDir = path19.relative(process.cwd(), config2.targetDir);
     const displayDir = !relDir || relDir === "." ? null : relDir.startsWith("../../") ? config2.targetDir : relDir;
     const skipAgent = options.agent === false || options.yes || isNonInteractive();
     if (!skipAgent) {
@@ -68176,7 +68173,7 @@ var watch_exports = {};
 __export(watch_exports, {
   watchCommand: () => watchCommand
 });
-import * as path19 from "path";
+import * as path20 from "path";
 function timestamp2() {
   const now = /* @__PURE__ */ new Date();
   const h = String(now.getHours()).padStart(2, "0");
@@ -68201,7 +68198,7 @@ async function watchCommand(input, options = {}) {
   });
   watcher.on("change", async (file) => {
     logger.newline();
-    logger.info(`${timestamp2()} File changed: ${path19.basename(file)}`);
+    logger.info(`${timestamp2()} File changed: ${path20.basename(file)}`);
     logger.info(`${timestamp2()} Recompiling...`);
     logger.newline();
     try {
@@ -68242,15 +68239,15 @@ var init_watch = __esm({
 });
 
 // src/mcp/workflow-executor.ts
-import * as path20 from "path";
+import * as path21 from "path";
 import * as fs19 from "fs";
 import { pathToFileURL } from "url";
 import ts4 from "typescript";
 async function executeWorkflowFromFile(filePath, params, options) {
-  const resolvedPath = path20.resolve(filePath);
+  const resolvedPath = path21.resolve(filePath);
   const includeTrace = options?.includeTrace !== false;
   const tmpId = `fw-exec-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const tmpBase = path20.join(path20.dirname(resolvedPath), tmpId);
+  const tmpBase = path21.join(path21.dirname(resolvedPath), tmpId);
   const tmpTsFile = `${tmpBase}.ts`;
   const tmpFile = `${tmpBase}.mjs`;
   try {
@@ -68279,20 +68276,20 @@ async function executeWorkflowFromFile(filePath, params, options) {
       }
     });
     let transpiledOutput = jsOutput.outputText;
-    const srcDir = path20.dirname(tmpTsFile);
-    if (srcDir.includes(`${path20.sep}src${path20.sep}`)) {
-      const distDir = srcDir.replace(`${path20.sep}src${path20.sep}`, `${path20.sep}dist${path20.sep}`);
+    const srcDir = path21.dirname(tmpTsFile);
+    if (srcDir.includes(`${path21.sep}src${path21.sep}`)) {
+      const distDir = srcDir.replace(`${path21.sep}src${path21.sep}`, `${path21.sep}dist${path21.sep}`);
       transpiledOutput = transpiledOutput.replace(
         /from\s+['"](\.[^'"]+)['"]/g,
         (_match, specifier) => {
-          const resolvedSrc = path20.resolve(srcDir, specifier);
+          const resolvedSrc = path21.resolve(srcDir, specifier);
           if (!fs19.existsSync(resolvedSrc)) {
             const distEquivalent = resolvedSrc.replace(
-              `${path20.sep}src${path20.sep}`,
-              `${path20.sep}dist${path20.sep}`
+              `${path21.sep}src${path21.sep}`,
+              `${path21.sep}dist${path21.sep}`
             );
             if (fs19.existsSync(distEquivalent)) {
-              const relative10 = path20.relative(srcDir, distEquivalent);
+              const relative10 = path21.relative(srcDir, distEquivalent);
               const posixRelative = relative10.replace(/\\/g, "/");
               const normalized = posixRelative.startsWith(".") ? posixRelative : `./${posixRelative}`;
               return `from '${normalized}'`;
@@ -68433,7 +68430,7 @@ var dev_exports = {};
 __export(dev_exports, {
   devCommand: () => devCommand
 });
-import * as path21 from "path";
+import * as path22 from "path";
 import * as fs20 from "fs";
 function timestamp3() {
   const now = /* @__PURE__ */ new Date();
@@ -68448,7 +68445,7 @@ function cycleSeparator(file) {
   logger.log(`
   ${logger.dim(`\u2500\u2500\u2500 ${ts5} ${pad2}`)}`);
   if (file) {
-    logger.log(`  ${logger.dim("File changed:")} ${path21.basename(file)}`);
+    logger.log(`  ${logger.dim("File changed:")} ${path22.basename(file)}`);
   }
 }
 function parseParams(options) {
@@ -68460,7 +68457,7 @@ function parseParams(options) {
     }
   }
   if (options.paramsFile) {
-    const paramsFilePath = path21.resolve(options.paramsFile);
+    const paramsFilePath = path22.resolve(options.paramsFile);
     if (!fs20.existsSync(paramsFilePath)) {
       throw new Error(`Params file not found: ${paramsFilePath}`);
     }
@@ -68540,7 +68537,7 @@ async function compileAndRun(filePath, params, options) {
   }
 }
 async function devCommand(input, options = {}) {
-  const filePath = path21.resolve(input);
+  const filePath = path22.resolve(input);
   if (!fs20.existsSync(filePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
@@ -68557,7 +68554,7 @@ async function devCommand(input, options = {}) {
   const params = parseParams(options);
   if (!options.json) {
     logger.section("Dev Mode");
-    logger.info(`File: ${path21.basename(filePath)}`);
+    logger.info(`File: ${path22.basename(filePath)}`);
     if (Object.keys(params).length > 0) {
       logger.info(`Params: ${JSON.stringify(params)}`);
     }
@@ -68816,10 +68813,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path54) {
-  if (!path54)
+function getElementAtPath(obj, path55) {
+  if (!path55)
     return obj;
-  return path54.reduce((acc, key) => acc?.[key], obj);
+  return path55.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys2 = Object.keys(promisesObj);
@@ -69068,11 +69065,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path54, issues) {
+function prefixIssues(path55, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path54);
+    iss.path.unshift(path55);
     return iss;
   });
 }
@@ -69289,7 +69286,7 @@ var init_errors6 = __esm({
 });
 
 // node_modules/zod/v4/core/parse.js
-var _parse, parse3, _parseAsync, parseAsync, _safeParse, safeParse, _safeParseAsync, safeParseAsync;
+var _parse, parse2, _parseAsync, parseAsync, _safeParse, safeParse, _safeParseAsync, safeParseAsync;
 var init_parse2 = __esm({
   "node_modules/zod/v4/core/parse.js"() {
     init_core();
@@ -69308,7 +69305,7 @@ var init_parse2 = __esm({
       }
       return result.value;
     };
-    parse3 = /* @__PURE__ */ _parse($ZodRealError);
+    parse2 = /* @__PURE__ */ _parse($ZodRealError);
     _parseAsync = (_Err) => async (schema2, value, _ctx, params) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
       let result = schema2._zod.run({ value, issues: [] }, ctx);
@@ -72573,7 +72570,7 @@ var init_schemas2 = __esm({
         throw new Error("Uninitialized schema in ZodMiniType.");
       $ZodType.init(inst, def);
       inst.def = def;
-      inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
+      inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
       inst.safeParse = (data, params) => safeParse(inst, data, params);
       inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
       inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
@@ -72897,12 +72894,12 @@ var init_errors7 = __esm({
 });
 
 // node_modules/zod/v4/classic/parse.js
-var parse4, parseAsync2, safeParse3, safeParseAsync3;
+var parse3, parseAsync2, safeParse3, safeParseAsync3;
 var init_parse4 = __esm({
   "node_modules/zod/v4/classic/parse.js"() {
     init_core2();
     init_errors7();
-    parse4 = /* @__PURE__ */ _parse(ZodRealError);
+    parse3 = /* @__PURE__ */ _parse(ZodRealError);
     parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
     safeParse3 = /* @__PURE__ */ _safeParse(ZodRealError);
     safeParseAsync3 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -73132,7 +73129,7 @@ var init_schemas3 = __esm({
         reg.add(inst, meta);
         return inst;
       });
-      inst.parse = (data, params) => parse4(inst, data, params, { callee: inst.parse });
+      inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
       inst.safeParse = (data, params) => safeParse3(inst, data, params);
       inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
       inst.safeParseAsync = async (data, params) => safeParseAsync3(inst, data, params);
@@ -80878,8 +80875,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path54) {
-      let input = path54;
+    function removeDotSegments(path55) {
+      let input = path55;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -81078,8 +81075,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path54, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path54 && path54 !== "/" ? path54 : void 0;
+        const [path55, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path55 && path55 !== "/" ? path55 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -81231,24 +81228,24 @@ var require_fast_uri = __commonJS({
     function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse5(uri, options), options);
+        serialize(parse4(uri, options), options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse5(serialize(uri, options), options);
+        parse4(serialize(uri, options), options);
       }
       return uri;
     }
     function resolve38(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse5(baseURI, schemelessOptions), parse5(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative10, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse5(serialize(base, options), options);
-        relative10 = parse5(serialize(relative10, options), options);
+        base = parse4(serialize(base, options), options);
+        relative10 = parse4(serialize(relative10, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative10.scheme) {
@@ -81300,13 +81297,13 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       if (typeof uriA === "string") {
         uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse5(uriA, options), true), { ...options, skipEscape: true });
+        uriA = serialize(normalizeComponentEncoding(parse4(uriA, options), true), { ...options, skipEscape: true });
       } else if (typeof uriA === "object") {
         uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
       }
       if (typeof uriB === "string") {
         uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse5(uriB, options), true), { ...options, skipEscape: true });
+        uriB = serialize(normalizeComponentEncoding(parse4(uriB, options), true), { ...options, skipEscape: true });
       } else if (typeof uriB === "object") {
         uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
       }
@@ -81375,7 +81372,7 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse5(uri, opts) {
+    function parse4(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -81469,7 +81466,7 @@ var require_fast_uri = __commonJS({
       resolveComponent,
       equal,
       serialize,
-      parse: parse5
+      parse: parse4
     };
     module2.exports = fastUri;
     module2.exports.default = fastUri;
@@ -84441,12 +84438,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs50, exportName) {
+    function addFormats(ajv, list, fs48, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs50[f]);
+        ajv.addFormat(f, fs48[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -86123,7 +86120,7 @@ var init_response_utils = __esm({
 });
 
 // src/mcp/tools-query.ts
-import * as path22 from "path";
+import * as path23 from "path";
 function parseErrorCode(errors2) {
   if (errors2.some((e) => e.includes("[MULTIPLE_WORKFLOWS_FOUND]"))) {
     return "MULTIPLE_WORKFLOWS_FOUND";
@@ -86142,11 +86139,11 @@ function registerQueryTools(mcp) {
     },
     async (args) => {
       try {
-        const filePath = path22.resolve(args.filePath);
-        const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName, projectDir: path22.dirname(filePath) });
+        const filePath = path23.resolve(args.filePath);
+        const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName, projectDir: path23.dirname(filePath) });
         if (parseResult.errors.length > 0 && parseResult.errors.some((e) => typeof e === "string" && e.includes("No workflows found"))) {
           try {
-            const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true, projectDir: path22.dirname(filePath) });
+            const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true, projectDir: path23.dirname(filePath) });
             if (ntResult.errors.length === 0 && ntResult.ast.nodeTypes?.length > 0) {
               return makeToolResult({
                 nodeTypesOnly: true,
@@ -86191,11 +86188,11 @@ ${parseResult.errors.join("\n")}`
     },
     async (args) => {
       try {
-        const filePath = path22.resolve(args.filePath);
-        const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName, projectDir: path22.dirname(filePath) });
+        const filePath = path23.resolve(args.filePath);
+        const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName, projectDir: path23.dirname(filePath) });
         if (parseResult.errors.length > 0 && parseResult.errors.some((e) => typeof e === "string" && e.includes("No workflows found"))) {
           try {
-            const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true, projectDir: path22.dirname(filePath) });
+            const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true, projectDir: path23.dirname(filePath) });
             if (ntResult.errors.length === 0 && ntResult.ast.nodeTypes?.length > 0) {
               const count = ntResult.ast.nodeTypes.length;
               return makeToolResult({
@@ -86271,7 +86268,7 @@ ${parseResult.errors.join("\n")}`
     },
     async (args) => {
       try {
-        const filePath = path22.resolve(args.filePath);
+        const filePath = path23.resolve(args.filePath);
         const customTarget = args.target && args.target !== "typescript" ? compileTargetRegistry.get(args.target) : void 0;
         if (args.target && args.target !== "typescript") {
           if (!customTarget) {
@@ -86313,8 +86310,8 @@ ${parseResult.errors.join("\n")}`);
           });
           const outputFile = filePath.replace(/\.ts$/, `.${args.target}.ts`);
           if (args.write !== false) {
-            const fs50 = await import("fs");
-            fs50.writeFileSync(outputFile, code, "utf8");
+            const fs48 = await import("fs");
+            fs48.writeFileSync(outputFile, code, "utf8");
           }
           return makeToolResult({
             target: args.target,
@@ -86351,11 +86348,11 @@ ${parseResult.errors.join("\n")}`);
     },
     async (args) => {
       try {
-        const file1 = path22.resolve(args.file1);
-        const file2 = path22.resolve(args.file2);
+        const file1 = path23.resolve(args.file1);
+        const file2 = path23.resolve(args.file2);
         const [result1, result2] = await Promise.all([
-          parseWorkflow(file1, { workflowName: args.workflowName, projectDir: path22.dirname(file1) }),
-          parseWorkflow(file2, { workflowName: args.workflowName, projectDir: path22.dirname(file2) })
+          parseWorkflow(file1, { workflowName: args.workflowName, projectDir: path23.dirname(file1) }),
+          parseWorkflow(file2, { workflowName: args.workflowName, projectDir: path23.dirname(file2) })
         ]);
         if (result1.errors.length > 0) {
           return makeErrorResult(
@@ -86417,11 +86414,11 @@ Query types:
     },
     async (args) => {
       try {
-        const filePath = path22.resolve(args.filePath);
-        let parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName, projectDir: path22.dirname(filePath) });
+        const filePath = path23.resolve(args.filePath);
+        let parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName, projectDir: path23.dirname(filePath) });
         if (parseResult.errors.length > 0 && args.query === "node-types" && parseResult.errors.some((e) => typeof e === "string" && e.includes("No workflows found"))) {
           try {
-            const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true, projectDir: path22.dirname(filePath) });
+            const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true, projectDir: path23.dirname(filePath) });
             if (ntResult.errors.length === 0) {
               parseResult = ntResult;
             }
@@ -86516,7 +86513,7 @@ ${parseResult.errors.join("\n")}`
     },
     async (args) => {
       try {
-        const dir = path22.resolve(args.directory ?? process.cwd());
+        const dir = path23.resolve(args.directory ?? process.cwd());
         const report = runDoctorChecks(dir);
         return makeToolResult(report);
       } catch (err) {
@@ -86546,7 +86543,7 @@ var init_tools_query = __esm({
 });
 
 // src/mcp/tools-template.ts
-import * as path23 from "path";
+import * as path24 from "path";
 import * as fs21 from "fs";
 function registerTemplateTools(mcp) {
   mcp.tool(
@@ -86589,7 +86586,7 @@ function registerTemplateTools(mcp) {
     },
     async (args) => {
       try {
-        const outPath = path23.resolve(args.filePath);
+        const outPath = path24.resolve(args.filePath);
         const wt = getWorkflowTemplate2(args.template);
         if (wt) {
           const code = generateWorkflowFromTemplate(args.template, {
@@ -86679,7 +86676,7 @@ var init_registry2 = __esm({
 });
 
 // src/mcp/tools-pattern.ts
-import * as path24 from "path";
+import * as path25 from "path";
 import * as fs22 from "fs";
 function registerPatternTools(mcp) {
   mcp.tool(
@@ -86690,7 +86687,7 @@ function registerPatternTools(mcp) {
     },
     async (args) => {
       try {
-        const filePath = path24.resolve(args.filePath);
+        const filePath = path25.resolve(args.filePath);
         const patterns = listPatterns(filePath);
         return makeToolResult(patterns);
       } catch (err) {
@@ -86713,8 +86710,8 @@ function registerPatternTools(mcp) {
     },
     async (args) => {
       try {
-        const patternFilePath = path24.resolve(args.patternFile);
-        const targetFilePath = path24.resolve(args.targetFile);
+        const patternFilePath = path25.resolve(args.patternFile);
+        const targetFilePath = path25.resolve(args.targetFile);
         const annotationParser = new AnnotationParser();
         const patternResult = annotationParser.parse(patternFilePath);
         if (patternResult.patterns.length === 0) {
@@ -86779,7 +86776,7 @@ function registerPatternTools(mcp) {
     },
     async (args) => {
       try {
-        const dir = path24.resolve(args.directory);
+        const dir = path25.resolve(args.directory);
         const results = await findWorkflows(dir, args.pattern);
         return makeToolResult(results);
       } catch (err) {
@@ -86816,7 +86813,7 @@ function registerPatternTools(mcp) {
         if (!paramValidation.success) {
           return makeErrorResult("INVALID_PARAMS", paramValidation.error);
         }
-        const filePath = path24.resolve(args.filePath);
+        const filePath = path25.resolve(args.filePath);
         const sourceCode = fs22.readFileSync(filePath, "utf8");
         const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
         if (parseResult.errors.length > 0) {
@@ -87109,7 +87106,7 @@ ${parseResult.errors.join("\n")}`);
             );
           }
         }
-        const filePath = path24.resolve(args.filePath);
+        const filePath = path25.resolve(args.filePath);
         const sourceCode = fs22.readFileSync(filePath, "utf8");
         const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
         if (parseResult.errors.length > 0) {
@@ -87220,7 +87217,7 @@ ${parseResult.errors.join("\n")}`);
     },
     async (args) => {
       try {
-        const filePath = path24.resolve(args.sourceFile);
+        const filePath = path25.resolve(args.sourceFile);
         const parseResult = await parseWorkflow(filePath);
         if (parseResult.errors.length > 0) {
           return makeErrorResult("PARSE_ERROR", `Parse errors:
@@ -87236,7 +87233,7 @@ ${parseResult.errors.join("\n")}`);
           name: args.name
         });
         if (args.outputFile) {
-          const outPath = path24.resolve(args.outputFile);
+          const outPath = path25.resolve(args.outputFile);
           fs22.writeFileSync(outPath, result.patternCode, "utf8");
           return makeToolResult({
             success: true,
@@ -87281,7 +87278,7 @@ ${parseResult.errors.join("\n")}`);
         }
         const results = [];
         for (const file of files) {
-          const filePath = path24.resolve(file);
+          const filePath = path25.resolve(file);
           try {
             const sourceCode = fs22.readFileSync(filePath, "utf8");
             const parseResult = await parseWorkflow(filePath);
@@ -87582,7 +87579,7 @@ var init_executor = __esm({
 
 // src/deployment/core/adapters.ts
 import * as fs23 from "fs";
-import * as path25 from "path";
+import * as path26 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function createAdapter(source) {
   switch (source) {
@@ -87669,7 +87666,7 @@ var init_adapters = __esm({
             throw new Error(`Invalid JSON in params: ${input.params}`);
           }
         } else if (input.paramsFile) {
-          const paramsFilePath = path25.resolve(input.paramsFile);
+          const paramsFilePath = path26.resolve(input.paramsFile);
           if (!fs23.existsSync(paramsFilePath)) {
             throw new Error(`Params file not found: ${paramsFilePath}`);
           }
@@ -87695,7 +87692,7 @@ var init_adapters = __esm({
        * Extract workflow ID from file path (uses filename without extension)
        */
       extractWorkflowId(filePath) {
-        const basename21 = path25.basename(filePath, path25.extname(filePath));
+        const basename21 = path26.basename(filePath, path26.extname(filePath));
         return basename21;
       }
     };
@@ -87926,7 +87923,7 @@ var init_defaults2 = __esm({
 
 // src/deployment/config/loader.ts
 import * as fs24 from "fs";
-import * as path26 from "path";
+import * as path27 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 async function loadConfig(cliOverrides, configPath) {
   const environment = detectEnvironment(cliOverrides);
@@ -87964,7 +87961,7 @@ async function loadConfigFile(configPath) {
   }
   const cwd = process.cwd();
   for (const fileName of CONFIG_FILE_NAMES) {
-    const configFilePath = path26.join(cwd, fileName);
+    const configFilePath = path27.join(cwd, fileName);
     if (fs24.existsSync(configFilePath)) {
       return loadConfigFromPath(configFilePath);
     }
@@ -87972,11 +87969,11 @@ async function loadConfigFile(configPath) {
   return null;
 }
 async function loadConfigFromPath(filePath) {
-  const absolutePath = path26.resolve(filePath);
+  const absolutePath = path27.resolve(filePath);
   if (!fs24.existsSync(absolutePath)) {
     return null;
   }
-  const ext2 = path26.extname(absolutePath);
+  const ext2 = path27.extname(absolutePath);
   if (ext2 === ".yaml" || ext2 === ".yml") {
     try {
       const content = fs24.readFileSync(absolutePath, "utf8");
@@ -88367,8 +88364,8 @@ var init_generator = __esm({
         doc.paths["/health"] = this.generateHealthEndpoint();
         doc.paths["/workflows"] = this.generateListEndpoint();
         for (const endpoint of endpoints) {
-          const path54 = options.basePath ? `${options.basePath}${endpoint.path}` : endpoint.path;
-          doc.paths[path54] = this.generateWorkflowEndpoint(endpoint);
+          const path55 = options.basePath ? `${options.basePath}${endpoint.path}` : endpoint.path;
+          doc.paths[path55] = this.generateWorkflowEndpoint(endpoint);
         }
         return doc;
       }
@@ -88602,7 +88599,7 @@ var init_generator = __esm({
 });
 
 // src/deployment/targets/base.ts
-import * as path27 from "path";
+import * as path28 from "path";
 var BaseExportTarget, ExportTargetRegistry;
 var init_base = __esm({
   "src/deployment/targets/base.ts"() {
@@ -88653,7 +88650,7 @@ var init_base = __esm({
       createFile(outputDir, relativePath, content, type2) {
         return {
           relativePath,
-          absolutePath: path27.join(outputDir, relativePath),
+          absolutePath: path28.join(outputDir, relativePath),
           content,
           type: type2
         };
@@ -88706,7 +88703,7 @@ var init_base = __esm({
        * Get relative import path for the workflow
        */
       getWorkflowImport(workflowFile) {
-        const basename21 = path27.basename(workflowFile, path27.extname(workflowFile));
+        const basename21 = path28.basename(workflowFile, path28.extname(workflowFile));
         return `./${basename21}.js`;
       }
       /**
@@ -89473,7 +89470,7 @@ __export(deployment_exports, {
   loadConfigSync: () => loadConfigSync,
   schemaConverter: () => schemaConverter
 });
-import * as path28 from "path";
+import * as path29 from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 async function createTargetRegistry(projectDir) {
   const registry2 = new ExportTargetRegistry();
@@ -89482,7 +89479,7 @@ async function createTargetRegistry(projectDir) {
     const packages = await listInstalledPackages2(projectDir);
     for (const pkg of packages) {
       for (const def of pkg.manifest.exportTargets ?? []) {
-        const filePath = path28.join(pkg.path, def.file);
+        const filePath = path29.join(pkg.path, def.file);
         const mod = await import(pathToFileURL3(filePath).href);
         const TargetClass = def.exportName ? mod[def.exportName] : mod.default;
         registry2.register(def.name, () => new TargetClass());
@@ -89508,7 +89505,7 @@ var init_deployment = __esm({
 });
 
 // src/mcp/tools-export.ts
-import * as path29 from "path";
+import * as path30 from "path";
 import * as fs25 from "fs";
 function registerExportTools(mcp) {
   mcp.tool(
@@ -89527,8 +89524,8 @@ function registerExportTools(mcp) {
     },
     async (args) => {
       try {
-        const filePath = path29.resolve(args.filePath);
-        const outputDir = path29.resolve(args.outputDir);
+        const filePath = path30.resolve(args.filePath);
+        const outputDir = path30.resolve(args.outputDir);
         const preview = args.preview ?? false;
         const includeDocs = args.includeDocs ?? true;
         try {
@@ -89547,7 +89544,7 @@ function registerExportTools(mcp) {
         }
         let parseResult;
         try {
-          parseResult = await parseWorkflow(filePath, { nodeTypesOnly: false, projectDir: path29.dirname(filePath) });
+          parseResult = await parseWorkflow(filePath, { nodeTypesOnly: false, projectDir: path30.dirname(filePath) });
         } catch (err) {
           return makeErrorResult(
             "PARSE_ERROR",
@@ -89556,7 +89553,7 @@ function registerExportTools(mcp) {
         }
         if (parseResult.errors.length > 0) {
           try {
-            const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true, projectDir: path29.dirname(filePath) });
+            const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true, projectDir: path30.dirname(filePath) });
             if (ntResult.errors.length === 0) {
               parseResult = ntResult;
             }
@@ -89570,7 +89567,7 @@ function registerExportTools(mcp) {
           }
         }
         if (!exportTarget.generateBundle) {
-          const serviceName2 = args.serviceName || path29.basename(filePath, ".ts").replace(/[^a-zA-Z0-9-]/g, "-");
+          const serviceName2 = args.serviceName || path30.basename(filePath, ".ts").replace(/[^a-zA-Z0-9-]/g, "-");
           const artifacts2 = await exportTarget.generate({
             sourceFile: filePath,
             workflowName: args.workflows?.[0] || serviceName2,
@@ -89581,8 +89578,8 @@ function registerExportTools(mcp) {
           if (!preview) {
             await fs25.promises.mkdir(outputDir, { recursive: true });
             for (const file of artifacts2.files) {
-              const fullPath = path29.join(outputDir, file.relativePath);
-              await fs25.promises.mkdir(path29.dirname(fullPath), { recursive: true });
+              const fullPath = path30.join(outputDir, file.relativePath);
+              await fs25.promises.mkdir(path30.dirname(fullPath), { recursive: true });
               await fs25.promises.writeFile(fullPath, file.content, "utf-8");
             }
           }
@@ -89610,7 +89607,7 @@ function registerExportTools(mcp) {
         const uniqueNodeTypes = [
           ...new Map(allNodeTypes.map((nt) => [nt.name, nt])).values()
         ];
-        const serviceName = args.serviceName || path29.basename(filePath, ".ts").replace(/[^a-zA-Z0-9-]/g, "-");
+        const serviceName = args.serviceName || path30.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,
@@ -89661,8 +89658,8 @@ function registerExportTools(mcp) {
         if (!preview) {
           await fs25.promises.mkdir(outputDir, { recursive: true });
           for (const file of artifacts.files) {
-            const fullPath = path29.join(outputDir, file.relativePath);
-            await fs25.promises.mkdir(path29.dirname(fullPath), { recursive: true });
+            const fullPath = path30.join(outputDir, file.relativePath);
+            await fs25.promises.mkdir(path30.dirname(fullPath), { recursive: true });
             await fs25.promises.writeFile(fullPath, file.content, "utf-8");
           }
         }
@@ -89712,7 +89709,7 @@ var init_tools_export = __esm({
 
 // src/marketplace/manifest.ts
 import * as fs26 from "fs";
-import * as path30 from "path";
+import * as path31 from "path";
 function toManifestPort(port) {
   return {
     dataType: port.dataType,
@@ -89783,7 +89780,7 @@ function patternToManifest(pat, relativeFile) {
 }
 async function generateManifest(options) {
   const { directory, srcDir = "src", distDir = "dist" } = options;
-  const pkgPath = path30.join(directory, "package.json");
+  const pkgPath = path31.join(directory, "package.json");
   if (!fs26.existsSync(pkgPath)) {
     return {
       manifest: emptyManifest("unknown", "0.0.0"),
@@ -89792,8 +89789,8 @@ async function generateManifest(options) {
     };
   }
   const pkg = JSON.parse(fs26.readFileSync(pkgPath, "utf-8"));
-  const srcRoot = path30.join(directory, srcDir);
-  const pattern = path30.join(srcRoot, "**/*.ts").replace(/\\/g, "/");
+  const srcRoot = path31.join(directory, srcDir);
+  const pattern = path31.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();
@@ -89806,8 +89803,8 @@ async function generateManifest(options) {
     try {
       const result = parser3.parse(file);
       parsedFiles.push(file);
-      const relFromSrc = path30.relative(srcRoot, file);
-      const distRelative = path30.join(distDir, relFromSrc.replace(/\.ts$/, ".js"));
+      const relFromSrc = path31.relative(srcRoot, file);
+      const distRelative = path31.join(distDir, relFromSrc.replace(/\.ts$/, ".js"));
       for (const nt of result.nodeTypes) {
         allNodeTypes.push(nodeTypeToManifest(nt, distRelative));
       }
@@ -89853,12 +89850,12 @@ async function generateManifest(options) {
   return { manifest, parsedFiles, errors: errors2 };
 }
 function writeManifest(directory, manifest) {
-  const outPath = path30.join(directory, "flowweaver.manifest.json");
+  const outPath = path31.join(directory, "flowweaver.manifest.json");
   fs26.writeFileSync(outPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
   return outPath;
 }
 function readManifest(directory) {
-  const manifestPath = path30.join(directory, "flowweaver.manifest.json");
+  const manifestPath = path31.join(directory, "flowweaver.manifest.json");
   if (!fs26.existsSync(manifestPath)) return null;
   return JSON.parse(fs26.readFileSync(manifestPath, "utf-8"));
 }
@@ -89882,7 +89879,7 @@ var init_manifest = __esm({
 
 // src/marketplace/validator.ts
 import * as fs27 from "fs";
-import * as path31 from "path";
+import * as path32 from "path";
 function issue2(code, severity, message) {
   return { code, severity, message };
 }
@@ -89927,7 +89924,7 @@ function validatePackageJson(pkg, directory) {
   if (pkg.private === true) {
     issues.push(issue2("PKG-004", "error", 'Package must not be "private: true"'));
   }
-  if (!fs27.existsSync(path31.join(directory, "README.md"))) {
+  if (!fs27.existsSync(path32.join(directory, "README.md"))) {
     issues.push(issue2("PKG-007", "warning", "README.md should exist"));
   }
   return issues;
@@ -90002,7 +89999,7 @@ function validateManifestContents(manifest) {
 async function validateWorkflows(manifest, directory) {
   const issues = [];
   for (const wf of manifest.workflows) {
-    const srcFile = path31.join(
+    const srcFile = path32.join(
       directory,
       wf.file.replace(/^dist\//, "src/").replace(/\.js$/, ".ts")
     );
@@ -90026,7 +90023,7 @@ async function validateWorkflows(manifest, directory) {
   return issues;
 }
 async function validatePackage(directory, manifest) {
-  const pkgPath = path31.join(directory, "package.json");
+  const pkgPath = path32.join(directory, "package.json");
   if (!fs27.existsSync(pkgPath)) {
     return {
       valid: false,
@@ -90201,7 +90198,7 @@ var init_tools_marketplace = __esm({
 
 // src/mcp/tools-diagram.ts
 import * as fs28 from "fs";
-import * as path32 from "path";
+import * as path33 from "path";
 function registerDiagramTools(mcp) {
   mcp.tool(
     "fw_diagram",
@@ -90237,7 +90234,7 @@ function registerDiagramTools(mcp) {
             result = sourceToSVG(args.source, diagramOptions);
           }
         } else {
-          const resolvedPath = path32.resolve(args.filePath);
+          const resolvedPath = path33.resolve(args.filePath);
           if (!fs28.existsSync(resolvedPath)) {
             return makeErrorResult("FILE_NOT_FOUND", `File not found: ${resolvedPath}`);
           }
@@ -90250,7 +90247,7 @@ function registerDiagramTools(mcp) {
           }
         }
         if (args.outputPath) {
-          const outputResolved = path32.resolve(args.outputPath);
+          const outputResolved = path33.resolve(args.outputPath);
           fs28.writeFileSync(outputResolved, result, "utf-8");
           return makeToolResult({ written: outputResolved, size: result.length });
         }
@@ -90355,7 +90352,7 @@ var init_tools_docs = __esm({
 
 // src/mcp/tools-model.ts
 import * as fs29 from "fs";
-import * as path33 from "path";
+import * as path34 from "path";
 function findDeclareFunction(source, functionName) {
   const lines = source.split("\n");
   const startPattern = new RegExp(`^(\\s*)declare\\s+function\\s+${escapeRegex2(functionName)}\\s*\\(`);
@@ -90386,7 +90383,7 @@ function registerModelTools(mcp) {
     },
     async (args) => {
       try {
-        const outputPath = path33.resolve(args.filePath);
+        const outputPath = path34.resolve(args.filePath);
         const lines = [];
         for (const step of args.steps) {
           lines.push("/** @flowWeaver node */");
@@ -90414,7 +90411,7 @@ function registerModelTools(mcp) {
         lines.push(...jsdocLines);
         lines.push("");
         const content = lines.join("\n");
-        const dir = path33.dirname(outputPath);
+        const dir = path34.dirname(outputPath);
         if (!fs29.existsSync(dir)) {
           fs29.mkdirSync(dir, { recursive: true });
         }
@@ -90442,7 +90439,7 @@ function registerModelTools(mcp) {
     },
     async (args) => {
       try {
-        const filePath = path33.resolve(args.filePath);
+        const filePath = path34.resolve(args.filePath);
         const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
         if (parseResult.errors.length > 0) {
           return makeErrorResult("PARSE_ERROR", `Parse errors:
@@ -90511,7 +90508,7 @@ ${parseResult.errors.join("\n")}`);
     },
     async (args) => {
       try {
-        const filePath = path33.resolve(args.filePath);
+        const filePath = path34.resolve(args.filePath);
         if (!fs29.existsSync(filePath)) {
           return makeErrorResult("FILE_NOT_FOUND", `File not found: ${args.filePath}`);
         }
@@ -90838,7 +90835,7 @@ var init_debug_controller = __esm({
 
 // src/runtime/checkpoint.ts
 import * as fs30 from "fs";
-import * as path34 from "path";
+import * as path35 from "path";
 import * as crypto from "crypto";
 function isUnserializableMarker(value) {
   return typeof value === "object" && value !== null && value.__fw_unserializable__ === true;
@@ -90894,7 +90891,7 @@ function loadCheckpoint(checkpointPath, workflowFilePath) {
   }
   let stale = false;
   if (workflowFilePath) {
-    const currentHash = hashFile(path34.resolve(workflowFilePath));
+    const currentHash = hashFile(path35.resolve(workflowFilePath));
     stale = currentHash !== data.workflowHash;
   }
   const unsafeSet = new Set(data.unsafeNodes);
@@ -90920,12 +90917,12 @@ function loadCheckpoint(checkpointPath, workflowFilePath) {
   return { data, stale, rerunNodes, skipNodes };
 }
 function findLatestCheckpoint(workflowFilePath, workflowName) {
-  const dir = path34.join(path34.dirname(path34.resolve(workflowFilePath)), ".fw-checkpoints");
+  const dir = path35.join(path35.dirname(path35.resolve(workflowFilePath)), ".fw-checkpoints");
   if (!fs30.existsSync(dir)) return null;
   const files = fs30.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: fs30.statSync(path34.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-  return path34.join(dir, sorted[0].name);
+  const sorted = files.map((f) => ({ name: f, mtime: fs30.statSync(path35.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  return path35.join(dir, sorted[0].name);
 }
 var CheckpointWriter;
 var init_checkpoint = __esm({
@@ -90941,12 +90938,12 @@ var init_checkpoint = __esm({
       checkpointPath;
       writeLock = Promise.resolve();
       constructor(workflowFilePath, workflowName, runId, params = {}) {
-        this.filePath = path34.resolve(workflowFilePath);
+        this.filePath = path35.resolve(workflowFilePath);
         this.workflowName = workflowName;
         this.runId = runId;
         this.params = params;
-        this.dir = path34.join(path34.dirname(this.filePath), ".fw-checkpoints");
-        this.checkpointPath = path34.join(this.dir, `${workflowName}-${runId}.json`);
+        this.dir = path35.join(path35.dirname(this.filePath), ".fw-checkpoints");
+        this.checkpointPath = path35.join(this.dir, `${workflowName}-${runId}.json`);
         this.workflowHash = hashFile(this.filePath);
       }
       /**
@@ -91095,10 +91092,10 @@ var init_debug_session = __esm({
 });
 
 // src/mcp/tools-debug.ts
-import * as path35 from "path";
+import * as path36 from "path";
 import * as fs31 from "fs";
 async function getExecutionOrder(filePath, workflowName) {
-  const source = fs31.readFileSync(path35.resolve(filePath), "utf8");
+  const source = fs31.readFileSync(path36.resolve(filePath), "utf8");
   const parsed = await parseWorkflow(source, { workflowName });
   if (parsed.errors.length > 0) {
     throw new Error(`Failed to parse workflow: ${parsed.errors.join(", ")}`);
@@ -91685,7 +91682,7 @@ Only reveal TypeScript when the user explicitly asks: "show me the code", "let m
 });
 
 // src/mcp/pack-tools.ts
-import * as path36 from "path";
+import * as path37 from "path";
 function compareVersions(a, b) {
   const pa = a.split(".").map(Number);
   const pb = b.split(".").map(Number);
@@ -91723,7 +91720,7 @@ async function registerPackMcpTools(mcp) {
     const manifest = pkg.manifest;
     if (!manifest.mcpEntrypoint || !manifest.mcpTools?.length) continue;
     checkPackEngineVersion(pkg);
-    const entrypointPath = path36.join(pkg.path, manifest.mcpEntrypoint);
+    const entrypointPath = path37.join(pkg.path, manifest.mcpEntrypoint);
     try {
       const mod = await import(entrypointPath);
       if (typeof mod.registerMcpTools === "function") {
@@ -91812,10 +91809,10 @@ __export(create_exports, {
   createWorkflowCommand: () => createWorkflowCommand
 });
 import * as fs32 from "fs";
-import * as path37 from "path";
+import * as path38 from "path";
 function insertIntoFile(filePath, content, line) {
   if (!fs32.existsSync(filePath)) {
-    const dir = path37.dirname(filePath);
+    const dir = path38.dirname(filePath);
     if (!fs32.existsSync(dir)) {
       fs32.mkdirSync(dir, { recursive: true });
     }
@@ -91843,12 +91840,10 @@ async function createWorkflowCommand(template, file, options = {}) {
   } = options;
   const templateDef = getWorkflowTemplate(template);
   if (!templateDef) {
-    logger.error(`Unknown workflow template: ${template}`);
-    logger.info("Run 'fw templates' to see available templates");
-    process.exit(1);
+    throw new Error(`Unknown workflow template: ${template}. Run 'fw templates' to see available templates`);
   }
-  const filePath = path37.resolve(file);
-  const baseName = path37.basename(filePath, path37.extname(filePath));
+  const filePath = path38.resolve(file);
+  const baseName = path38.basename(filePath, path38.extname(filePath));
   const workflowName = options.name || toCamelCase(baseName);
   const config2 = {};
   if (provider) config2.provider = provider;
@@ -91860,8 +91855,7 @@ async function createWorkflowCommand(template, file, options = {}) {
     try {
       Object.assign(config2, JSON.parse(configJson));
     } catch {
-      logger.error("Invalid --config JSON");
-      process.exit(1);
+      throw new Error("Invalid --config JSON");
     }
   }
   const code = templateDef.generate({
@@ -91881,27 +91875,23 @@ async function createWorkflowCommand(template, file, options = {}) {
     }
     logger.info(`  Workflow function: ${workflowName}`);
   } catch (error2) {
-    logger.error(`Failed to create workflow: ${getErrorMessage(error2)}`);
-    process.exit(1);
+    throw new Error(`Failed to create workflow: ${getErrorMessage(error2)}`);
   }
 }
 async function createNodeCommand(name, file, options = {}) {
   const { line, template = "processor", preview = false, strategy, config: configJson } = options;
   const templateDef = getNodeTemplate(template);
   if (!templateDef) {
-    logger.error(`Unknown node template: ${template}`);
-    logger.info("Run 'fw templates' to see available templates");
-    process.exit(1);
+    throw new Error(`Unknown node template: ${template}. Run 'fw templates' to see available templates`);
   }
-  const filePath = path37.resolve(file);
+  const filePath = path38.resolve(file);
   const config2 = {};
   if (strategy) config2.strategy = strategy;
   if (configJson) {
     try {
       Object.assign(config2, JSON.parse(configJson));
     } catch {
-      logger.error("Invalid --config JSON");
-      process.exit(1);
+      throw new Error("Invalid --config JSON");
     }
   }
   const nodeName = toCamelCase(name);
@@ -91919,8 +91909,7 @@ async function createNodeCommand(name, file, options = {}) {
     }
     logger.info(`  Node function: ${nodeName}`);
   } catch (error2) {
-    logger.error(`Failed to create node: ${getErrorMessage(error2)}`);
-    process.exit(1);
+    throw new Error(`Failed to create node: ${getErrorMessage(error2)}`);
   }
 }
 var init_create = __esm({
@@ -91944,13 +91933,13 @@ __export(modify_exports, {
   modifySetPositionCommand: () => modifySetPositionCommand
 });
 import * as fs33 from "fs";
-import * as path38 from "path";
+import * as path39 from "path";
 async function readParseModifyWrite(file, operation, params) {
   const validation = validateModifyParams(operation, params);
   if (!validation.success) {
     throw new Error(validation.error);
   }
-  const filePath = path38.resolve(file);
+  const filePath = path39.resolve(file);
   const source = fs33.readFileSync(filePath, "utf-8");
   const parseResult = await parseWorkflow(filePath);
   if (parseResult.errors.length > 0) {
@@ -91959,7 +91948,7 @@ ${parseResult.errors.join("\n")}`);
   }
   const { ast: modifiedAST, warnings } = applyModifyOperation(parseResult.ast, operation, params);
   const result = generateInPlace(source, modifiedAST);
-  fs33.writeFileSync(filePath, result.code, "utf-8");
+  safeWriteFile(filePath, result.code);
   for (const w of warnings) {
     logger.warn(w);
   }
@@ -92003,6 +91992,7 @@ var init_modify = __esm({
     init_generate_in_place();
     init_modify_operation();
     init_logger();
+    init_safe_write();
   }
 });
 
@@ -92079,7 +92069,6 @@ var grammar_exports = {};
 __export(grammar_exports, {
   grammarCommand: () => grammarCommand
 });
-import * as fs34 from "fs";
 async function grammarCommand(options = {}) {
   const defaultFormat = options.output ? "html" : process.stdout.isTTY ? "ebnf" : "html";
   const { format = defaultFormat, output } = options;
@@ -92099,14 +92088,13 @@ async function grammarCommand(options = {}) {
       content = generateGrammarDiagrams();
     }
     if (output) {
-      fs34.writeFileSync(output, content, "utf-8");
+      safeWriteFile(output, content);
       logger.success(`Grammar written to ${output}`);
     } else {
       process.stdout.write(content);
     }
   } catch (error2) {
-    logger.error(`Grammar generation failed: ${getErrorMessage(error2)}`);
-    process.exit(1);
+    throw new Error(`Grammar generation failed: ${getErrorMessage(error2)}`);
   }
 }
 var init_grammar = __esm({
@@ -92115,6 +92103,7 @@ var init_grammar = __esm({
     init_grammar_diagrams();
     init_logger();
     init_error_utils();
+    init_safe_write();
   }
 });
 
@@ -92125,13 +92114,13 @@ __export(pattern_exports, {
   patternExtractCommand: () => patternExtractCommand,
   patternListCommand: () => patternListCommand
 });
-import * as fs35 from "fs";
-import * as path39 from "path";
+import * as fs34 from "fs";
+import * as path40 from "path";
 async function patternListCommand(inputPath, options) {
-  if (!fs35.existsSync(inputPath)) {
+  if (!fs34.existsSync(inputPath)) {
     throw new Error(`Path not found: ${inputPath}`);
   }
-  const stat = fs35.statSync(inputPath);
+  const stat = fs34.statSync(inputPath);
   let files;
   if (stat.isDirectory()) {
     files = await glob("**/*.ts", { cwd: inputPath, absolute: true });
@@ -92166,7 +92155,7 @@ async function patternListCommand(inputPath, options) {
     if (description) {
       logger.info(description);
     }
-    logger.info(`File: ${path39.relative(process.cwd(), file)}`);
+    logger.info(`File: ${path40.relative(process.cwd(), file)}`);
     if (inputPorts.length > 0) {
       logger.info("Input ports:");
       for (const port of inputPorts) {
@@ -92200,7 +92189,7 @@ async function patternApplyCommand(patternFile, targetFile, options) {
   } else {
     pattern = patternResult.patterns[0];
   }
-  const targetContent = fs35.readFileSync(targetFile, "utf8");
+  const targetContent = fs34.readFileSync(targetFile, "utf8");
   const targetResult = parser2.parse(targetFile);
   const existingNodeTypes = new Set(targetResult.nodeTypes.map((nt) => nt.name));
   const result = applyPattern({
@@ -92232,7 +92221,7 @@ async function patternApplyCommand(patternFile, targetFile, options) {
     }
     return;
   }
-  fs35.writeFileSync(targetFile, result.modifiedContent);
+  safeWriteFile(targetFile, result.modifiedContent);
   logger.success(`Applied pattern "${pattern.name}" to ${targetFile}`);
   if (result.nodeTypesAdded.length > 0) {
     logger.info(`Added node types: ${result.nodeTypesAdded.join(", ")}`);
@@ -92270,7 +92259,7 @@ async function patternExtractCommand(sourceFile, options) {
     console.log(result.patternCode);
     return;
   }
-  fs35.writeFileSync(options.output, result.patternCode);
+  safeWriteFile(options.output, result.patternCode);
   logger.success(`Extracted pattern "${result.patternName}" to ${options.output}`);
   logger.info(`Included nodes: ${result.nodes.join(", ")}`);
   logger.info(`Input ports: ${result.inputPorts.join(", ") || "none"}`);
@@ -92283,6 +92272,7 @@ var init_pattern2 = __esm({
     init_esm5();
     init_parser2();
     init_logger();
+    init_safe_write();
     init_patterns();
     parser2 = new AnnotationParser();
   }
@@ -92294,11 +92284,11 @@ __export(run_exports, {
   runCommand: () => runCommand2,
   validateMockConfig: () => validateMockConfig
 });
-import * as path40 from "path";
-import * as fs36 from "fs";
+import * as path41 from "path";
+import * as fs35 from "fs";
 import * as readline8 from "readline";
 function displayPath2(filePath) {
-  const rel = path40.relative(process.cwd(), filePath);
+  const rel = path41.relative(process.cwd(), filePath);
   if (rel && !rel.startsWith("..") && rel.length < filePath.length) {
     return rel;
   }
@@ -92317,8 +92307,8 @@ async function runCommand2(input, options) {
   await runCommandInner(input, options);
 }
 async function runCommandInner(input, options) {
-  const filePath = path40.resolve(input);
-  if (!fs36.existsSync(filePath)) {
+  const filePath = path41.resolve(input);
+  if (!fs35.existsSync(filePath)) {
     throw new Error(`File not found: ${displayPath2(filePath)}`);
   }
   let params = {};
@@ -92329,12 +92319,12 @@ async function runCommandInner(input, options) {
       throw new Error(`Invalid JSON in --params: ${options.params}`);
     }
   } else if (options.paramsFile) {
-    const paramsFilePath = path40.resolve(options.paramsFile);
-    if (!fs36.existsSync(paramsFilePath)) {
+    const paramsFilePath = path41.resolve(options.paramsFile);
+    if (!fs35.existsSync(paramsFilePath)) {
       throw new Error(`Params file not found: ${paramsFilePath}`);
     }
     try {
-      const content = fs36.readFileSync(paramsFilePath, "utf8");
+      const content = fs35.readFileSync(paramsFilePath, "utf8");
       params = JSON.parse(content);
     } catch {
       throw new Error(`Failed to parse params file: ${options.paramsFile}`);
@@ -92348,12 +92338,12 @@ async function runCommandInner(input, options) {
       throw new Error(`Invalid JSON in --mocks: ${options.mocks}`);
     }
   } else if (options.mocksFile) {
-    const mocksFilePath = path40.resolve(options.mocksFile);
-    if (!fs36.existsSync(mocksFilePath)) {
+    const mocksFilePath = path41.resolve(options.mocksFile);
+    if (!fs35.existsSync(mocksFilePath)) {
       throw new Error(`Mocks file not found: ${mocksFilePath}`);
     }
     try {
-      const content = fs36.readFileSync(mocksFilePath, "utf8");
+      const content = fs35.readFileSync(mocksFilePath, "utf8");
       mocks = JSON.parse(content);
     } catch {
       throw new Error(`Failed to parse mocks file: ${options.mocksFile}`);
@@ -92423,7 +92413,7 @@ async function runCommandInner(input, options) {
     if (useDebug) {
       let executionOrder = resumeExecutionOrder;
       if (!executionOrder) {
-        const source = fs36.readFileSync(filePath, "utf8");
+        const source = fs35.readFileSync(filePath, "utf8");
         const parsed = await parseWorkflow(source, { workflowName: options.workflow });
         if (parsed.errors.length === 0) {
           executionOrder = getTopologicalOrder(parsed.ast);
@@ -92945,7 +92935,7 @@ var init_run = __esm({
 });
 
 // src/server/workflow-registry.ts
-import * as fs37 from "fs";
+import * as fs36 from "fs";
 var WorkflowRegistry;
 var init_workflow_registry = __esm({
   "src/server/workflow-registry.ts"() {
@@ -92986,7 +92976,7 @@ var init_workflow_registry = __esm({
         this.endpoints.clear();
         for (const file of files) {
           try {
-            const content = fs37.readFileSync(file, "utf8");
+            const content = fs36.readFileSync(file, "utf8");
             if (!content.includes("@flowWeaver")) {
               continue;
             }
@@ -93391,14 +93381,14 @@ var serve_exports = {};
 __export(serve_exports, {
   serveCommand: () => serveCommand
 });
-import * as path41 from "path";
-import * as fs38 from "fs";
+import * as path42 from "path";
+import * as fs37 from "fs";
 async function serveCommand(dir, options) {
-  const workflowDir = path41.resolve(dir || ".");
-  if (!fs38.existsSync(workflowDir)) {
+  const workflowDir = path42.resolve(dir || ".");
+  if (!fs37.existsSync(workflowDir)) {
     throw new Error(`Directory not found: ${workflowDir}`);
   }
-  if (!fs38.statSync(workflowDir).isDirectory()) {
+  if (!fs37.statSync(workflowDir).isDirectory()) {
     throw new Error(`Not a directory: ${workflowDir}`);
   }
   const port = options.port ?? 3e3;
@@ -93448,8 +93438,8 @@ var init_serve = __esm({
 });
 
 // src/export/index.ts
-import * as path42 from "path";
-import * as fs39 from "fs";
+import * as path43 from "path";
+import * as fs38 from "fs";
 import * as os2 from "os";
 async function exportWorkflow(options) {
   const { createTargetRegistry: createTargetRegistry2 } = await Promise.resolve().then(() => (init_deployment(), deployment_exports));
@@ -93461,8 +93451,8 @@ async function exportWorkflow(options) {
       available.length === 0 ? `No export targets installed. Install a target pack (e.g. npm install flow-weaver-pack-${options.target})` : `Unknown target "${options.target}". Installed: ${available.join(", ")}`
     );
   }
-  const inputPath = path42.resolve(options.input);
-  const outputDir = path42.resolve(options.output);
+  const inputPath = path43.resolve(options.input);
+  const outputDir = path43.resolve(options.output);
   const isDryRun = options.dryRun ?? false;
   if (options.multi) {
     return exportMultiWorkflowViaRegistry(
@@ -93482,11 +93472,11 @@ async function exportWorkflow(options) {
   );
 }
 async function exportSingleWorkflowViaRegistry(target, inputPath, outputDir, isDryRun, options) {
-  if (!fs39.existsSync(inputPath)) {
+  if (!fs38.existsSync(inputPath)) {
     throw new Error(`Input file not found: ${inputPath}`);
   }
   const parser3 = new AnnotationParser();
-  const projectDir = path42.dirname(inputPath);
+  const projectDir = path43.dirname(inputPath);
   await parser3.loadPackHandlers(projectDir);
   const parseResult = parser3.parse(inputPath);
   if (parseResult.workflows.length === 0) {
@@ -93516,8 +93506,8 @@ async function exportSingleWorkflowViaRegistry(target, inputPath, outputDir, isD
   );
   let compiledContent;
   if (needsCompiledWorkflow) {
-    const workDir = isDryRun ? path42.join(os2.tmpdir(), `fw-export-dryrun-${Date.now()}`) : outputDir;
-    fs39.mkdirSync(workDir, { recursive: true });
+    const workDir = isDryRun ? path43.join(os2.tmpdir(), `fw-export-dryrun-${Date.now()}`) : outputDir;
+    fs38.mkdirSync(workDir, { recursive: true });
     try {
       const compiledPath = await compileToOutput(
         inputPath,
@@ -93525,29 +93515,29 @@ async function exportSingleWorkflowViaRegistry(target, inputPath, outputDir, isD
         workDir,
         options.production
       );
-      compiledContent = fs39.readFileSync(compiledPath, "utf8");
+      compiledContent = fs38.readFileSync(compiledPath, "utf8");
     } finally {
       if (isDryRun) {
         try {
-          fs39.rmSync(workDir, { recursive: true, force: true });
+          fs38.rmSync(workDir, { recursive: true, force: true });
         } catch {
         }
       }
     }
   }
   const files = artifacts.files.map((f) => ({
-    path: path42.join(outputDir, f.relativePath),
+    path: path43.join(outputDir, f.relativePath),
     content: f.content
   }));
   if (compiledContent) {
-    const workflowOutputPath = path42.join(outputDir, "workflow.ts");
+    const workflowOutputPath = path43.join(outputDir, "workflow.ts");
     files.push({ path: workflowOutputPath, content: compiledContent });
   }
   if (!isDryRun) {
     for (const file of files) {
-      const dirPath = path42.dirname(file.path);
-      fs39.mkdirSync(dirPath, { recursive: true });
-      fs39.writeFileSync(file.path, file.content, "utf-8");
+      const dirPath = path43.dirname(file.path);
+      fs38.mkdirSync(dirPath, { recursive: true });
+      fs38.writeFileSync(file.path, file.content, "utf-8");
     }
   }
   return {
@@ -93559,11 +93549,11 @@ async function exportSingleWorkflowViaRegistry(target, inputPath, outputDir, isD
   };
 }
 async function exportMultiWorkflowViaRegistry(target, inputPath, outputDir, isDryRun, options) {
-  if (!fs39.existsSync(inputPath)) {
+  if (!fs38.existsSync(inputPath)) {
     throw new Error(`Input file not found: ${inputPath}`);
   }
   const parser3 = new AnnotationParser();
-  const projectDir = path42.dirname(inputPath);
+  const projectDir = path43.dirname(inputPath);
   await parser3.loadPackHandlers(projectDir);
   const parseResult = parser3.parse(inputPath);
   if (parseResult.workflows.length === 0) {
@@ -93579,7 +93569,7 @@ async function exportMultiWorkflowViaRegistry(target, inputPath, outputDir, isDr
       throw new Error(`None of the requested workflows found. Available: ${available}`);
     }
   }
-  const serviceName = path42.basename(options.input, path42.extname(options.input)) + "-service";
+  const serviceName = path43.basename(options.input, path43.extname(options.input)) + "-service";
   const bundleWorkflows = selectedWorkflows.map((w) => ({
     name: w.name,
     functionName: w.functionName,
@@ -93604,15 +93594,15 @@ async function exportMultiWorkflowViaRegistry(target, inputPath, outputDir, isDr
   });
   const files = artifacts.files.map(
     (f) => ({
-      path: path42.join(outputDir, f.relativePath),
+      path: path43.join(outputDir, f.relativePath),
       content: f.content
     })
   );
   if (!isDryRun) {
     for (const file of files) {
-      const dirPath = path42.dirname(file.path);
-      fs39.mkdirSync(dirPath, { recursive: true });
-      fs39.writeFileSync(file.path, file.content, "utf-8");
+      const dirPath = path43.dirname(file.path);
+      fs38.mkdirSync(dirPath, { recursive: true });
+      fs38.writeFileSync(file.path, file.content, "utf-8");
     }
   }
   return {
@@ -93624,8 +93614,8 @@ async function exportMultiWorkflowViaRegistry(target, inputPath, outputDir, isDr
   };
 }
 async function compileToOutput(inputPath, functionName, outputDir, production) {
-  const outputPath = path42.join(outputDir, "workflow.ts");
-  fs39.copyFileSync(inputPath, outputPath);
+  const outputPath = path43.join(outputDir, "workflow.ts");
+  fs38.copyFileSync(inputPath, outputPath);
   await compileWorkflow(outputPath, {
     write: true,
     inPlace: true,
@@ -93684,7 +93674,7 @@ async function exportCommand(input, options) {
     input,
     output: options.output,
     workflow: options.workflow,
-    production: options.production ?? true,
+    production: options.production ?? false,
     bundle: options.bundle,
     dryRun: isDryRun,
     multi: isMulti,
@@ -93774,14 +93764,14 @@ var openapi_exports = {};
 __export(openapi_exports, {
   openapiCommand: () => openapiCommand
 });
-import * as path43 from "path";
-import * as fs40 from "fs";
+import * as path44 from "path";
+import * as fs39 from "fs";
 async function openapiCommand(dir, options) {
-  const workflowDir = path43.resolve(dir);
-  if (!fs40.existsSync(workflowDir)) {
+  const workflowDir = path44.resolve(dir);
+  if (!fs39.existsSync(workflowDir)) {
     throw new Error(`Directory not found: ${workflowDir}`);
   }
-  if (!fs40.statSync(workflowDir).isDirectory()) {
+  if (!fs39.statSync(workflowDir).isDirectory()) {
     throw new Error(`Not a directory: ${workflowDir}`);
   }
   const registry2 = new WorkflowRegistry(workflowDir);
@@ -93802,8 +93792,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 = path43.resolve(options.output);
-    fs40.writeFileSync(outputPath, spec);
+    const outputPath = path44.resolve(options.output);
+    safeWriteFile(outputPath, spec);
     logger.success(`OpenAPI specification written to ${outputPath}`);
   } else {
     process.stdout.write(spec + "\n");
@@ -93815,6 +93805,7 @@ var init_openapi = __esm({
     init_workflow_registry();
     init_generator();
     init_logger();
+    init_safe_write();
   }
 });
 
@@ -93825,8 +93816,8 @@ __export(plugin_exports, {
   pluginInitCommand: () => pluginInitCommand,
   validatePluginName: () => validatePluginName
 });
-import * as fs41 from "fs";
-import * as path44 from "path";
+import * as fs40 from "fs";
+import * as path45 from "path";
 function validatePluginName(name) {
   if (!name) return "Plugin name cannot be empty";
   if (name.length > 100) return "Plugin name must be at most 100 characters";
@@ -93951,18 +93942,18 @@ async function pluginInitCommand(name, options) {
     }
     return;
   }
-  const targetDir = path44.resolve("plugins", name);
+  const targetDir = path45.resolve("plugins", name);
   const filesCreated = [];
   const filesSkipped = [];
   for (const [relativePath, content] of Object.entries(files)) {
-    const absPath = path44.join(targetDir, relativePath);
-    const dir = path44.dirname(absPath);
-    fs41.mkdirSync(dir, { recursive: true });
-    if (fs41.existsSync(absPath) && !force) {
+    const absPath = path45.join(targetDir, relativePath);
+    const dir = path45.dirname(absPath);
+    fs40.mkdirSync(dir, { recursive: true });
+    if (fs40.existsSync(absPath) && !force) {
       filesSkipped.push(relativePath);
       continue;
     }
-    fs41.writeFileSync(absPath, content, "utf8");
+    fs40.writeFileSync(absPath, content, "utf8");
     filesCreated.push(relativePath);
   }
   logger.section("Plugin scaffolded");
@@ -93993,8 +93984,8 @@ var migrate_exports = {};
 __export(migrate_exports, {
   migrateCommand: () => migrateCommand
 });
-import * as fs42 from "fs";
-import * as path45 from "path";
+import * as fs41 from "fs";
+import * as path46 from "path";
 async function migrateCommand(globPattern, options = {}) {
   const { dryRun = false, diff = false } = options;
   const files = globSync(globPattern, { ignore: ["**/node_modules/**", "**/*.generated.ts"] });
@@ -94011,9 +94002,9 @@ async function migrateCommand(globPattern, options = {}) {
   let skippedCount = 0;
   let errorCount = 0;
   for (const file of files) {
-    const filePath = path45.resolve(file);
+    const filePath = path46.resolve(file);
     try {
-      const sourceCode = fs42.readFileSync(filePath, "utf8");
+      const sourceCode = fs41.readFileSync(filePath, "utf8");
       const parseResult = await parseWorkflow(filePath);
       if (parseResult.errors.length > 0) {
         logger.error(`  ${file}: parse errors \u2014 skipping`);
@@ -94046,7 +94037,7 @@ ${file}:`);
         migratedCount++;
         continue;
       }
-      fs42.writeFileSync(filePath, genResult.code, "utf8");
+      safeWriteFile(filePath, genResult.code);
       logger.success(`  ${file}: migrated`);
       migratedCount++;
     } catch (error2) {
@@ -94070,6 +94061,7 @@ var init_migrate = __esm({
     init_diff();
     init_registry2();
     init_logger();
+    init_safe_write();
     init_error_utils();
   }
 });
@@ -94079,16 +94071,16 @@ var status_exports = {};
 __export(status_exports, {
   statusCommand: () => statusCommand
 });
-import * as fs43 from "fs";
-import * as path46 from "path";
+import * as fs42 from "fs";
+import * as path47 from "path";
 function formatPortList(ports) {
   return Object.entries(ports).filter(([name]) => name !== "execute" && name !== "onSuccess" && name !== "onFailure").map(([name, port]) => `${name}(${port.dataType.toLowerCase()})`);
 }
 async function statusCommand(input, options = {}) {
   const { workflowName, json: json2 = false } = options;
   try {
-    const filePath = path46.resolve(input);
-    if (!fs43.existsSync(filePath)) {
+    const filePath = path47.resolve(input);
+    if (!fs42.existsSync(filePath)) {
       if (json2) {
         console.log(JSON.stringify({ error: `File not found: ${input}` }));
       } else {
@@ -94193,8 +94185,8 @@ var implement_exports = {};
 __export(implement_exports, {
   implementCommand: () => implementCommand
 });
-import * as fs44 from "fs";
-import * as path47 from "path";
+import * as fs43 from "fs";
+import * as path48 from "path";
 function findDeclareFunction2(source, functionName) {
   const lines = source.split("\n");
   const escaped = functionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -94216,16 +94208,14 @@ function findDeclareFunction2(source, functionName) {
 async function implementCommand(input, nodeName, options = {}) {
   const { workflowName, preview = false } = options;
   try {
-    const filePath = path47.resolve(input);
-    if (!fs44.existsSync(filePath)) {
-      logger.error(`File not found: ${input}`);
-      process.exit(1);
+    const filePath = path48.resolve(input);
+    if (!fs43.existsSync(filePath)) {
+      throw new Error(`File not found: ${input}`);
     }
     const parseResult = await parseWorkflow(filePath, { workflowName });
     if (parseResult.errors.length > 0) {
-      logger.error("Parse errors:");
-      parseResult.errors.forEach((e) => logger.error(`  ${e}`));
-      process.exit(1);
+      throw new Error(`Parse errors:
+${parseResult.errors.map((e) => `  ${e}`).join("\n")}`);
     }
     const ast = parseResult.ast;
     const stubNodeType = ast.nodeTypes.find(
@@ -94241,17 +94231,15 @@ async function implementCommand(input, nodeName, options = {}) {
       }
       const available = ast.nodeTypes.filter((nt) => nt.variant === "STUB").map((nt) => nt.functionName);
       if (available.length === 0) {
-        logger.error("No stub nodes found in this workflow.");
+        throw new Error("No stub nodes found in this workflow.");
       } else {
-        logger.error(`Stub node "${nodeName}" not found. Available stubs: ${available.join(", ")}`);
+        throw new Error(`Stub node "${nodeName}" not found. Available stubs: ${available.join(", ")}`);
       }
-      process.exit(1);
     }
-    const source = fs44.readFileSync(filePath, "utf8");
+    const source = fs43.readFileSync(filePath, "utf8");
     const found = findDeclareFunction2(source, stubNodeType.functionName);
     if (!found) {
-      logger.error(`Could not find "declare function ${stubNodeType.functionName}" in source file.`);
-      process.exit(1);
+      throw new Error(`Could not find "declare function ${stubNodeType.functionName}" in source file.`);
     }
     const implementedType = { ...stubNodeType, variant: "FUNCTION" };
     const signatureLines = generateFunctionSignature(implementedType);
@@ -94262,12 +94250,11 @@ async function implementCommand(input, nodeName, options = {}) {
       console.log(replacement);
     } else {
       const updated = source.replace(found.match, replacement);
-      fs44.writeFileSync(filePath, updated, "utf8");
-      logger.success(`Implemented ${stubNodeType.functionName} in ${path47.basename(filePath)}`);
+      safeWriteFile(filePath, updated);
+      logger.success(`Implemented ${stubNodeType.functionName} in ${path48.basename(filePath)}`);
     }
   } catch (error2) {
-    logger.error(`Implement failed: ${getErrorMessage(error2)}`);
-    process.exit(1);
+    throw new Error(`Implement failed: ${getErrorMessage(error2)}`);
   }
 }
 var init_implement = __esm({
@@ -94277,6 +94264,7 @@ var init_implement = __esm({
     init_annotation_generator();
     init_logger();
     init_error_utils();
+    init_safe_write();
   }
 });
 
@@ -94415,8 +94403,7 @@ __export(docs_exports, {
 async function docsListCommand(options) {
   const topics = listTopics();
   if (topics.length === 0) {
-    logger.error("No documentation topics found.");
-    process.exit(1);
+    throw new Error("No documentation topics found.");
   }
   if (options.json) {
     process.stdout.write(JSON.stringify({ topics }, null, 2) + "\n");
@@ -94437,16 +94424,14 @@ async function docsReadCommand(topic, options) {
   if (options.json) {
     const structured = readTopicStructured(topic);
     if (!structured) {
-      logger.error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
-      process.exit(1);
+      throw new Error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
     }
     process.stdout.write(JSON.stringify(structured, null, 2) + "\n");
     return;
   }
   const doc = readTopic(topic, options.compact);
   if (!doc) {
-    logger.error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
-    process.exit(1);
+    throw new Error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
   }
   process.stdout.write(doc.content + "\n");
 }
@@ -94496,7 +94481,6 @@ var context_exports = {};
 __export(context_exports, {
   contextCommand: () => contextCommand
 });
-import * as fs45 from "fs";
 async function contextCommand(preset, options) {
   if (options.list) {
     logger.section("Context Presets");
@@ -94513,15 +94497,13 @@ async function contextCommand(preset, options) {
   }
   const presetName = preset ?? "core";
   if (!PRESET_NAMES.includes(presetName) && !options.topics) {
-    logger.error(
+    throw new Error(
       `Unknown preset "${preset}". Available: ${PRESET_NAMES.join(", ")}. Or use --topics to specify topics directly.`
     );
-    process.exit(1);
   }
   const profile = options.profile ?? "standalone";
   if (profile !== "standalone" && profile !== "assistant") {
-    logger.error(`Unknown profile "${profile}". Use "standalone" or "assistant".`);
-    process.exit(1);
+    throw new Error(`Unknown profile "${profile}". Use "standalone" or "assistant".`);
   }
   const result = buildContext({
     preset: PRESET_NAMES.includes(presetName) ? presetName : "core",
@@ -94531,7 +94513,7 @@ async function contextCommand(preset, options) {
     includeGrammar: options.grammar !== false
   });
   if (options.output) {
-    fs45.writeFileSync(options.output, result.content, "utf-8");
+    safeWriteFile(options.output, result.content);
     logger.success(`Context written to ${options.output}`);
   } else {
     process.stdout.write(result.content);
@@ -94545,6 +94527,7 @@ var init_context2 = __esm({
     "use strict";
     init_context();
     init_logger();
+    init_safe_write();
   }
 });
 
@@ -94558,8 +94541,8 @@ __export(market_exports, {
   marketPublishCommand: () => marketPublishCommand,
   marketSearchCommand: () => marketSearchCommand
 });
-import * as fs46 from "fs";
-import * as path48 from "path";
+import * as fs44 from "fs";
+import * as path49 from "path";
 import { execSync as execSync7 } from "child_process";
 async function marketInitCommand(name, options = {}) {
   if (!name.startsWith("flow-weaver-pack-")) {
@@ -94567,18 +94550,16 @@ async function marketInitCommand(name, options = {}) {
     logger.warn(`Name should follow "flow-weaver-pack-*" convention, using "${suggested}"`);
     name = suggested;
   }
-  const targetDir = path48.resolve(name);
-  if (fs46.existsSync(targetDir)) {
-    const stat = fs46.statSync(targetDir);
+  const targetDir = path49.resolve(name);
+  if (fs44.existsSync(targetDir)) {
+    const stat = fs44.statSync(targetDir);
     if (stat.isDirectory()) {
-      const contents = fs46.readdirSync(targetDir);
+      const contents = fs44.readdirSync(targetDir);
       if (contents.length > 0) {
-        logger.error(`Directory "${name}" already exists and is not empty`);
-        process.exit(1);
+        throw new Error(`Directory "${name}" already exists and is not empty`);
       }
     } else {
-      logger.error(`"${name}" already exists and is not a directory`);
-      process.exit(1);
+      throw new Error(`"${name}" already exists and is not a directory`);
     }
   }
   logger.section("Creating Marketplace Package");
@@ -94586,13 +94567,13 @@ async function marketInitCommand(name, options = {}) {
   logger.newline();
   const dirs = [
     targetDir,
-    path48.join(targetDir, "src"),
-    path48.join(targetDir, "src", "node-types"),
-    path48.join(targetDir, "src", "workflows"),
-    path48.join(targetDir, "src", "patterns")
+    path49.join(targetDir, "src"),
+    path49.join(targetDir, "src", "node-types"),
+    path49.join(targetDir, "src", "workflows"),
+    path49.join(targetDir, "src", "patterns")
   ];
   for (const dir of dirs) {
-    fs46.mkdirSync(dir, { recursive: true });
+    fs44.mkdirSync(dir, { recursive: true });
   }
   const shortName = name.replace(/^flow-weaver-pack-/, "");
   const pkg = {
@@ -94623,8 +94604,8 @@ async function marketInitCommand(name, options = {}) {
     },
     files: ["dist", "flowweaver.manifest.json", "README.md", "LICENSE"]
   };
-  fs46.writeFileSync(
-    path48.join(targetDir, "package.json"),
+  fs44.writeFileSync(
+    path49.join(targetDir, "package.json"),
     JSON.stringify(pkg, null, 2) + "\n"
   );
   const tsconfig = {
@@ -94642,8 +94623,8 @@ async function marketInitCommand(name, options = {}) {
     include: ["src"],
     exclude: ["node_modules", "dist"]
   };
-  fs46.writeFileSync(
-    path48.join(targetDir, "tsconfig.json"),
+  fs44.writeFileSync(
+    path49.join(targetDir, "tsconfig.json"),
     JSON.stringify(tsconfig, null, 2) + "\n"
   );
   const sampleNodeType = `/**
@@ -94661,21 +94642,21 @@ export function sample(execute: () => void, data: string): { result: string } {
   return { result: data.toUpperCase() };
 }
 `;
-  fs46.writeFileSync(path48.join(targetDir, "src", "node-types", "sample.ts"), sampleNodeType);
-  fs46.writeFileSync(
-    path48.join(targetDir, "src", "node-types", "index.ts"),
+  fs44.writeFileSync(path49.join(targetDir, "src", "node-types", "sample.ts"), sampleNodeType);
+  fs44.writeFileSync(
+    path49.join(targetDir, "src", "node-types", "index.ts"),
     "export { sample } from './sample.js';\n"
   );
-  fs46.writeFileSync(
-    path48.join(targetDir, "src", "workflows", "index.ts"),
+  fs44.writeFileSync(
+    path49.join(targetDir, "src", "workflows", "index.ts"),
     "// Export workflows here\n"
   );
-  fs46.writeFileSync(
-    path48.join(targetDir, "src", "patterns", "index.ts"),
+  fs44.writeFileSync(
+    path49.join(targetDir, "src", "patterns", "index.ts"),
     "// Export patterns here\n"
   );
-  fs46.writeFileSync(
-    path48.join(targetDir, "src", "index.ts"),
+  fs44.writeFileSync(
+    path49.join(targetDir, "src", "index.ts"),
     [
       "export * from './node-types/index.js';",
       "export * from './workflows/index.js';",
@@ -94708,9 +94689,9 @@ npm run pack    # Generate flowweaver.manifest.json
 npm publish     # Publish to npm
 \`\`\`
 `;
-  fs46.writeFileSync(path48.join(targetDir, "README.md"), readme);
-  fs46.writeFileSync(
-    path48.join(targetDir, ".gitignore"),
+  fs44.writeFileSync(path49.join(targetDir, "README.md"), readme);
+  fs44.writeFileSync(
+    path49.join(targetDir, ".gitignore"),
     ["node_modules", "dist", "*.tgz", ""].join("\n")
   );
   logger.success("Created package.json");
@@ -94730,7 +94711,7 @@ npm publish     # Publish to npm
   logger.newline();
 }
 async function marketPackCommand(directory, options = {}) {
-  const dir = path48.resolve(directory ?? ".");
+  const dir = path49.resolve(directory ?? ".");
   const { json: json2 = false, verbose = false } = options;
   if (!json2) {
     logger.section("Packing Marketplace Package");
@@ -94766,26 +94747,25 @@ async function marketPackCommand(directory, options = {}) {
   }
   if (!validation.valid) {
     logger.newline();
-    logger.error("Package validation failed. Fix errors above before publishing.");
-    process.exit(1);
+    throw new Error("Package validation failed. Fix errors above before publishing.");
   }
   const outPath = writeManifest(dir, manifest);
   logger.newline();
-  logger.success(`Manifest written to ${path48.relative(dir, outPath)}`);
+  logger.success(`Manifest written to ${path49.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 = path48.resolve(directory ?? ".");
+  const dir = path49.resolve(directory ?? ".");
   const { dryRun = false, tag } = options;
   logger.section("Publishing Marketplace Package");
   await marketPackCommand(dir, { json: false });
-  if (!fs46.existsSync(path48.join(dir, "LICENSE"))) {
+  if (!fs44.existsSync(path49.join(dir, "LICENSE"))) {
     logger.warn("LICENSE file not found \u2014 consider adding one");
   }
-  const pkg = JSON.parse(fs46.readFileSync(path48.join(dir, "package.json"), "utf-8"));
+  const pkg = JSON.parse(fs44.readFileSync(path49.join(dir, "package.json"), "utf-8"));
   logger.info(`Publishing ${pkg.name}@${pkg.version}`);
   const npmArgs = ["publish"];
   if (dryRun) npmArgs.push("--dry-run");
@@ -94798,8 +94778,7 @@ async function marketPublishCommand(directory, options = {}) {
       logger.success(`Published ${pkg.name}@${pkg.version} to npm`);
     }
   } catch (err) {
-    logger.error(`npm publish failed: ${getErrorMessage(err)}`);
-    process.exit(1);
+    throw new Error(`npm publish failed: ${getErrorMessage(err)}`);
   }
 }
 async function marketInstallCommand(packageSpec, options = {}) {
@@ -94821,7 +94800,7 @@ async function marketInstallCommand(packageSpec, options = {}) {
     return;
   }
   const packageName = resolvePackageName2(packageSpec);
-  const manifest = readManifest(path48.join(process.cwd(), "node_modules", packageName));
+  const manifest = readManifest(path49.join(process.cwd(), "node_modules", packageName));
   if (json2) {
     console.log(JSON.stringify({
       success: true,
@@ -94912,7 +94891,7 @@ async function marketListCommand(options = {}) {
 }
 function resolvePackageName2(spec) {
   if (spec.endsWith(".tgz") || spec.endsWith(".tar.gz")) {
-    const base = path48.basename(spec, spec.endsWith(".tar.gz") ? ".tar.gz" : ".tgz");
+    const base = path49.basename(spec, spec.endsWith(".tar.gz") ? ".tar.gz" : ".tgz");
     const match2 = base.match(/^(.+)-\d+\.\d+\.\d+/);
     return match2 ? match2[1] : base;
   }
@@ -94973,7 +94952,7 @@ var pack_commands_exports = {};
 __export(pack_commands_exports, {
   registerPackCommands: () => registerPackCommands
 });
-import * as path49 from "path";
+import * as path50 from "path";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 function compareVersions2(a, b) {
   const pa = a.split(".").map(Number);
@@ -95015,7 +94994,7 @@ async function registerPackCommands(program3) {
     if (!manifest.cliEntrypoint || !manifest.cliCommands?.length) continue;
     checkPackEngineVersion2(pkg);
     const namespace = deriveNamespace(pkg.name);
-    const entrypointPath = path49.join(pkg.path, manifest.cliEntrypoint);
+    const entrypointPath = path50.join(pkg.path, manifest.cliEntrypoint);
     const group = program3.command(namespace).description(`Commands from ${pkg.name}`);
     const showPackHelp = async () => {
       try {
@@ -95076,13 +95055,13 @@ var init_pack_commands = __esm({
 });
 
 // src/cli/config/credentials.ts
-import * as fs47 from "node:fs";
-import * as path50 from "node:path";
+import * as fs45 from "node:fs";
+import * as path51 from "node:path";
 import * as os3 from "node:os";
 function loadCredentials() {
-  if (!fs47.existsSync(CREDENTIALS_FILE)) return null;
+  if (!fs45.existsSync(CREDENTIALS_FILE)) return null;
   try {
-    const data = JSON.parse(fs47.readFileSync(CREDENTIALS_FILE, "utf-8"));
+    const data = JSON.parse(fs45.readFileSync(CREDENTIALS_FILE, "utf-8"));
     if (isTokenExpired(data)) return null;
     return data;
   } catch {
@@ -95090,16 +95069,16 @@ function loadCredentials() {
   }
 }
 function saveCredentials(creds) {
-  fs47.mkdirSync(FW_CONFIG_DIR, { recursive: true });
-  fs47.writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), "utf-8");
+  fs45.mkdirSync(FW_CONFIG_DIR, { recursive: true });
+  fs45.writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), "utf-8");
   try {
-    fs47.chmodSync(CREDENTIALS_FILE, 384);
+    fs45.chmodSync(CREDENTIALS_FILE, 384);
   } catch {
   }
 }
 function clearCredentials() {
   try {
-    fs47.unlinkSync(CREDENTIALS_FILE);
+    fs45.unlinkSync(CREDENTIALS_FILE);
   } catch {
   }
 }
@@ -95114,8 +95093,8 @@ var FW_CONFIG_DIR, CREDENTIALS_FILE;
 var init_credentials = __esm({
   "src/cli/config/credentials.ts"() {
     "use strict";
-    FW_CONFIG_DIR = path50.join(os3.homedir(), ".fw");
-    CREDENTIALS_FILE = path50.join(FW_CONFIG_DIR, "credentials.json");
+    FW_CONFIG_DIR = path51.join(os3.homedir(), ".fw");
+    CREDENTIALS_FILE = path51.join(FW_CONFIG_DIR, "credentials.json");
   }
 });
 
@@ -95131,14 +95110,14 @@ var init_platform_client = __esm({
         this.baseUrl = creds.platformUrl.replace(/\/+$/, "");
         this.token = creds.token;
       }
-      async fetch(path54, opts = {}) {
+      async fetch(path55, opts = {}) {
         const isApiKey = this.token.startsWith("fw_");
         const headers = {
           "Content-Type": "application/json",
           ...isApiKey ? { "X-API-Key": this.token } : { Authorization: `Bearer ${this.token}` },
           ...opts.headers ?? {}
         };
-        return fetch(`${this.baseUrl}${path54}`, { ...opts, headers });
+        return fetch(`${this.baseUrl}${path55}`, { ...opts, headers });
       }
       // Auth
       async getUser() {
@@ -95495,8 +95474,8 @@ __export(deploy_exports, {
   deployCommand: () => deployCommand,
   undeployCommand: () => undeployCommand
 });
-import * as fs48 from "node:fs";
-import * as path51 from "node:path";
+import * as fs46 from "node:fs";
+import * as path52 from "node:path";
 async function deployCommand(filePath, options = {}) {
   const creds = loadCredentials();
   if (!creds) {
@@ -95504,14 +95483,14 @@ async function deployCommand(filePath, options = {}) {
     process.exit(1);
     return;
   }
-  const absPath = path51.resolve(filePath);
-  if (!fs48.existsSync(absPath)) {
+  const absPath = path52.resolve(filePath);
+  if (!fs46.existsSync(absPath)) {
     console.error(`  \x1B[31m\u2717\x1B[0m File not found: ${filePath}`);
     process.exit(1);
     return;
   }
-  const source = fs48.readFileSync(absPath, "utf-8");
-  const name = options.name ?? path51.basename(filePath, path51.extname(filePath));
+  const source = fs46.readFileSync(absPath, "utf-8");
+  const name = options.name ?? path52.basename(filePath, path52.extname(filePath));
   const client = new PlatformClient(creds);
   console.log("");
   console.log(`  \x1B[2mPushing ${name}...\x1B[0m`);
@@ -95767,8 +95746,8 @@ __export(connect_exports, {
   handleConnect: () => handleConnect,
   loadPackDeviceHandlers: () => loadPackDeviceHandlers
 });
-import * as fs49 from "node:fs";
-import * as path52 from "node:path";
+import * as fs47 from "node:fs";
+import * as path53 from "node:path";
 import * as os4 from "node:os";
 import * as readline10 from "node:readline";
 function promptYesNo(message) {
@@ -95804,12 +95783,12 @@ async function loadPackDeviceHandlers(conn, projectDir) {
   return loadedPacks;
 }
 async function handleConnect(projectDir) {
-  const credPath = path52.join(os4.homedir(), ".fw", "credentials.json");
-  if (!fs49.existsSync(credPath)) {
+  const credPath = path53.join(os4.homedir(), ".fw", "credentials.json");
+  if (!fs47.existsSync(credPath)) {
     console.error("\n  Not logged in. Run: fw login\n");
     process.exit(1);
   }
-  const creds = JSON.parse(fs49.readFileSync(credPath, "utf-8"));
+  const creds = JSON.parse(fs47.readFileSync(credPath, "utf-8"));
   if (!creds.token || !creds.platformUrl || creds.expiresAt < Date.now()) {
     console.error("\n  Credentials expired. Run: fw login\n");
     process.exit(1);
@@ -95818,27 +95797,27 @@ async function handleConnect(projectDir) {
     platformUrl: creds.platformUrl,
     token: creds.token,
     projectDir,
-    deviceName: path52.basename(projectDir),
+    deviceName: path53.basename(projectDir),
     logger: (msg) => process.stderr.write(`  \x1B[2m${msg}\x1B[0m
 `)
   });
   conn.addCapability("file_read");
   conn.addCapability("file_list");
   conn.onRequest("file:read", async (_method, params) => {
-    const filePath = path52.resolve(projectDir, String(params.path ?? ""));
+    const filePath = path53.resolve(projectDir, String(params.path ?? ""));
     if (!filePath.startsWith(projectDir)) throw new Error("Path outside project directory");
-    if (!fs49.existsSync(filePath)) throw new Error("File not found");
-    const stat = fs49.statSync(filePath);
-    if (stat.isDirectory()) return { type: "directory", entries: fs49.readdirSync(filePath) };
+    if (!fs47.existsSync(filePath)) throw new Error("File not found");
+    const stat = fs47.statSync(filePath);
+    if (stat.isDirectory()) return { type: "directory", entries: fs47.readdirSync(filePath) };
     if (stat.size > 1048576) throw new Error("File too large (>1MB)");
-    return { type: "file", content: fs49.readFileSync(filePath, "utf-8") };
+    return { type: "file", content: fs47.readFileSync(filePath, "utf-8") };
   });
   conn.onRequest("file:list", async (_method, params) => {
-    const dirPath = path52.resolve(projectDir, String(params.path ?? "."));
+    const dirPath = path53.resolve(projectDir, String(params.path ?? "."));
     if (!dirPath.startsWith(projectDir)) throw new Error("Path outside project directory");
-    if (!fs49.existsSync(dirPath)) throw new Error("Directory not found");
-    const entries = fs49.readdirSync(dirPath, { withFileTypes: true });
-    return entries.filter((e) => !e.name.startsWith(".") && e.name !== "node_modules" && e.name !== "dist").map((e) => ({ name: e.name, type: e.isDirectory() ? "directory" : "file", path: path52.relative(projectDir, path52.join(dirPath, e.name)), hasUnfetchedChildren: e.isDirectory() }));
+    if (!fs47.existsSync(dirPath)) throw new Error("Directory not found");
+    const entries = fs47.readdirSync(dirPath, { withFileTypes: true });
+    return entries.filter((e) => !e.name.startsWith(".") && e.name !== "node_modules" && e.name !== "dist").map((e) => ({ name: e.name, type: e.isDirectory() ? "directory" : "file", path: path53.relative(projectDir, path53.join(dirPath, e.name)), hasUnfetchedChildren: e.isDirectory() }));
   });
   const loadedPacks = await loadPackDeviceHandlers(conn, projectDir);
   if (loadedPacks.length > 0) {
@@ -95846,7 +95825,7 @@ async function handleConnect(projectDir) {
   }
   console.log("");
   console.log("  \x1B[1mflow-weaver connect\x1B[0m");
-  console.log(`  \x1B[2mProject: ${path52.basename(projectDir)}\x1B[0m`);
+  console.log(`  \x1B[2mProject: ${path53.basename(projectDir)}\x1B[0m`);
   console.log(`  \x1B[2mPlatform: ${creds.platformUrl}\x1B[0m`);
   console.log("");
   if (loadedPacks.length > 0) {
@@ -95929,7 +95908,7 @@ if (process.env.FORCE_COLOR === "0") {
 }
 
 // src/cli/index.ts
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 
 // node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
@@ -95948,10 +95927,23 @@ var {
   Help
 } = import_index.default;
 
+// src/cli/utils/parse-int-strict.ts
+function parseIntStrict(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    throw new Error(`"${value}" is not a valid number`);
+  }
+  const n = Number(trimmed);
+  if (!Number.isFinite(n) || !Number.isInteger(n)) {
+    throw new Error(`"${value}" is not a valid number`);
+  }
+  return n;
+}
+
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.23.4" : "0.0.0-dev";
+var version2 = true ? "0.24.0" : "0.0.0-dev";
 var program2 = new Command();
 program2.name("fw").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);
@@ -95982,7 +95974,7 @@ function wrapAction(fn) {
     }
   };
 }
-program2.command("compile <input>").description("Compile workflow files to TypeScript").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("--dry-run", "Preview compilation without writing files", false).option("-w, --workflow <name>", "Specific workflow name to compile").addOption(new Option("-f, --format <format>", "Module format").choices(["esm", "cjs", "auto"]).default("auto")).option("--strict", "Treat type coercion warnings as errors", false).option("--inline-runtime", "Force inline runtime even when @synergenius/flow-weaver package is installed", false).option("--clean", "Omit redundant @param/@returns annotations from compiled output", false).option("--target <target>", "Compilation target: typescript (default) or a registered extension target").option("--cron <schedule>", "Set cron trigger schedule").option("--serve", "Generate serve() handler for HTTP event reception").option("--framework <name>", "Framework adapter for serve handler (next, express, hono, fastify, remix)").option("--typed-events", "Generate Zod event schemas from workflow @param annotations").option("--retries <n>", "Number of retries per function", parseInt).option("--timeout <duration>", 'Function timeout (e.g. "30m", "1h")').action(wrapAction(async (input, options) => {
+program2.command("compile <input>").description("Compile workflow files to TypeScript").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("--dry-run", "Preview compilation without writing files", false).option("-w, --workflow <name>", "Specific workflow name to compile").addOption(new Option("-f, --format <format>", "Module format").choices(["esm", "cjs", "auto"]).default("auto")).option("--strict", "Treat type coercion warnings as errors", false).option("--clean", "Omit redundant @param/@returns annotations from compiled output", false).option("--target <target>", "Compilation target: typescript (default) or a registered extension target").option("--cron <schedule>", "Set cron trigger schedule").option("--serve", "Generate serve() handler for HTTP event reception").option("--framework <name>", "Framework adapter for serve handler (next, express, hono, fastify, remix)").option("--typed-events", "Generate Zod event schemas from workflow @param annotations").option("--retries <n>", "Number of retries per function", parseIntStrict).option("--timeout <duration>", 'Function timeout (e.g. "30m", "1h")').action(wrapAction(async (input, options) => {
   const { compileCommand: compileCommand2 } = await Promise.resolve().then(() => (init_compile2(), compile_exports));
   if (options.workflow) options.workflowName = options.workflow;
   await compileCommand2(input, options);
@@ -95996,7 +95988,7 @@ program2.command("describe <input>").description("Output workflow structure in L
   if (options.workflow) options.workflowName = options.workflow;
   await describeCommand2(input, options);
 }));
-program2.command("diagram <input>").description("Generate SVG or interactive HTML diagram of a workflow").option("-t, --theme <theme>", "Color theme: dark, light", "dark").option("--width <pixels>", "SVG width in pixels").option("-p, --padding <pixels>", "Canvas padding in pixels").option("--no-port-labels", "Hide data type labels on ports").option("-w, --workflow <name>", "Specific workflow to render").addOption(new Option("-f, --format <format>", "Output format").choices(["svg", "html", "ascii", "ascii-compact", "text"]).default("svg")).option("-o, --output <file>", "Write output to file instead of stdout").action(wrapAction(async (input, options) => {
+program2.command("diagram <input>").description("Generate SVG or interactive HTML diagram of a workflow").addOption(new Option("-t, --theme <theme>", "Color theme").choices(["dark", "light"]).default("dark")).option("--width <pixels>", "SVG width in pixels").option("-p, --padding <pixels>", "Canvas padding in pixels").option("--no-port-labels", "Hide data type labels on ports").option("-w, --workflow <name>", "Specific workflow to render").addOption(new Option("-f, --format <format>", "Output format").choices(["svg", "html", "ascii", "ascii-compact", "text"]).default("svg")).option("-o, --output <file>", "Write output to file instead of stdout").action(wrapAction(async (input, options) => {
   if (options.width) options.width = Number(options.width);
   if (options.padding) options.padding = Number(options.padding);
   options.showPortLabels = options.portLabels;
@@ -96018,7 +96010,7 @@ program2.command("doctor").description("Check project environment and configurat
   const { doctorCommand: doctorCommand2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
   await doctorCommand2(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("--with-weaver", "Install Weaver AI assistant").option("--no-weaver", "Skip Weaver installation").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("--with-weaver", "Install Weaver AI assistant").option("--no-weaver", "Skip Weaver installation").option("--force", "Overwrite existing files", false).action(wrapAction(async (directory, options) => {
   const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   await initCommand2(directory, options);
 }));
@@ -96027,7 +96019,7 @@ program2.command("watch <input>").description("Watch workflow files and recompil
   if (options.workflow) options.workflowName = options.workflow;
   await watchCommand2(input, options);
 }));
-program2.command("dev <input>").description("Watch, compile, and run workflow on changes").option("--params <json>", "Input parameters as JSON string").option("--params-file <path>", "Path to JSON file with input parameters").option("-w, --workflow <name>", "Specific workflow name to run").option("-p, --production", "Run in production mode (no trace events)", false).option("-f, --format <format>", "Module format: esm, cjs, or auto", "auto").option("--clean", "Omit redundant @param/@returns annotations", false).option("--once", "Run once then exit", false).option("--json", "Output result as JSON", false).option("--target <target>", "Compilation target (default: typescript)").option("--framework <framework>", "Framework for serve handler", "express").option("--port <port>", "Port for dev server", (v) => parseInt(v, 10), 3e3).action(wrapAction(async (input, options) => {
+program2.command("dev <input>").description("Watch, compile, and run workflow on changes").option("--params <json>", "Input parameters as JSON string").option("--params-file <path>", "Path to JSON file with input parameters").option("-w, --workflow <name>", "Specific workflow name to run").option("-p, --production", "Run in production mode (no trace events)", false).option("-f, --format <format>", "Module format: esm, cjs, or auto", "auto").option("--clean", "Omit redundant @param/@returns annotations", false).option("--once", "Run once then exit", false).option("--json", "Output result as JSON", false).option("--target <target>", "Compilation target (default: typescript)").action(wrapAction(async (input, options) => {
   const { devCommand: devCommand2 } = await Promise.resolve().then(() => (init_dev(), dev_exports));
   await devCommand2(input, options);
 }));
@@ -96040,11 +96032,11 @@ program2.command("mcp-setup").description("Configure MCP server for AI coding to
   await mcpSetupCommand2(options);
 }));
 var createCmd = program2.command("create").description("Create workflows or nodes from templates");
-createCmd.command("workflow <template> <file>").description("Create a workflow from a template").option("-l, --line <number>", "Insert at specific line number", parseInt).option("-a, --async", "Generate an async workflow", false).option("-p, --preview", "Preview generated code without writing", false).option("--provider <provider>", "LLM provider (openai, anthropic, ollama, mock)").option("--model <model>", "Model identifier (e.g., gpt-4o, claude-3-5-sonnet-20241022)").option("--config <json>", "Configuration as JSON string").option("--name <name>", "Override the derived workflow function name").option("--nodes <names>", 'Comma-separated node function names (e.g., "fetch,parse,store")').option("--input <name>", 'Custom input port name (default: "data")').option("--output <name>", 'Custom output port name (default: "result")').action(wrapAction(async (template, file, options) => {
+createCmd.command("workflow <template> <file>").description("Create a workflow from a template").option("-l, --line <number>", "Insert at specific line number", parseIntStrict).option("-a, --async", "Generate an async workflow", false).option("-p, --preview", "Preview generated code without writing", false).option("--provider <provider>", "LLM provider (openai, anthropic, ollama, mock)").option("--model <model>", "Model identifier (e.g., gpt-4o, claude-3-5-sonnet-20241022)").option("--config <json>", "Configuration as JSON string").option("--name <name>", "Override the derived workflow function name").option("--nodes <names>", 'Comma-separated node function names (e.g., "fetch,parse,store")').option("--input <name>", 'Custom input port name (default: "data")').option("--output <name>", 'Custom output port name (default: "result")').action(wrapAction(async (template, file, options) => {
   const { createWorkflowCommand: createWorkflowCommand2 } = await Promise.resolve().then(() => (init_create(), create_exports));
   await createWorkflowCommand2(template, file, options);
 }));
-createCmd.command("node <name> <file>").description("Create a node type from a template").option("-l, --line <number>", "Insert at specific line number", parseInt).option("-t, --template <template>", "Node template to use", "transformer").option("-p, --preview", "Preview generated code without writing", false).option("--strategy <strategy>", "Template strategy (e.g. mock, callback, webhook)").option("--config <json>", "Additional configuration (JSON)").action(wrapAction(async (name, file, options) => {
+createCmd.command("node <name> <file>").description("Create a node type from a template").option("-l, --line <number>", "Insert at specific line number", parseIntStrict).option("-t, --template <template>", "Node template to use", "transformer").option("-p, --preview", "Preview generated code without writing", false).option("--strategy <strategy>", "Template strategy (e.g. mock, callback, webhook)").option("--config <json>", "Additional configuration (JSON)").action(wrapAction(async (name, file, options) => {
   const { createNodeCommand: createNodeCommand2 } = await Promise.resolve().then(() => (init_create(), create_exports));
   await createNodeCommand2(name, file, options);
 }));
@@ -96100,14 +96092,14 @@ patternCmd.command("extract <source-file>").description("Extract a pattern from
   const { patternExtractCommand: patternExtractCommand2 } = await Promise.resolve().then(() => (init_pattern2(), pattern_exports));
   await patternExtractCommand2(sourceFile, options);
 }));
-program2.command("run <input>").description("Execute a workflow file directly").option("-w, --workflow <name>", "Specific workflow name to run").option("--params <json>", "Input parameters as JSON string").option("--params-file <path>", "Path to JSON file with input parameters").option("-p, --production", "Production mode (no trace events)", false).option("-t, --trace", "Include execution trace events").option("-s, --stream", "Stream trace events in real-time").option("--json", "Output result as JSON", false).option("--timeout <ms>", "Execution timeout in milliseconds", parseInt).option("--mocks <json>", "Mock config for built-in nodes (events, invocations, agents, fast) as JSON").option("--mocks-file <path>", "Path to JSON file with mock config for built-in nodes").option("-d, --debug", "Start in step-through debug mode").option("--checkpoint", "Enable checkpointing to disk after each node").option("--resume [file]", "Resume from a checkpoint file (auto-detects latest if no file)").option("-b, --breakpoint <nodeIds...>", "Set initial breakpoints (repeatable)").action(wrapAction(async (input, options) => {
+program2.command("run <input>").description("Execute a workflow file directly").option("-w, --workflow <name>", "Specific workflow name to run").option("--params <json>", "Input parameters as JSON string").option("--params-file <path>", "Path to JSON file with input parameters").option("-p, --production", "Production mode (no trace events)", false).option("-t, --trace", "Include execution trace events").option("-s, --stream", "Stream trace events in real-time").option("--json", "Output result as JSON", false).option("--timeout <ms>", "Execution timeout in milliseconds", parseIntStrict).option("--mocks <json>", "Mock config for built-in nodes (events, invocations, agents, fast) as JSON").option("--mocks-file <path>", "Path to JSON file with mock config for built-in nodes").option("-d, --debug", "Start in step-through debug mode").option("--checkpoint", "Enable checkpointing to disk after each node").option("--resume [file]", "Resume from a checkpoint file (auto-detects latest if no file)").option("-b, --breakpoint <nodeIds...>", "Set initial breakpoints (repeatable)").action(wrapAction(async (input, options) => {
   const { runCommand: runCommand3 } = await Promise.resolve().then(() => (init_run(), run_exports));
   await runCommand3(input, options);
 }));
 program2.command("serve [directory]").description("Start HTTP server exposing workflows as endpoints").option("-p, --port <port>", "Server port", "3000").option("-H, --host <host>", "Server host", "0.0.0.0").option("--no-watch", "Disable file watching for hot reload").option("--production", "Production mode (no trace events)", false).option("--precompile", "Precompile all workflows on startup", false).option("--cors <origin>", "CORS origin", "*").option("--swagger", "Enable Swagger UI at /docs", false).action(wrapAction(async (directory, options) => {
   const { serveCommand: serveCommand2 } = await Promise.resolve().then(() => (init_serve(), serve_exports));
   await serveCommand2(directory, {
-    port: parseInt(options.port, 10),
+    port: parseIntStrict(options.port),
     host: options.host,
     watch: options.watch,
     production: options.production,
@@ -96116,7 +96108,7 @@ program2.command("serve [directory]").description("Start HTTP server exposing wo
     swagger: options.swagger
   });
 }));
-program2.command("export <input>").description("Export workflow as serverless function").requiredOption("-t, --target <target>", "Target platform (install target packs via marketplace)").requiredOption("-o, --output <path>", "Output directory").option("-w, --workflow <name>", "Specific workflow name to export").option("-p, --production", "Production mode", true).option("--dry-run", "Preview without writing files", false).option("--multi", "Export all workflows in file as a single multi-workflow service", false).option("--workflows <names>", "Comma-separated list of workflows to export (used with --multi)").option("--docs", "Include API documentation routes (/docs and /openapi.json)", false).option("--durable-steps", "Use deep generator with per-node durable steps", false).action(wrapAction(async (input, options) => {
+program2.command("export <input>").description("Export workflow as serverless function").requiredOption("-t, --target <target>", "Target platform (install target packs via marketplace)").requiredOption("-o, --output <path>", "Output directory").option("-w, --workflow <name>", "Specific workflow name to export").option("-p, --production", "Production mode (no debug events)", false).option("--bundle", "Bundle node types into the output", false).option("--dry-run", "Preview without writing files", false).option("--multi", "Export all workflows in file as a single multi-workflow service", false).option("--workflows <names>", "Comma-separated list of workflows to export (used with --multi)").option("--docs", "Include API documentation routes (/docs and /openapi.json)", false).option("--durable-steps", "Use deep generator with per-node durable steps", false).action(wrapAction(async (input, options) => {
   const { exportCommand: exportCommand2 } = await Promise.resolve().then(() => (init_export2(), export_exports));
   await exportCommand2(input, options);
 }));
@@ -96189,7 +96181,7 @@ marketCmd.command("install <package>").description("Install a marketplace packag
 }));
 marketCmd.command("search [query]").description("Search npm for marketplace packages").option("-l, --limit <number>", "Max results", "20").option("-r, --registry <url>", "Custom registry search URL (e.g., private npm registry)").option("--json", "Output as JSON", false).action(wrapAction(async (query, options) => {
   const { marketSearchCommand: marketSearchCommand2 } = await Promise.resolve().then(() => (init_market(), market_exports));
-  await marketSearchCommand2(query, { ...options, limit: parseInt(options.limit, 10) });
+  await marketSearchCommand2(query, { ...options, limit: parseIntStrict(options.limit) });
 }));
 marketCmd.command("list").description("List installed marketplace packages").option("--json", "Output as JSON", false).action(wrapAction(async (options) => {
   const { marketListCommand: marketListCommand2 } = await Promise.resolve().then(() => (init_market(), market_exports));
@@ -96252,7 +96244,7 @@ if (!process.env["VITEST"]) {
     });
     program2.command("connect [dir]").description("Connect this device to the Flow Weaver platform").action(async (dir) => {
       const { handleConnect: handleConnect2 } = await Promise.resolve().then(() => (init_connect(), connect_exports));
-      await handleConnect2(path53.resolve(dir ?? "."));
+      await handleConnect2(path54.resolve(dir ?? "."));
     });
     if (!program2.commands.some((c) => c.name() === "weaver")) {
       program2.command("weaver").description("AI assistant for Flow Weaver workflows").allowUnknownOption(true).action(async () => {