windmill-cli 1.691.1 → 1.692.0

package/esm/main.js

@@ -16224,6 +16224,14 @@ var execFile5, __dirname2, localXdgOpenPath, platform, arch, pTryEach = async (a
   }
   subprocess.unref();
   return subprocess;
+}, open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
 }, openApp = (name, options) => {
   if (typeof name !== "string" && !Array.isArray(name)) {
     throw new TypeError("Expected a valid `name`");
@@ -16239,7 +16247,7 @@ var execFile5, __dirname2, localXdgOpenPath, platform, arch, pTryEach = async (a
       arguments: appArguments
     }
   });
-}, apps;
+}, apps, open_default;
 var init_open = __esm(() => {
   init_wsl_utils();
   init_default_browser();
@@ -16285,6 +16293,7 @@ var init_open = __esm(() => {
   }));
   defineLazyProperty(apps, "browser", () => "browser");
   defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+  open_default = open;
 });
 
 // node_modules/@cliffy/prompt/secret.js
@@ -16408,7 +16417,7 @@ async function browserLogin(baseUrl) {
     const url = `${baseUrl}user/cli?port=${port}`;
     info(`Login by going to ${url}`);
     try {
-      openApp(apps.browser, { arguments: [url] }).catch((error2) => {
+      open_default(url).catch((error2) => {
         console.error(`Failed to open browser, please navigate to ${url}, error: ${error2}`);
       });
       info("Opened browser for you");
@@ -16701,7 +16710,7 @@ var init_OpenAPI = __esm(() => {
     PASSWORD: undefined,
     TOKEN: getEnv3("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: "1.691.1",
+    VERSION: "1.692.0",
     WITH_CREDENTIALS: true,
     interceptors: {
       request: new Interceptors,
@@ -26226,9 +26235,6 @@ function getFolderSuffixes() {
 function getFolderSuffix(type) {
   return getFolderSuffixes()[type];
 }
-function getFolderSuffixWithSep(type) {
-  return getFolderSuffixes()[type] + SEP2;
-}
 function getMetadataFileName(type, format6) {
   return METADATA_FILES[type][format6];
 }
@@ -30232,6 +30238,74 @@ return schema
   rawAppWmillTs_exports = /* @__PURE__ */ __export2({ default: () => rawAppWmillTs_default }, 1);
 });
 
+// src/utils/port-probe.ts
+import { createServer as createServer2 } from "node:net";
+import { execSync as execSync4 } from "node:child_process";
+function isPortFree(port, host) {
+  return new Promise((resolve6) => {
+    const s = createServer2();
+    s.once("error", (err) => {
+      const code2 = err.code ?? "";
+      resolve6(code2 !== "EADDRINUSE" && code2 !== "EACCES");
+    });
+    s.once("listening", () => s.close(() => resolve6(true)));
+    s.listen(port, host);
+  });
+}
+async function isPortFreeOnBothStacks(port) {
+  if (!await isPortFree(port, "0.0.0.0"))
+    return false;
+  if (!await isPortFree(port, "::"))
+    return false;
+  return true;
+}
+function findPortHolder(port) {
+  try {
+    const out = execSync4(`lsof -nP -iTCP:${port} -sTCP:LISTEN -F pc 2>/dev/null`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    let pid;
+    let cmd;
+    for (const line of out.split(`
+`)) {
+      if (line.startsWith("p"))
+        pid = parseInt(line.slice(1), 10);
+      else if (line.startsWith("c"))
+        cmd = line.slice(1);
+      if (pid && cmd)
+        return { pid, command: cmd };
+    }
+  } catch {}
+  try {
+    const out = execSync4(`ss -ltnp 2>/dev/null | awk '$4 ~ /:${port}$/ { print $NF }'`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const m = out.match(/\("([^"]+)",pid=(\d+)/);
+    if (m)
+      return { pid: parseInt(m[2], 10), command: m[1] };
+  } catch {}
+  return;
+}
+async function resolveBindPort(requested, flagLabel, log) {
+  const MAX_SHIFT = 20;
+  for (let port = requested;port < requested + MAX_SHIFT; port++) {
+    if (await isPortFreeOnBothStacks(port)) {
+      if (port !== requested) {
+        const holder = findPortHolder(requested);
+        const holderHint = holder ? ` (held by PID ${holder.pid} \`${holder.command}\`)` : "";
+        log.warn(`Port ${requested} is already in use${holderHint}. Using port ${port} instead.`);
+        log.info(`If you need port ${requested} stable (e.g. a launch.json entry pinned to it), stop the holder and re-run with ${flagLabel} ${requested}.`);
+      }
+      return port;
+    }
+  }
+  throw new Error(`Could not find a free port in the range ${requested}-${requested + MAX_SHIFT - 1}. Stop a holder or pass ${flagLabel} <other>.`);
+}
+var BIND_HOST = "0.0.0.0";
+var init_port_probe = () => {};
+
 // node_modules/ws/lib/stream.js
 var require_stream = __commonJS((exports, module) => {
   var { Duplex } = __require("stream");
@@ -30296,7 +30370,7 @@ var require_stream = __commonJS((exports, module) => {
     };
     duplex._final = function(callback) {
       if (ws.readyState === ws.CONNECTING) {
-        ws.once("open", function open() {
+        ws.once("open", function open2() {
           duplex._final(callback);
         });
         return;
@@ -30320,7 +30394,7 @@ var require_stream = __commonJS((exports, module) => {
     };
     duplex._write = function(chunk, encoding, callback) {
       if (ws.readyState === ws.CONNECTING) {
-        ws.once("open", function open() {
+        ws.once("open", function open2() {
           duplex._write(chunk, encoding, callback);
         });
         return;
@@ -34923,10 +34997,10 @@ globstar while`, file, fr, pattern, pr, swallowee);
       }
       return filtered.join("/");
     }).join("|");
-    const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
-    re = "^" + open + re + close + "$";
+    const [open2, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+    re = "^" + open2 + re + close + "$";
     if (this.partial) {
-      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
+      re = "^(?:\\/|" + open2 + re.slice(1, -1) + close + ")$";
     }
     if (this.negate)
       re = "^(?!" + re + ").+$";
@@ -61383,7 +61457,7 @@ import { Buffer as Buffer4 } from "node:buffer";
 import { sep as SEP4 } from "node:path";
 import * as path7 from "node:path";
 import fs8 from "node:fs";
-import { execSync as execSync4 } from "node:child_process";
+import { execSync as execSync5 } from "node:child_process";
 function isRawAppBackendPath2(filePath) {
   return isRawAppBackendPath(filePath);
 }
@@ -61484,7 +61558,7 @@ async function handleFile(path8, workspace, alreadySynced, message, opts, rawWor
       let outputFiles = [];
       if (codebase.customBundler) {
         info(`Using custom bundler ${codebase.customBundler} for ${path8}`);
-        bundleContent = execSync4(codebase.customBundler + " " + path8, {
+        bundleContent = execSync5(codebase.customBundler + " " + path8, {
           maxBuffer: 1024 * 1024 * 50
         }).toString();
         info("Custom bundler executed for " + path8);
@@ -62177,7 +62251,7 @@ async function preview(opts, filePath) {
       if (!opts.silent) {
         info(`Using custom bundler ${codebase.customBundler} for preview`);
       }
-      bundledContent = execSync4(codebase.customBundler + " " + filePath, {
+      bundledContent = execSync5(codebase.customBundler + " " + filePath, {
         maxBuffer: 52428800
       }).toString();
     } else {
@@ -68608,10 +68682,14 @@ async function dev(opts, appFolder) {
   const rawApp = await yamlParseFile(rawAppPath);
   const appPath = rawApp?.custom_path ?? "u/unknown/newapp";
   const esbuild = await import("esbuild");
-  const port = opts.port ?? await getPorts({
+  const host = opts.host ?? DEFAULT_HOST;
+  const probeBothStacks = host === DEFAULT_HOST;
+  const port = opts.port !== undefined ? probeBothStacks ? await resolveBindPort(opts.port, "--port", {
+    info: (m) => info(m),
+    warn: (m) => warn(m)
+  }) : opts.port : await getPorts({
     port: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map((p) => p + DEFAULT_PORT)
   });
-  const host = opts.host ?? DEFAULT_HOST;
   const shouldOpen = opts.open ?? true;
   const frameworks = detectFrameworks(process16.cwd());
   const defaultEntry = frameworks.svelte || frameworks.vue ? "index.ts" : "index.tsx";
@@ -69714,6 +69792,7 @@ var init_dev = __esm(async () => {
   init_log();
   init_lib_es();
   init_get_port();
+  init_port_probe();
   init_open();
   init_wrapper();
   init_services_gen();
@@ -69880,8 +69959,9 @@ var init_lint2 = __esm(async () => {
 });
 
 // src/commands/app/new.ts
-import { stat as stat9, writeFile as writeFile10, mkdir as mkdir7 } from "node:fs/promises";
+import { stat as stat9, writeFile as writeFile10, mkdir as mkdir7, rm as rm3 } from "node:fs/promises";
 import path17 from "node:path";
+import { execSync as execSync6, exec, execFile as execFile6 } from "node:child_process";
 function validateAppPath(appPath) {
   if (!appPath.startsWith("u/") && !appPath.startsWith("f/")) {
     return {
@@ -69948,16 +70028,25 @@ async function newApp(opts) {
     const errorMessage = error2 instanceof Error ? error2.message : String(error2);
     warn(colors.yellow(`Could not fetch datatables: ${errorMessage}`));
   }
-  const summary = await Input.prompt({
-    message: "App summary (short description):",
-    minLength: 1,
-    validate: (value) => {
-      if (value.trim().length === 0) {
-        return "Summary cannot be empty";
-      }
-      return true;
+  let summary;
+  if (opts.summary !== undefined) {
+    if (opts.summary.trim().length === 0) {
+      error(colors.red("--summary cannot be empty"));
+      return;
     }
-  });
+    summary = opts.summary;
+  } else {
+    summary = await Input.prompt({
+      message: "App summary (short description):",
+      minLength: 1,
+      validate: (value) => {
+        if (value.trim().length === 0) {
+          return "Summary cannot be empty";
+        }
+        return true;
+      }
+    });
+  }
   const buildPathSuggestions = (input) => {
     const suggestions = [];
     if (input.length < 2) {
@@ -69974,27 +70063,46 @@ async function newApp(opts) {
     return suggestions;
   };
   let appPath;
-  while (true) {
-    appPath = await Input.prompt({
-      message: "App path (e.g., f/my_folder/my_app or u/username/my_app):",
-      minLength: 1,
-      suggestions: buildPathSuggestions
-    });
-    const validation = validateAppPath(appPath);
-    if (validation.valid) {
-      break;
+  if (opts.path !== undefined) {
+    const validation = validateAppPath(opts.path);
+    if (!validation.valid) {
+      error(colors.red(`Invalid --path: ${validation.error}`));
+      return;
+    }
+    appPath = opts.path;
+  } else {
+    while (true) {
+      appPath = await Input.prompt({
+        message: "App path (e.g., f/my_folder/my_app or u/username/my_app):",
+        minLength: 1,
+        suggestions: buildPathSuggestions
+      });
+      const validation = validateAppPath(appPath);
+      if (validation.valid) {
+        break;
+      }
+      error(colors.red(`Invalid path: ${validation.error}`));
     }
-    error(colors.red(`Invalid path: ${validation.error}`));
   }
-  const framework = await Select.prompt({
-    message: "Select a framework:",
-    options: [
-      { name: "React 19 (Recommended)", value: "react19" },
-      { name: "React 18", value: "react18" },
-      { name: "Svelte 5", value: "svelte5" },
-      { name: "Vue 3", value: "vue" }
-    ]
-  });
+  const VALID_FRAMEWORKS = ["react19", "react18", "svelte5", "vue"];
+  let framework;
+  if (opts.framework !== undefined) {
+    if (!VALID_FRAMEWORKS.includes(opts.framework)) {
+      error(colors.red(`Invalid --framework: ${opts.framework}. Must be one of: ${VALID_FRAMEWORKS.join(", ")}`));
+      return;
+    }
+    framework = opts.framework;
+  } else {
+    framework = await Select.prompt({
+      message: "Select a framework:",
+      options: [
+        { name: "React 19 (Recommended)", value: "react19" },
+        { name: "React 18", value: "react18" },
+        { name: "Svelte 5", value: "svelte5" },
+        { name: "Vue 3", value: "vue" }
+      ]
+    });
+  }
   const template = templates[framework];
   if (!template) {
     error(colors.red(`Unknown framework: ${framework}`));
@@ -70003,7 +70111,29 @@ async function newApp(opts) {
   let dataConfig = {};
   let createSchemaSQL;
   let schemaName;
-  if (datatables.length > 0) {
+  const nonInteractive = opts.summary !== undefined || opts.path !== undefined || opts.framework !== undefined;
+  if (opts.datatable !== undefined) {
+    if (datatables.length > 0 && !datatables.includes(opts.datatable)) {
+      warn(colors.yellow(`--datatable '${opts.datatable}' is not in the workspace's datatable list (${datatables.join(", ")}). Continuing anyway.`));
+    }
+    dataConfig.datatable = opts.datatable;
+    if (opts.schema !== undefined) {
+      if (!/^[a-z_][a-z0-9_]*$/.test(opts.schema)) {
+        error(colors.red(`--schema must start with a letter or underscore and contain only lowercase letters, numbers, and underscores: ${opts.schema}`));
+        return;
+      }
+      schemaName = opts.schema;
+      dataConfig.schema = schemaName;
+      const existingSchemas = datatableSchemas.get(opts.datatable) ?? [];
+      if (!existingSchemas.includes(schemaName)) {
+        createSchemaSQL = `-- Create schema for ${summary}
+-- This will be executed when you run 'wmill app dev' and confirm in the modal
+CREATE SCHEMA IF NOT EXISTS ${schemaName};
+`;
+      }
+    }
+    dataConfig.tables = [];
+  } else if (nonInteractive) {} else if (datatables.length > 0) {
     info("");
     info(colors.bold.cyan("Data Configuration"));
     info(colors.gray("Configure datatables to enable AI to create and query database tables."));
@@ -70087,17 +70217,29 @@ CREATE SCHEMA IF NOT EXISTS ${schemaName};
   await loadNonDottedPathsSetting();
   const folderName2 = buildFolderPath(appPath, "raw_app");
   const appDir = path17.join(process.cwd(), folderName2);
+  let dirExists = false;
   try {
     await stat9(appDir);
-    const overwrite = await Confirm.prompt({
-      message: `Directory '${folderName2}' already exists. Overwrite?`,
-      default: false
-    });
-    if (!overwrite) {
-      info(colors.yellow("Aborted."));
+    dirExists = true;
+  } catch {}
+  if (dirExists) {
+    if (opts.overwrite) {
+      warn(colors.yellow(`Overwriting existing '${folderName2}' (--overwrite)`));
+    } else if (nonInteractive) {
+      error(colors.red(`Directory '${folderName2}' already exists. Pass --overwrite to replace it.`));
       return;
+    } else {
+      const overwrite = await Confirm.prompt({
+        message: `Directory '${folderName2}' already exists. Overwrite?`,
+        default: false
+      });
+      if (!overwrite) {
+        info(colors.yellow("Aborted."));
+        return;
+      }
     }
-  } catch {}
+    await rm3(appDir, { recursive: true, force: true });
+  }
   await mkdir7(appDir, { recursive: true });
   await mkdir7(path17.join(appDir, "backend"), { recursive: true });
   await mkdir7(path17.join(appDir, "sql_to_apply"), { recursive: true });
@@ -70202,6 +70344,69 @@ This folder is for SQL migration files that will be applied to datatables during
   }
   info("");
   info(colors.gray("  4. wmill sync push (to deploy when ready)"));
+  let hasClaudeDesktop = false;
+  if (process.platform === "darwin") {
+    try {
+      execSync6("ls /Applications/Claude.app", { stdio: "ignore" });
+      hasClaudeDesktop = true;
+    } catch {}
+  }
+  if (hasClaudeDesktop && !nonInteractive && opts.openInDesktop !== false) {
+    info("");
+    const openInDesktop = await Confirm.prompt({
+      message: "Open in Claude Desktop?",
+      default: true
+    });
+    if (openInDesktop) {
+      try {
+        const absAppDir = path17.resolve(appDir);
+        const claudeDir = path17.join(absAppDir, ".claude");
+        const launchPath = path17.join(claudeDir, "launch.json");
+        if (!await stat9(launchPath).catch(() => null)) {
+          const launchJson = JSON.stringify({
+            version: "0.0.1",
+            configurations: [{
+              name: `windmill: ${appPath}`,
+              runtimeExecutable: "bash",
+              runtimeArgs: ["-c", "wmill app dev --no-open --port ${PORT:-4000}"],
+              port: 4000,
+              autoPort: true
+            }]
+          }, null, 2) + `
+`;
+          await mkdir7(claudeDir, { recursive: true });
+          await writeFile10(launchPath, launchJson, "utf-8");
+          info(colors.gray(`Seeded ${path17.relative(process.cwd(), launchPath)}`));
+        }
+        const sessionId = crypto.randomUUID();
+        const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        let i = 0;
+        const spinner = setInterval(() => {
+          process.stdout.write(`\r${colors.gray(`${frames[i++ % frames.length]} Creating Claude session...`)}`);
+        }, 80);
+        try {
+          await new Promise((resolve8, reject) => {
+            exec(`claude --session-id "${sessionId}" -p "Say: Your app is ready, click on preview to test it!"`, { cwd: absAppDir }, (error2) => error2 ? reject(error2) : resolve8());
+          });
+        } finally {
+          clearInterval(spinner);
+          process.stdout.write("\r" + " ".repeat(40) + "\r");
+        }
+        const deepLink = `claude://resume?session=${sessionId}&cwd=${encodeURIComponent(absAppDir)}`;
+        execFile6("open", [deepLink], (err) => {
+          if (err) {
+            warn(colors.yellow(`Could not open Claude Desktop deep link (${err.message}). Open it manually: ${deepLink}`));
+          } else {
+            info(colors.bold.green("Opened in Claude Desktop!"));
+          }
+        });
+      } catch (error2) {
+        const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+        warn(colors.yellow(`Could not open in Claude Desktop: ${errorMessage}`));
+        info(colors.gray("You can manually run: cd " + folderName2 + " && claude"));
+      }
+    }
+  }
 }
 var import_yaml22, reactIndex = `
 import React from 'react'
@@ -70272,7 +70477,18 @@ const msg = ref('world');
 import App from './App.vue'
 import "./index.css";
 
-createApp(App).mount('#root')`, indexCss = `.myclass {
+createApp(App).mount('#root')`, indexCss = `body {
+    margin: 0;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background-color: #f5f5f5;
+    color: #1a1a1a;
+}
+
+#root {
+    padding: 24px;
+}
+
+.myclass {
     border: 1px solid gray;
     padding: 2px;
 }`, templates, command11, new_default;
@@ -70360,7 +70576,7 @@ var init_new = __esm(async () => {
       }
     }
   };
-  command11 = new Command().description("create a new raw app from a template").action(newApp);
+  command11 = new Command().description("create a new raw app from a template").option("--summary <summary:string>", "App summary (short description). Skips the prompt when provided. Triggers non-interactive mode.").option("--path <path:string>", "App path (e.g., f/folder/my_app or u/username/my_app). Skips the prompt when provided. Triggers non-interactive mode.").option("--framework <framework:string>", "Framework template: react19 | react18 | svelte5 | vue. Skips the prompt when provided. Triggers non-interactive mode.").option("--datatable <datatable:string>", "Datatable to wire up. Without this flag in non-interactive mode, no datatable is configured.").option("--schema <schema:string>", "Schema to use with --datatable. Created (CREATE SCHEMA IF NOT EXISTS) if it doesn't already exist.").option("--overwrite", "Overwrite the target directory if it already exists, without prompting.").option("--no-open-in-desktop", "Do not prompt to open the new app in Claude Desktop.").action(newApp);
   new_default = command11;
 });
 
@@ -71826,7 +72042,7 @@ var init_settings = __esm(async () => {
 });
 
 // src/commands/instance/instance.ts
-import { writeFile as writeFile15, readdir as readdir9, mkdir as mkdir11, rm as rm3, stat as stat14 } from "node:fs/promises";
+import { writeFile as writeFile15, readdir as readdir9, mkdir as mkdir11, rm as rm4, stat as stat14 } from "node:fs/promises";
 import { appendFile } from "node:fs/promises";
 import * as path18 from "node:path";
 async function allInstances() {
@@ -72092,7 +72308,7 @@ Pulling workspace ` + remoteWorkspace.id);
       if (confirmDelete) {
         for (const workspace of localWorkspacesToDelete) {
           await removeWorkspace(workspace.id, false, {});
-          await rm3(path18.join(rootDir, workspace.dir), {
+          await rm4(path18.join(rootDir, workspace.dir), {
             recursive: true
           });
         }
@@ -74176,6 +74392,10 @@ async function bootstrap2(opts, flowPath) {
   const metadataFile = getMetadataFileName("flow", "yaml");
   const flowYamlPath = `${flowDirFullPath}/${metadataFile}`;
   writeFileSync6(flowYamlPath, newFlowDefinitionYaml, { flag: "wx", encoding: "utf-8" });
+  info(colors.green(`Created flow at ${flowDirFullPath}`));
+  info("");
+  info(colors.bold("To preview this flow:"));
+  info(colors.gray(`  wmill dev --path ${flowPath}`));
 }
 async function history2(opts, flowPath) {
   if (opts.json)
@@ -75224,22 +75444,22 @@ var init_gitsync_settings = __esm(async () => {
 async function uploadScripts(tree, workspace) {
   const scriptHashes = {};
   const workspaceDeps = [];
-  for (const path20 of tree.allPaths()) {
-    const content = tree.getContent(path20);
-    const itemType = tree.getItemType(path20);
+  for (const path21 of tree.allPaths()) {
+    const content = tree.getContent(path21);
+    const itemType = tree.getItemType(path21);
     if (itemType === "dependencies") {
       if (content === undefined)
         continue;
-      const info2 = workspaceDependenciesPathToLanguageAndFilename(path20);
+      const info2 = workspaceDependenciesPathToLanguageAndFilename(path21);
       if (info2) {
         const hash2 = await generateHash(content);
-        workspaceDeps.push({ path: path20, language: info2.language, name: info2.name, hash: hash2 });
+        workspaceDeps.push({ path: path21, language: info2.language, name: info2.name, hash: hash2 });
       }
     } else if (itemType === "script") {
       if (!content)
         continue;
       const hash2 = await generateHash(content);
-      scriptHashes[path20] = hash2;
+      scriptHashes[path21] = hash2;
     }
   }
   if (Object.keys(scriptHashes).length === 0 && workspaceDeps.length === 0)
@@ -75251,19 +75471,19 @@ async function uploadScripts(tree, workspace) {
       workspace_deps: workspaceDeps
     }
   });
-  for (const path20 of mismatched) {
-    const content = tree.getContent(path20);
-    const itemType = tree.getItemType(path20);
+  for (const path21 of mismatched) {
+    const content = tree.getContent(path21);
+    const itemType = tree.getItemType(path21);
     if (itemType === "dependencies") {
       if (content !== undefined) {
-        tree.setContentHash(path20, "mismatched");
+        tree.setContentHash(path21, "mismatched");
       }
     } else if (content) {
       const hash2 = await storeRawScriptTemp({
         workspace: workspace.workspaceId,
         requestBody: content
       });
-      tree.setContentHash(path20, hash2);
+      tree.setContentHash(path21, hash2);
     }
   }
 }
@@ -75274,12 +75494,12 @@ class DoubleLinkedDependencyTree {
   setWorkspaceDeps(deps) {
     this.workspaceDeps = deps;
   }
-  async addNode(path20, content, language, metadata, imports, itemType, folder, originalPath, isDirectlyStale, isRawApp) {
+  async addNode(path21, content, language, metadata, imports, itemType, folder, originalPath, isDirectlyStale, isRawApp) {
     const hasWorkspaceDeps = itemType === "script" || itemType === "inline_script";
     const filteredDeps = hasWorkspaceDeps ? filterWorkspaceDependencies(this.workspaceDeps, content, language) : {};
     const stalenessHash = await generateScriptHash({}, content, metadata);
-    if (!this.nodes.has(path20)) {
-      this.nodes.set(path20, {
+    if (!this.nodes.has(path21)) {
+      this.nodes.set(path21, {
         content: "",
         stalenessHash: "",
         language: "deno",
@@ -75292,7 +75512,7 @@ class DoubleLinkedDependencyTree {
         isDirectlyStale: false
       });
     }
-    const node = this.nodes.get(path20);
+    const node = this.nodes.get(path21);
     node.content = content;
     node.stalenessHash = stalenessHash;
     node.language = language;
@@ -75339,59 +75559,59 @@ class DoubleLinkedDependencyTree {
           isDirectlyStale: false
         });
       }
-      this.nodes.get(importPath).importedBy.add(path20);
+      this.nodes.get(importPath).importedBy.add(path21);
     }
   }
-  getContent(path20) {
-    return this.nodes.get(path20)?.content;
+  getContent(path21) {
+    return this.nodes.get(path21)?.content;
   }
-  getStalenessHash(path20) {
-    return this.nodes.get(path20)?.stalenessHash;
+  getStalenessHash(path21) {
+    return this.nodes.get(path21)?.stalenessHash;
   }
-  getContentHash(path20) {
-    return this.nodes.get(path20)?.contentHash;
+  getContentHash(path21) {
+    return this.nodes.get(path21)?.contentHash;
   }
-  setContentHash(path20, hash2) {
-    const node = this.nodes.get(path20);
+  setContentHash(path21, hash2) {
+    const node = this.nodes.get(path21);
     if (node) {
       node.contentHash = hash2;
     }
   }
-  getLanguage(path20) {
-    return this.nodes.get(path20)?.language;
+  getLanguage(path21) {
+    return this.nodes.get(path21)?.language;
   }
-  getMetadata(path20) {
-    return this.nodes.get(path20)?.metadata;
+  getMetadata(path21) {
+    return this.nodes.get(path21)?.metadata;
   }
-  getStaleReason(path20) {
-    return this.nodes.get(path20)?.staleReason;
+  getStaleReason(path21) {
+    return this.nodes.get(path21)?.staleReason;
   }
-  getItemType(path20) {
-    return this.nodes.get(path20)?.itemType;
+  getItemType(path21) {
+    return this.nodes.get(path21)?.itemType;
   }
-  getFolder(path20) {
-    return this.nodes.get(path20)?.folder;
+  getFolder(path21) {
+    return this.nodes.get(path21)?.folder;
   }
-  getIsRawApp(path20) {
-    return this.nodes.get(path20)?.isRawApp;
+  getIsRawApp(path21) {
+    return this.nodes.get(path21)?.isRawApp;
   }
-  getIsDirectlyStale(path20) {
-    return this.nodes.get(path20)?.isDirectlyStale ?? false;
+  getIsDirectlyStale(path21) {
+    return this.nodes.get(path21)?.isDirectlyStale ?? false;
   }
-  getOriginalPath(path20) {
-    return this.nodes.get(path20)?.originalPath;
+  getOriginalPath(path21) {
+    return this.nodes.get(path21)?.originalPath;
   }
-  getImports(path20) {
-    return this.nodes.get(path20)?.imports;
+  getImports(path21) {
+    return this.nodes.get(path21)?.imports;
   }
-  isStale(path20) {
-    return this.nodes.get(path20)?.staleReason !== undefined;
+  isStale(path21) {
+    return this.nodes.get(path21)?.staleReason !== undefined;
   }
   propagateStaleness() {
     const directlyStale = new Set;
-    for (const [path20, node] of this.nodes.entries()) {
+    for (const [path21, node] of this.nodes.entries()) {
       if (node.isDirectlyStale) {
-        directlyStale.add(path20);
+        directlyStale.add(path21);
         node.staleReason = "content changed";
       }
     }
@@ -75443,20 +75663,20 @@ class DoubleLinkedDependencyTree {
     return this.nodes.keys();
   }
   *stalePaths() {
-    for (const [path20, node] of this.nodes.entries()) {
+    for (const [path21, node] of this.nodes.entries()) {
       if (node.staleReason) {
-        yield path20;
+        yield path21;
       }
     }
   }
-  has(path20) {
-    return this.nodes.has(path20);
+  has(path21) {
+    return this.nodes.has(path21);
   }
   getMismatchedWorkspaceDeps() {
     const result2 = {};
-    for (const [path20, node] of this.nodes.entries()) {
+    for (const [path21, node] of this.nodes.entries()) {
       if (node.itemType === "dependencies" && node.contentHash && node.content !== undefined) {
-        result2[path20] = node.content;
+        result2[path21] = node.content;
       }
     }
     return result2;
@@ -75471,11 +75691,11 @@ class DoubleLinkedDependencyTree {
     return result2;
   }
   async persistDepsHashes(depsPaths) {
-    for (const path20 of depsPaths) {
-      const node = this.nodes.get(path20);
+    for (const path21 of depsPaths) {
+      const node = this.nodes.get(path21);
       if (node?.itemType === "dependencies" && node.content !== undefined) {
-        const hash2 = await generateHash(node.content + path20);
-        await updateMetadataGlobalLock(path20, hash2);
+        const hash2 = await generateHash(node.content + path21);
+        await updateMetadataGlobalLock(path21, hash2);
       }
     }
   }
@@ -76867,9 +77087,11 @@ await init_lint();
 init_mod3();
 init_log();
 init_wrapper();
-init_get_port();
 init_open();
 init_script_common();
+init_extractor();
+init_path_assigner();
+init_port_probe();
 await __promiseAll([
   init_yaml(),
   init_utils(),
@@ -76884,13 +77106,223 @@ await __promiseAll([
   init_codebase(),
   init_local_path_scripts()
 ]);
+var import_yaml40 = __toESM(require_dist(), 1);
 import { sep as SEP20 } from "node:path";
 import * as http3 from "node:http";
-import { realpath } from "node:fs/promises";
+import * as https from "node:https";
+import { access, readdir as readdir10, realpath, stat as stat17, unlink, writeFile as writeFile19 } from "node:fs/promises";
 import { watch as watch2 } from "node:fs";
+import * as path20 from "node:path";
+import * as fs13 from "node:fs";
+
+// src/commands/dev/pathscript-restore.ts
+var TAG_KEY = "_originalPathScript";
+function walkModules(modules, visitor) {
+  for (const module of modules) {
+    if (!module.value)
+      continue;
+    const val = module.value;
+    if (val.type === "forloopflow" || val.type === "whileloopflow") {
+      walkModules(val.modules, visitor);
+    } else if (val.type === "branchall") {
+      for (const branch of val.branches ?? []) {
+        walkModules(branch.modules, visitor);
+      }
+    } else if (val.type === "branchone") {
+      for (const branch of val.branches ?? []) {
+        walkModules(branch.modules, visitor);
+      }
+      if (val.default) {
+        walkModules(val.default, visitor);
+      }
+    } else if (val.type === "aiagent") {
+      for (const tool of val.tools ?? []) {
+        visitor.onTool(tool);
+      }
+    } else {
+      visitor.onModule(module);
+    }
+  }
+}
+function walkFlow(flowValue, visitor) {
+  if (flowValue?.modules)
+    walkModules(flowValue.modules, visitor);
+  if (flowValue?.failure_module)
+    walkModules([flowValue.failure_module], visitor);
+  if (flowValue?.preprocessor_module)
+    walkModules([flowValue.preprocessor_module], visitor);
+}
+function snapshotPathScripts(flowValue) {
+  walkFlow(flowValue, {
+    onModule(module) {
+      if (module.value.type === "script") {
+        module[TAG_KEY] = JSON.parse(JSON.stringify(module.value));
+      }
+    },
+    onTool(tool) {
+      const tv = tool.value;
+      if (tv && "tool_type" in tv && tv.tool_type === "flowmodule" && tv.type === "script") {
+        tool[TAG_KEY] = JSON.parse(JSON.stringify(tv));
+      }
+    }
+  });
+}
+function tagReplacedPathScripts(flowValue) {
+  walkFlow(flowValue, {
+    onModule(module) {
+      if (module[TAG_KEY] && module.value.type === "rawscript") {
+        module.value[TAG_KEY] = module[TAG_KEY];
+        delete module[TAG_KEY];
+      } else if (module[TAG_KEY]) {
+        delete module[TAG_KEY];
+      }
+    },
+    onTool(tool) {
+      const tv = tool.value;
+      if (tool[TAG_KEY] && tv && "tool_type" in tv && tv.tool_type === "flowmodule" && tv.type === "rawscript") {
+        tv[TAG_KEY] = tool[TAG_KEY];
+        delete tool[TAG_KEY];
+      } else if (tool[TAG_KEY]) {
+        delete tool[TAG_KEY];
+      }
+    }
+  });
+}
+function restorePathScripts(flowValue) {
+  walkFlow(flowValue, {
+    onModule(module) {
+      if (module.value[TAG_KEY]) {
+        module.value = module.value[TAG_KEY];
+      }
+    },
+    onTool(tool) {
+      if (tool.value?.[TAG_KEY]) {
+        tool.value = tool.value[TAG_KEY];
+      }
+    }
+  });
+}
+
+// src/commands/dev/dev.ts
 var PORT = 3001;
+var FLOW_SUFFIXES = [".flow", "__flow"];
+var APP_SUFFIXES = [".app", "__app", ".raw_app", "__raw_app"];
+var INLINE_SCRIPT_EXTS = new Set([
+  ...exts.map((e) => path20.extname("x" + e)).filter((e) => e !== ".yml"),
+  ".js"
+]);
+function stripFolderSuffix(rel, suffixes) {
+  for (const s of suffixes) {
+    if (rel.endsWith(s))
+      return rel.slice(0, -s.length);
+  }
+  return rel;
+}
+function isFlowFolderName(name) {
+  return FLOW_SUFFIXES.some((s) => name.endsWith(s));
+}
+function normalizeWmPath(p) {
+  return stripFolderSuffix(p.replace(/\/$/, ""), FLOW_SUFFIXES);
+}
+function isInsideFlowFolder(cpath) {
+  return cpath.split("/").some(isFlowFolderName);
+}
+function findFlowFolderPrefix(cpath) {
+  const segs = cpath.split("/");
+  for (let i = 0;i < segs.length; i++) {
+    if (isFlowFolderName(segs[i])) {
+      return segs.slice(0, i + 1).join("/") + "/";
+    }
+  }
+  return;
+}
+async function listWorkspacePaths() {
+  const items = [];
+  async function walk(dir, rel) {
+    let entries;
+    try {
+      entries = await readdir10(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules")
+        continue;
+      const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+      const childAbs = path20.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (isFlowFolderName(entry.name)) {
+          items.push({
+            path: stripFolderSuffix(childRel, FLOW_SUFFIXES),
+            kind: "flow",
+            _metaPath: path20.join(childAbs, "flow.yaml")
+          });
+          continue;
+        }
+        if (APP_SUFFIXES.some((s) => entry.name.endsWith(s))) {
+          items.push({ path: stripFolderSuffix(childRel, APP_SUFFIXES), kind: "raw_app" });
+          continue;
+        }
+        await walk(childAbs, childRel);
+      } else if (entry.isFile()) {
+        const matchedExt = exts.find((ext2) => entry.name.endsWith(ext2));
+        if (matchedExt) {
+          const noExtAbs = childAbs.slice(0, -matchedExt.length);
+          items.push({
+            path: childRel.slice(0, -matchedExt.length),
+            kind: "script",
+            _metaPath: noExtAbs + ".script.yaml"
+          });
+        }
+      }
+    }
+  }
+  await walk(process.cwd(), "");
+  await Promise.all(items.map(async (item) => {
+    if (!item._metaPath)
+      return;
+    try {
+      const meta = await yamlParseFile(item._metaPath);
+      if (typeof meta?.summary === "string" && meta.summary.length > 0) {
+        item.summary = meta.summary;
+      }
+    } catch {}
+  }));
+  items.sort((a, b) => a.path.localeCompare(b.path));
+  return items.map(({ _metaPath, ...item }) => item);
+}
 async function dev2(opts) {
+  if (!opts.path) {
+    const cwd = process.cwd();
+    const cwdBasename = path20.basename(cwd);
+    await loadNonDottedPathsSetting();
+    if (isFlowFolderName(cwdBasename)) {
+      GLOBAL_CONFIG_OPT.noCdToRoot = true;
+      let searchDir = cwd;
+      let workspaceRoot;
+      while (true) {
+        const wmillYaml = path20.join(searchDir, "wmill.yaml");
+        if (fs13.existsSync(wmillYaml)) {
+          workspaceRoot = searchDir;
+          break;
+        }
+        const parentDir = path20.dirname(searchDir);
+        if (parentDir === searchDir)
+          break;
+        searchDir = parentDir;
+      }
+      if (workspaceRoot) {
+        const relPath = path20.relative(workspaceRoot, cwd).replaceAll("\\", "/");
+        opts.path = stripFolderSuffix(relPath, FLOW_SUFFIXES);
+        info(`Detected flow folder, path: ${opts.path}`);
+        process.chdir(workspaceRoot);
+      }
+    }
+  }
   opts = await mergeConfigWithConfigFile(opts);
+  if (opts.path) {
+    opts.path = normalizeWmPath(opts.path);
+  }
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   info("Started dev mode");
@@ -76922,39 +77354,50 @@ async function dev2(opts) {
       });
     });
   }
-  const flowFolderSuffix = getFolderSuffixWithSep("flow");
   const flowMetadataFile = getMetadataFileName("flow", "yaml");
   async function loadPaths(pathsToLoad) {
-    const paths = pathsToLoad.filter((path20) => exts.some((ext2) => path20.endsWith(ext2) || path20.endsWith(flowFolderSuffix + flowMetadataFile)));
+    const paths = pathsToLoad.filter((p) => exts.some((ext2) => p.endsWith(ext2) || p.endsWith(".flow/" + flowMetadataFile) || p.endsWith("__flow/" + flowMetadataFile)));
     if (paths.length == 0) {
       return;
     }
     const nativePath = (await realpath(paths[0])).replace(base + SEP20, "");
     const cpath = nativePath.replaceAll("\\", "/");
-    if (!ignore(nativePath, false)) {
-      const typ = getTypeStrFromPath(cpath);
+    const insideFlow = isInsideFlowFolder(cpath);
+    if (insideFlow || !ignore(nativePath, false)) {
+      let typ;
+      if (insideFlow) {
+        typ = "flow";
+      } else {
+        typ = getTypeStrFromPath(cpath);
+      }
       info("Detected change in " + cpath + " (" + typ + ")");
       if (typ == "flow") {
-        const localPath = extractFolderPath(cpath, "flow");
+        let localPath = extractFolderPath(cpath, "flow") ?? findFlowFolderPrefix(cpath);
+        if (!localPath)
+          return;
+        const wmFlowPath = stripFolderSuffix(localPath.replace(/\/$/, ""), FLOW_SUFFIXES);
         const localFlow = await yamlParseFile(localPath + "flow.yaml");
-        await replaceInlineScripts(localFlow.value.modules, async (path20) => await readTextFile(localPath + path20), exports_log, localPath, SEP20, undefined);
+        await replaceInlineScripts(localFlow.value.modules, async (path21) => await readTextFile(localPath + path21), exports_log, localPath, SEP20, undefined);
+        snapshotPathScripts(localFlow.value);
         const localScriptReader = createPreviewLocalScriptReader({
           exts,
           defaultTs: opts.defaultTs,
           codebases
         });
         await replaceAllPathScriptsWithLocal(localFlow.value, localScriptReader, exports_log);
+        tagReplacedPathScripts(localFlow.value);
         currentLastEdit = {
           type: "flow",
           flow: localFlow,
-          uriPath: localPath
+          uriPath: localPath,
+          path: wmFlowPath
         };
-        info("Updated " + localPath);
+        info("Updated " + wmFlowPath);
         broadcastChanges(currentLastEdit);
       } else if (typ == "script") {
-        const content = await readTextFile(cpath);
         const splitted = cpath.split(".");
         const wmPath = splitted[0];
+        const content = await readTextFile(cpath);
         const lang = inferContentTypeFromFilePath(cpath, opts.defaultTs);
         const typed = (await parseMetadataFile(removeExtensionToPath(cpath), undefined))?.payload;
         currentLastEdit = {
@@ -76970,29 +77413,164 @@ async function dev2(opts) {
       }
     }
   }
+  async function loadWmPath(wmPath) {
+    wmPath = normalizeWmPath(wmPath);
+    let flowDir;
+    let flowYaml;
+    for (const suffix of [".flow", "__flow"]) {
+      const candidate = wmPath + suffix + "/";
+      try {
+        await access(candidate + "flow.yaml");
+        flowDir = candidate;
+        flowYaml = candidate + "flow.yaml";
+        break;
+      } catch {}
+    }
+    try {
+      if (!flowDir || !flowYaml)
+        throw new Error("not a flow");
+      const localFlow = await yamlParseFile(flowYaml);
+      await replaceInlineScripts(localFlow.value.modules, async (p) => await readTextFile(flowDir + p), exports_log, flowDir, SEP20, undefined);
+      snapshotPathScripts(localFlow.value);
+      const localScriptReader = createPreviewLocalScriptReader({
+        exts,
+        defaultTs: opts.defaultTs,
+        codebases
+      });
+      await replaceAllPathScriptsWithLocal(localFlow.value, localScriptReader, exports_log);
+      tagReplacedPathScripts(localFlow.value);
+      const edit = {
+        type: "flow",
+        flow: localFlow,
+        uriPath: flowDir,
+        path: wmPath
+      };
+      currentLastEdit = edit;
+      return edit;
+    } catch {}
+    for (const ext2 of exts) {
+      const filePath = wmPath + ext2;
+      try {
+        await access(filePath);
+        const content = await readTextFile(filePath);
+        const lang = inferContentTypeFromFilePath(filePath, opts.defaultTs);
+        const typed = (await parseMetadataFile(removeExtensionToPath(filePath), undefined))?.payload;
+        const edit = {
+          type: "script",
+          content,
+          path: wmPath,
+          language: lang,
+          tag: typed?.tag,
+          lock: typed?.lock
+        };
+        currentLastEdit = edit;
+        return edit;
+      } catch {
+        continue;
+      }
+    }
+    error(`Could not find file for path: ${wmPath}`);
+    return;
+  }
+  async function handleFlowRoundTrip(data3) {
+    if (!data3.uriPath || !data3.flow?.value)
+      return;
+    let flowDir = data3.uriPath;
+    if (!flowDir.endsWith("/"))
+      flowDir += "/";
+    if (flowDir.includes("://")) {
+      flowDir = new URL(flowDir).pathname;
+    }
+    restorePathScripts(data3.flow.value);
+    const flowYamlPath = flowDir + "flow.yaml";
+    let currentLoadedFlow;
+    let currentLoadedFailureModule;
+    let currentLoadedPreprocessorModule;
+    try {
+      const currentFlow = await yamlParseFile(flowYamlPath);
+      currentLoadedFlow = currentFlow.value?.modules;
+      currentLoadedFailureModule = currentFlow.value?.failure_module;
+      currentLoadedPreprocessorModule = currentFlow.value?.preprocessor_module;
+    } catch {}
+    const inlineScriptMapping = {};
+    extractCurrentMapping(currentLoadedFlow, inlineScriptMapping, currentLoadedFailureModule, currentLoadedPreprocessorModule);
+    const extractOptions = { skipInlineScriptSuffix: getNonDottedPaths() };
+    const pathAssigner = newPathAssigner(opts.defaultTs ?? "bun", extractOptions);
+    const allExtracted = extractInlineScripts(data3.flow.value.modules ?? [], inlineScriptMapping, "/", opts.defaultTs ?? "bun", pathAssigner, extractOptions);
+    if (data3.flow.value.failure_module?.value?.type === "rawscript") {
+      allExtracted.push(...extractInlineScripts([data3.flow.value.failure_module], inlineScriptMapping, "/", opts.defaultTs ?? "bun", pathAssigner, extractOptions));
+    }
+    if (data3.flow.value.preprocessor_module?.value?.type === "rawscript") {
+      allExtracted.push(...extractInlineScripts([data3.flow.value.preprocessor_module], inlineScriptMapping, "/", opts.defaultTs ?? "bun", pathAssigner, extractOptions));
+    }
+    for (const s of allExtracted) {
+      const filePath = flowDir + s.path;
+      if (s.content.startsWith("!inline ")) {
+        try {
+          await stat17(filePath);
+        } catch {
+          await writeFile19(filePath, "", "utf-8");
+        }
+        continue;
+      }
+      let needsWrite = true;
+      try {
+        const existing = await readTextFile(filePath);
+        if (existing === s.content)
+          needsWrite = false;
+      } catch {}
+      if (needsWrite) {
+        await writeFile19(filePath, s.content, "utf-8");
+        info(`Wrote inline script: ${filePath}`);
+      }
+    }
+    const flowYaml = import_yaml40.stringify(data3.flow);
+    let currentYaml;
+    try {
+      currentYaml = await readTextFile(flowYamlPath);
+    } catch {}
+    if (currentYaml?.trimEnd() !== flowYaml.trimEnd()) {
+      await writeFile19(flowYamlPath, flowYaml, "utf-8");
+      info(`Wrote flow: ${flowYamlPath}`);
+    }
+    const extractedPaths = new Set(allExtracted.map((s) => s.path));
+    try {
+      const dirFiles = await readdir10(flowDir);
+      for (const file of dirFiles) {
+        if (file === "flow.yaml" || file === "flow.json" || file.startsWith("."))
+          continue;
+        if (!INLINE_SCRIPT_EXTS.has(path20.extname(file)))
+          continue;
+        if (!extractedPaths.has(file)) {
+          await unlink(flowDir + file);
+          info(`Removed orphaned file: ${flowDir + file}`);
+        }
+      }
+    } catch {}
+  }
   const connectedClients = new Set;
   function broadcastChanges(lastEdit) {
+    if (opts.path && normalizeWmPath(lastEdit.path) !== opts.path) {
+      return;
+    }
     for (const client of connectedClients.values()) {
       client.send(JSON.stringify(lastEdit));
     }
   }
-  async function startApp() {
-    const server = http3.createServer((_req, res) => {
-      res.writeHead(200);
-      res.end();
-    });
-    const wss = new import_websocket_server.default({ server });
+  function setupDevWs(wss) {
     wss.on("connection", (ws) => {
       connectedClients.add(ws);
-      console.log("New client connected");
-      ws.on("open", () => {
-        if (currentLastEdit) {
-          broadcastChanges(currentLastEdit);
+      console.log("New dev client connected");
+      if (currentLastEdit && ws.readyState === import_websocket.default.OPEN) {
+        try {
+          ws.send(JSON.stringify(currentLastEdit));
+        } catch (e) {
+          console.error("Failed to push initial state to new client:", e);
         }
-      });
+      }
       ws.on("close", () => {
         connectedClients.delete(ws);
-        console.log("Client disconnected");
+        console.log("Dev client disconnected");
       });
       ws.on("message", (message) => {
         let data3;
@@ -77004,29 +77582,184 @@ async function dev2(opts) {
         }
         if (data3.type === "load") {
           loadPaths([data3.path]);
+        } else if (data3.type === "flow") {
+          handleFlowRoundTrip(data3).catch((err) => {
+            error(`Failed to write flow changes: ${err}`);
+          });
+        } else if (data3.type === "loadWmPath") {
+          loadWmPath(data3.path).then((edit) => {
+            if (edit && ws.readyState === import_websocket.default.OPEN) {
+              ws.send(JSON.stringify(edit));
+            }
+          }).catch((err) => {
+            error(`Failed to load path ${data3.path}: ${err}`);
+          });
+        } else if (data3.type === "listPaths") {
+          listWorkspacePaths().then((items) => {
+            if (ws.readyState === import_websocket.default.OPEN) {
+              ws.send(JSON.stringify({ type: "paths", items }));
+            }
+          }).catch((err) => {
+            error(`Failed to list paths: ${err}`);
+          });
         }
       });
     });
-    const port = await getPorts({ port: 3001 });
-    const url = `${workspace.remote}dev?workspace=${workspace.workspaceId}&local=true&wm_token=${workspace.token}` + (port === PORT ? "" : `&port=${port}`);
-    console.log(`Go to ${url}`);
+  }
+  function maybeOpenBrowser(url) {
+    if (opts.open === false)
+      return;
     try {
-      openApp(apps.browser, { arguments: [url] }).catch((error2) => {
+      open_default(url).catch((error2) => {
         console.error(`Failed to open browser, please navigate to ${url}, error: ${error2}`);
       });
-      console.log("Opened browser for you");
+      console.log(`Opened browser at ${url}`);
     } catch (error2) {
       console.error(`Failed to open browser, please navigate to ${url}, ${error2}`);
     }
-    console.log("Dev server will automatically point to the last script edited locally");
-    server.listen(port, () => {
-      console.log(`Server listening on port ${port}`);
+  }
+  async function startProxyServer(requestedPort) {
+    const proxyPort = await resolveBindPort(requestedPort, "--proxy-port", {
+      info: (m) => console.log(m),
+      warn: (m) => console.warn(m)
+    });
+    const remote = new URL(workspace.remote);
+    const isHttps = remote.protocol === "https:";
+    const remoteHost = remote.hostname;
+    const remotePort = remote.port ? parseInt(remote.port) : isHttps ? 443 : 80;
+    const httpModule = isHttps ? https : http3;
+    const devWss = new import_websocket_server.default({ noServer: true });
+    setupDevWs(devWss);
+    const proxyWss = new import_websocket_server.default({ noServer: true });
+    const proxyServer = http3.createServer((clientReq, clientRes) => {
+      const parsedUrl = new URL(clientReq.url ?? "/", `http://localhost`);
+      if (parsedUrl.pathname === "/" || parsedUrl.pathname === "") {
+        let devUrl = `/dev?workspace=${workspace.workspaceId}&local=true&wm_token=${workspace.token}&port=${proxyPort}`;
+        if (opts.path) {
+          devUrl += `&path=${opts.path}`;
+        }
+        clientRes.writeHead(302, { Location: devUrl });
+        clientRes.end();
+        return;
+      }
+      const fwdHeaders = {
+        ...clientReq.headers,
+        host: remote.host
+      };
+      delete fwdHeaders["connection"];
+      delete fwdHeaders["keep-alive"];
+      delete fwdHeaders["transfer-encoding"];
+      delete fwdHeaders["accept-encoding"];
+      const proxyOpts = {
+        hostname: remoteHost,
+        port: remotePort,
+        path: clientReq.url,
+        method: clientReq.method,
+        headers: fwdHeaders
+      };
+      const proxyReq = httpModule.request(proxyOpts, (proxyRes) => {
+        const setCookie = proxyRes.headers["set-cookie"];
+        if (setCookie) {
+          proxyRes.headers["set-cookie"] = setCookie.map((cookie) => cookie.replace(/domain=[^;]+/gi, "domain=localhost"));
+        }
+        clientRes.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+        proxyRes.pipe(clientRes, { end: true });
+      });
+      proxyReq.on("error", (err) => {
+        console.error("Proxy error:", err.message);
+        clientRes.writeHead(502);
+        clientRes.end("Bad Gateway");
+      });
+      clientReq.pipe(proxyReq, { end: true });
+    });
+    proxyServer.on("upgrade", (req, socket, head) => {
+      const pathname = req.url?.split("?")[0] ?? "";
+      if (pathname === "/ws_dev" || pathname === "/ws") {
+        devWss.handleUpgrade(req, socket, head, (ws) => {
+          devWss.emit("connection", ws, req);
+        });
+        return;
+      }
+      if (pathname.startsWith("/ws/") || pathname.startsWith("/ws_mp/") || pathname.startsWith("/ws_debug/")) {
+        const wsProtocol = isHttps ? "wss" : "ws";
+        const remoteWsUrl = `${wsProtocol}://${remote.host}${req.url}`;
+        const remoteWs = new import_websocket.default(remoteWsUrl, {
+          headers: {
+            ...req.headers,
+            host: remote.host
+          }
+        });
+        remoteWs.on("open", () => {
+          proxyWss.handleUpgrade(req, socket, head, (clientWs) => {
+            clientWs.on("message", (data3) => {
+              if (remoteWs.readyState === import_websocket.default.OPEN) {
+                remoteWs.send(data3);
+              }
+            });
+            remoteWs.on("message", (data3) => {
+              if (clientWs.readyState === import_websocket.default.OPEN) {
+                clientWs.send(data3);
+              }
+            });
+            clientWs.on("close", () => remoteWs.close());
+            remoteWs.on("close", () => clientWs.close());
+          });
+        });
+        remoteWs.on("error", (err) => {
+          console.error("WebSocket proxy error:", err.message);
+          socket.destroy();
+        });
+        return;
+      }
+      socket.destroy();
+    });
+    return new Promise((resolve8) => {
+      proxyServer.listen(proxyPort, BIND_HOST, () => {
+        console.log(`Dev proxy listening on http://localhost:${proxyPort}`);
+        if (opts.path) {
+          console.log(`Watching ${opts.path} — edits will live-reload in the dev page`);
+        } else {
+          console.log("Open the dev page and pick a flow or script to preview — edits will live-reload");
+          console.log("(pass --path <path> to skip the picker)");
+        }
+        maybeOpenBrowser(`http://localhost:${proxyPort}/`);
+        resolve8();
+      });
+    });
+  }
+  async function startDirectServer() {
+    const server = http3.createServer((_req, res) => {
+      res.writeHead(200);
+      res.end();
+    });
+    const wss = new import_websocket_server.default({ server });
+    setupDevWs(wss);
+    const port = await resolveBindPort(PORT, "wmill dev", {
+      info: (m) => console.log(m),
+      warn: (m) => console.warn(m)
+    });
+    const url = `${workspace.remote}dev?workspace=${workspace.workspaceId}&local=true&wm_token=${workspace.token}` + (port === PORT ? "" : `&port=${port}`) + (opts.path ? `&path=${opts.path}` : "");
+    if (opts.open === false) {
+      console.log(`Go to ${url}`);
+    }
+    maybeOpenBrowser(url);
+    if (opts.path) {
+      console.log(`Watching ${opts.path} — edits will live-reload in the dev page`);
+    } else {
+      console.log("Open the dev page and pick a flow or script to preview — edits will live-reload");
+    }
+    server.listen(port, BIND_HOST, () => {
+      console.log(`Dev WebSocket listening on ws://localhost:${port}/ws`);
     });
   }
-  await Promise.all([startApp(), watchChanges()]);
+  if (opts.path) {
+    await loadWmPath(opts.path);
+  }
+  const startServer = opts.proxyPort ? () => startProxyServer(opts.proxyPort) : () => startDirectServer();
+  await Promise.all([startServer(), watchChanges()]);
   console.log("Stopped dev mode");
 }
-var command24 = new Command().description("Launch a dev server that watches for local file changes and auto-pushes them to the remote workspace. Provides live reload for scripts and flows during development.").option("--includes <pattern...:string>", "Filter paths givena glob pattern or path").action(dev2);
+var command24 = new Command().description("Watch local file changes and live-reload the dev page for preview. Does NOT deploy to the remote workspace — use wmill sync push for that.").option("--includes <pattern...:string>", "Filter paths given a glob pattern or path").option("--proxy-port <port:number>", "Port for a localhost reverse proxy to the remote Windmill server").option("--path <path:string>", "Watch a specific windmill path (e.g., u/admin/my_script or f/my_flow)").option("--no-open", "Do not open the browser automatically").action(dev2);
 var dev_default2 = command24;
 
 // src/main.ts
@@ -77268,12 +78001,12 @@ await __promiseAll([
   init_workspace(),
   init_resource_type()
 ]);
-import { stat as stat18, writeFile as writeFile20, rm as rm4 } from "node:fs/promises";
+import { stat as stat19, writeFile as writeFile21, rm as rm5 } from "node:fs/promises";
 
 // src/guidance/writer.ts
 await init_utils();
-import { cp, mkdir as mkdir13, readdir as readdir10, stat as stat17, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { cp, mkdir as mkdir13, readdir as readdir11, stat as stat18, writeFile as writeFile20 } from "node:fs/promises";
+import { join as join18 } from "node:path";
 
 // src/guidance/core.ts
 function generateAgentsMdContent(skillsReference) {
@@ -77293,11 +78026,12 @@ You MUST use the \`write-script-<language>\` skill to write or modify scripts in
 ## Flow Writing Guide
 
 You MUST use the \`write-flow\` skill to create or modify flows.
+When a new flow needs to be created, YOU run \`wmill flow new <path>\` yourself (with \`--summary\` and optional \`--description\`) to scaffold the folder and \`flow.yaml\`, then edit \`flow.yaml\` to fill in modules and schema. Do NOT scaffold the folder + yaml by hand and do NOT tell the user to run \`wmill flow new\`. If path or summary are missing from the user's request, ask via \`AskUserQuestion\` (one call, all missing fields) — never invent them. See the \`write-flow\` skill for the procedure.
 
 ## Raw App Development
 
 You MUST use the \`raw-app\` skill to create or modify raw apps.
-Whenever a new app needs to be created you MUST ask the user to run \`wmill app new\` in its terminal first.
+When a new app needs to be created, YOU run \`wmill app new\` yourself with \`--summary\`, \`--path\`, and \`--framework\` flags (and any other relevant flags). Do NOT ask the user to run it. If you don't have the values for those flags, ask the user via \`AskUserQuestion\` (one call, all missing fields) — never invent them. See the \`raw-app\` skill for the full procedure.
 
 ## Triggers
 
@@ -77311,6 +78045,10 @@ You MUST use the \`schedules\` skill to configure cron schedules.
 
 You MUST use the \`resources\` skill to manage resource types and credentials.
 
+## Visual Preview
+
+You MUST use the \`preview\` skill any time the user wants to see/open/visualize/preview a flow, script, or app in the dev page — and after writing one, when offering visual verification. The skill picks between an MCP-embedded proxy (one named \`launch.json\` entry per target) and direct mode (URL handed to the user) based on what tools you have.
+
 ## CLI Reference
 
 You MUST use the \`cli-commands\` skill to use the CLI.
@@ -77363,7 +78101,8 @@ var SKILLS = [
   { name: "triggers", description: "MUST use when configuring triggers." },
   { name: "schedules", description: "MUST use when configuring schedules." },
   { name: "resources", description: "MUST use when managing resources." },
-  { name: "cli-commands", description: "MUST use when using the CLI, including debugging job failures and inspecting run history via `wmill job`." }
+  { name: "cli-commands", description: "MUST use when using the CLI, including debugging job failures and inspecting run history via `wmill job`." },
+  { name: "preview", description: "MUST use when opening the Windmill dev page / visual preview of a flow, script, or app. Triggers on words like preview, open, navigate to, visualize, see the flow/app/script, and after writing a flow/script/app for visual verification." }
 ];
 var SKILL_CONTENT = {
   "write-script-bash": `---
@@ -77373,11 +78112,36 @@ description: MUST use when writing Bash scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -77438,11 +78202,36 @@ description: MUST use when writing BigQuery queries.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -77465,11 +78254,36 @@ description: MUST use when writing Bun/TypeScript scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -78132,11 +78946,36 @@ description: MUST use when writing Bun Native scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -78797,11 +79636,36 @@ description: MUST use when writing C# scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -78854,11 +79718,36 @@ description: MUST use when writing Deno/TypeScript scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -79525,11 +80414,36 @@ description: MUST use when writing DuckDB queries.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -79592,11 +80506,36 @@ description: MUST use when writing Go scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -79666,11 +80605,36 @@ description: MUST use when writing GraphQL queries.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -79727,11 +80691,36 @@ description: MUST use when writing Java scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -79781,11 +80770,36 @@ description: MUST use when writing MS SQL Server queries.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -79808,11 +80822,36 @@ description: MUST use when writing MySQL queries.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -79835,11 +80874,36 @@ description: MUST use when writing Native TypeScript scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -80467,11 +81531,36 @@ description: MUST use when writing PHP scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -80540,11 +81629,36 @@ description: MUST use when writing PostgreSQL queries.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -80567,11 +81681,36 @@ description: MUST use when writing PowerShell scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -80638,11 +81777,36 @@ description: MUST use when writing Python scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -81464,11 +82628,36 @@ description: MUST use when writing R scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -81565,11 +82754,36 @@ description: MUST use when writing Rust scripts.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
+
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -81656,11 +82870,36 @@ description: MUST use when writing Snowflake queries.
 
 ## CLI Commands
 
-Place scripts in a folder. After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate .script.yaml and .lock files
-- \`wmill sync push\` - Deploy to Windmill
+Place scripts in a folder.
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
+- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`script run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local script being edited (you're just invoking an existing script).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to test, don't wait passively
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
+
+\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
 
 Use \`wmill resource-type list --schema\` to discover available resource types.
 
@@ -81683,15 +82922,77 @@ description: MUST use when creating flows.
 
 # Windmill Flow Building Guide
 
-## CLI Commands
+## Creating a Flow
+
+**You — the AI agent — scaffold the flow yourself by running \`wmill flow new <path>\` with the right flags. Do NOT hand-create the folder + \`flow.yaml\`, and do NOT tell the user to "run \`wmill flow new\` and follow the prompts".**
+
+\`wmill flow new\` creates the folder with the correct suffix (\`{{FLOW_SUFFIX}}\` or \`.flow\` depending on the workspace's \`nonDottedPaths\` setting), writes a minimal \`flow.yaml\` shell, and prints Claude-specific next-step hints. Scaffolding by hand skips all of that and often picks the wrong suffix.
+
+### Step 1 — Gather path + summary by asking the user
+
+You need two things:
+
+1. **path** — the windmill path, e.g. \`f/folder/my_flow\` or \`u/username/my_flow\`.
+2. **summary** — a short description of the flow.
+
+If the user's request didn't supply both, ask for both in a single round-trip. Use whichever interactive question facility your runtime provides — a structured multi-choice tool if available, otherwise plain chat — and provide one or two example values for each (with an "Other" / free-form fallback). Do not guess paths or summaries.
+
+### Step 2 — Run the command yourself
+
+\`\`\`bash
+wmill flow new f/folder/my_flow --summary "Short description"
+\`\`\`
+
+Add \`--description "..."\` when the user provided a longer explanation worth preserving separately from the summary.
+
+### Step 3 — Fill in \`flow.yaml\`
+
+Open the generated \`flow.yaml\` (under the folder the command just created) and replace the empty \`value.modules\` + \`schema\` with the real flow definition.
 
-Create a folder ending with \`{{FLOW_SUFFIX}}\` and add a \`flow.yaml\` file with the flow definition.
 For rawscript modules, use \`!inline path/to/script.ts\` for the content key. {{INLINE_SCRIPT_NAMING}}
-After writing, tell the user they can run:
-- \`wmill generate-metadata\` - Generate lock files for the flow you modified
-- \`wmill sync push\` - Deploy to Windmill
 
-Do NOT run these commands yourself. Instead, inform the user that they should run them.
+Once the flow has real content, **offer** to open the visual preview as a one-sentence next step (e.g. "Want me to open the visual preview?"). Don't auto-open — opening the dev page has side effects (browser window, possibly a \`launch.json\` entry) and the user should consent.
+
+### Anti-patterns to avoid
+
+- ❌ Hand-creating the \`{{FLOW_SUFFIX}}\` folder + \`flow.yaml\` instead of running \`wmill flow new\`. You'll miss the suffix-setting resolution, the default shape, and the Claude hints.
+- ❌ Telling the user to "run \`wmill flow new <path>\`" — you can and should run it yourself.
+- ❌ Inventing a path/summary instead of asking the user.
+
+## CLI Commands — running, previewing, deploying
+
+After writing, tell the user which command fits what they want to do:
+
+- \`wmill flow preview <flow_path>\` — **default when iterating on a local flow.** Runs the local \`flow.yaml\` against local inline scripts without deploying. Add \`--remote\` to use deployed workspace scripts for PathScript steps instead of local files.
+- \`wmill flow run <path>\` — runs the flow **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
+- \`wmill generate-metadata\` — regenerate stale \`.lock\` and \`.script.yaml\` files. By default it scans **scripts, flows, and apps** across the workspace; pass \`--skip-flows --skip-apps\` (or run from a subdirectory) to limit the scope when you only care about the flow you edited.
+- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
+
+### Preview vs run — choose by intent, not habit
+
+If the user says "run the flow", "try it", "test it", "does it work" while there are **local edits to a \`flow.yaml\`**, use \`flow preview\`. Do NOT push the flow to then \`flow run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
+
+Only use \`flow run\` when:
+- The user explicitly says "run the deployed version" / "run what's on the server".
+- There is no local \`flow.yaml\` being edited (you're just invoking an existing flow).
+
+Only use \`sync push\` when:
+- The user explicitly asks to deploy, publish, push, or ship.
+- The preview has already validated the change and the user wants it in the workspace.
+
+### After writing — offer to run, don't wait passively
+
+This is about **programmatic execution** (\`wmill flow preview -d '<args>'\`), which actually runs the flow and has side effects. Visual preview (the \`preview\` skill) is offered separately — see "Visual preview" below.
+
+If the user hasn't already told you to run/test the flow, offer it as a one-sentence next step (e.g. "Want me to run \`wmill flow preview\` with sample args?"). Do not present a multi-option menu.
+
+If the user already asked to test/run/try the flow in their original request, skip the offer and just execute \`wmill flow preview <path> -d '<args>'\` directly — pick plausible args from the flow's input schema.
+
+\`wmill flow preview\` is safe to run yourself (it does not deploy). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
+
+### Visual preview
+
+To open the flow visually in the dev page (graph + live reload), use the \`preview\` skill. Always **offer** it as a one-sentence next step (e.g. "Want me to open the visual preview?") rather than opening it automatically — opening the dev page has side effects (browser window, possibly a \`launch.json\` entry under MCP-preview branches) the user should consent to. If the user already asked to see/preview/visualize the flow in their original request, skip the offer and just invoke the skill.
 
 ## OpenFlow Schema
 
@@ -82000,11 +83301,70 @@ Raw apps let you build custom frontends with React, Svelte, or Vue that connect
 
 ## Creating a Raw App
 
+**You — the AI agent — create the app yourself by running \`wmill app new\` with the right flags. Do NOT tell the user to "run \`wmill app new\` and follow the prompts" or wait for them to do it.** The bare \`wmill app new\` is an interactive wizard that hangs waiting for stdin in any non-TTY context (which includes you). Always pass flags.
+
+### Step 1 — Gather the three required values by asking the user
+
+You need three things to run the command:
+
+1. **summary** — a short description of the app
+2. **path** — the windmill path, e.g. \`f/folder/my_app\` or \`u/username/my_app\`
+3. **framework** — one of \`react19\` (recommended), \`react18\`, \`svelte5\`, \`vue\`
+
+If the user's request did not supply *every* one of these explicitly, ask. Do not guess values, do not invent paths, do not pick a framework on the user's behalf, do not "just use react19 because it's the default".
+
+Use whichever interactive question facility your runtime provides — a structured multi-choice tool if available, otherwise plain chat — and group all missing fields into a single round-trip so the user answers them at once:
+
+- For \`framework\` — multiple-choice with the four allowed values; mark \`react19\` as \`(Recommended)\` and put it first.
+- For \`summary\` and \`path\` — provide one or two example values as multiple-choice options (the user can pick "Other" to type a free-form answer).
+
+Only proceed once you have concrete values for all three. If the user replies with something ambiguous, ask again rather than guessing.
+
+### Step 2 — Run the command yourself
+
+Once you have summary + path + framework, run it:
+
+\`\`\`bash
+wmill app new \\
+  --summary "Customer dashboard" \\
+  --path f/sales/dashboard \\
+  --framework react19
+\`\`\`
+
+That's the minimum. The datatable wizard and the "Open in Claude Desktop?" prompt are skipped silently because passing any of \`--summary\`/\`--path\`/\`--framework\` puts the command in non-interactive mode.
+
+### Optional flags
+
+Layer these in only when the user asked for them:
+
+| Flag | When to add it |
+|---|---|
+| \`--datatable <name>\` | The user wants this app wired to a specific Windmill datatable. Without it, the app is created with no datatable. |
+| \`--schema <name>\` | Together with \`--datatable\`. Creates the schema with \`CREATE SCHEMA IF NOT EXISTS\` if it doesn't already exist. |
+| \`--overwrite\` | The target directory already exists and the user said it's OK to replace. Without it, non-interactive mode aborts with an error so you don't clobber existing work. |
+| \`--no-open-in-desktop\` | Already implied in non-interactive mode; only needed if you're somehow running interactively. |
+
+### Step 3 — Offer the visual preview
+
+After \`wmill app new\` and any initial edits to \`App.tsx\` / \`index.tsx\`, **offer** to open the visual preview as a one-sentence next step (e.g. "Want me to open the visual preview?"). Don't auto-open — opening the dev page has side effects (browser window, possibly a \`launch.json\` entry when an embedded preview tool is in play) the user should consent to.
+
+For apps the preview command runs from the app folder (\`cd <app_path>__raw_app && wmill app dev …\`); the \`preview\` skill picks the proxy vs direct branch based on whether the runtime exposes a tool that can embed a localhost URL. If the user already asked to see/preview/visualize the app in their original request, skip the offer and just invoke the skill.
+
+### Anti-patterns to avoid
+
+- ❌ Running \`wmill app new\` with no flags (the prompt will hang).
+- ❌ Telling the user to "run \`wmill app new\` and follow the prompts" — that's a step backwards from what you can do directly.
+- ❌ Inventing a path/summary/framework instead of asking the user.
+- ❌ Defaulting to \`react19\` because the user didn't say — even sensible defaults must be confirmed.
+- ❌ Passing \`--overwrite\` automatically when the directory exists — confirm with the user first.
+
+### Interactive (only when a human is at the terminal)
+
 \`\`\`bash
 wmill app new
 \`\`\`
 
-This interactive command creates a complete app structure with your choice of frontend framework (React, Svelte, or Vue).
+This is the wizard. It only works when run by a human in a real terminal. Don't call it this way from an agent.
 
 ## App Structure
 
@@ -82228,12 +83588,13 @@ data:
 
 ## CLI Commands
 
-Tell the user they can run these commands (do NOT run them yourself):
+\`wmill app new\` is the exception: you run it yourself, with flags, per the "Creating a Raw App" section above.
+
+For everything else, tell the user which command fits their intent and let them run it — these touch the workspace or local lock files, and the user should consent each time:
 
 | Command | Description |
 |---------|-------------|
-| \`wmill app new\` | Create a new raw app interactively |
-| \`wmill app dev\` | Start dev server with live reload |
+| \`wmill app dev\` | Start dev server with live reload (see the \`preview\` skill for the full open-the-app-in-the-IDE-pane procedure). |
 | \`wmill app generate-agents\` | Refresh AGENTS.md and DATATABLES.md |
 | \`wmill generate-metadata\` | Generate lock files for backend runnables |
 | \`wmill sync push\` | Deploy app to Windmill |
@@ -82622,6 +83983,13 @@ app related commands
 - \`app lint [app_folder:string]\` - Lint a raw app folder to validate structure and buildability
   - \`--fix\` - Attempt to fix common issues (not implemented yet)
 - \`app new\` - create a new raw app from a template
+  - \`--summary <summary:string>\` - App summary (short description). Skips the prompt when provided. Triggers non-interactive mode.
+  - \`--path <path:string>\` - App path (e.g., f/folder/my_app or u/username/my_app). Skips the prompt when provided. Triggers non-interactive mode.
+  - \`--framework <framework:string>\` - Framework template: react19 | react18 | svelte5 | vue. Skips the prompt when provided. Triggers non-interactive mode.
+  - \`--datatable <datatable:string>\` - Datatable to wire up. Without this flag in non-interactive mode, no datatable is configured.
+  - \`--schema <schema:string>\` - Schema to use with --datatable. Created (CREATE SCHEMA IF NOT EXISTS) if it doesn't already exist.
+  - \`--overwrite\` - Overwrite the target directory if it already exists, without prompting.
+  - \`--no-open-in-desktop\` - Do not prompt to open the new app in Claude Desktop.
 - \`app generate-agents [app_folder:string]\` - regenerate AGENTS.md and DATATABLES.md from remote workspace
 - \`app set-permissioned-as <path:string> <email:string>\` - Set the on_behalf_of_email for an app (requires admin or wm_deployers group)
 
@@ -82658,10 +84026,13 @@ workspace dependencies related commands
 
 ### dev
 
-Launch a dev server that watches for local file changes and auto-pushes them to the remote workspace. Provides live reload for scripts and flows during development.
+Watch local file changes and live-reload the dev page for preview. Does NOT deploy to the remote workspace — use wmill sync push for that.
 
 **Options:**
-- \`--includes <pattern...:string>\` - Filter paths givena glob pattern or path
+- \`--includes <pattern...:string>\` - Filter paths given a glob pattern or path
+- \`--proxy-port <port:number>\` - Port for a localhost reverse proxy to the remote Windmill server
+- \`--path <path:string>\` - Watch a specific windmill path (e.g., u/admin/my_script or f/my_flow)
+- \`--no-open\` - Do not open the browser automatically
 
 ### docs
 
@@ -83207,6 +84578,133 @@ workspace related commands
   - \`--team-name <team_name:string>\` - Slack team name
 - \`workspace disconnect-slack\`
 
+`,
+  preview: `---
+name: preview
+description: MUST use when opening the Windmill dev page / visual preview of a flow, script, or app. Triggers on words like preview, open, navigate to, visualize, see the flow/app/script, and after writing a flow/script/app for visual verification.
+---
+
+# Windmill Preview Workflow
+
+Use this skill any time the user wants to **see**, **open**, **navigate to**, **visualize**, or **preview** a flow, script, or app — and any time you've just finished writing one and want to offer visual verification.
+
+The Windmill dev page renders the flow graph / script editor, lets the user step through steps, and live-reloads on every save. It runs locally via \`wmill dev\` and is reached on a localhost port.
+
+## Two independent decisions
+
+### 1. Mode: proxy or direct?
+
+\`wmill dev\` runs in two modes; pick by asking what kind of URL whatever will display the preview needs.
+
+- **Proxy** (\`--proxy-port <port>\`) — exposes the dev page on \`http://localhost:<port>/\`. Use it when the embedder you'll hand the URL to **only accepts localhost URLs** (most in-IDE / in-chat preview embedders do, because they sandbox cross-origin loads).
+- **Direct** (default) — the user's browser loads the dev page from the remote workspace's HTTPS URL; the local \`wmill dev\` only runs the WebSocket back-channel for live reload. Use it when the URL will be opened in a regular browser tab.
+
+Default to **direct** unless you have a specific embedder that needs localhost.
+
+### 2. Who starts the server?
+
+- **You start it** in the background. Spawn \`wmill dev …\` (or \`wmill app dev …\`) yourself, capture the URL it prints, do whatever's next (open a tab, hand the URL to an embedder).
+- **The runtime starts it from \`.claude/launch.json\`.** Some runtimes (currently the Claude Desktop / Claude Code MCP preview integration — tools prefixed with \`mcp__Claude_Preview__\`) can read a \`launch.json\` configuration and launch the dev server on demand when you invoke their preview tool. **Only take this path if you actually have such a tool** — otherwise nothing reads the file and \`wmill dev\` never starts.
+
+The two decisions compose. The common cases:
+
+| Embedder | Needs localhost? | launch.json runtime? | What to do |
+|---|---|---|---|
+| Regular browser tab | No | n/a | Direct mode, you start it, give URL to user |
+| IDE / chat preview pane that takes any URL | No | No | Direct mode, you start it, point the embedder at the printed URL |
+| IDE / chat preview pane that only accepts localhost | Yes | No | Proxy mode, you start it, point the embedder at \`http://localhost:<port>/\` |
+| Claude Desktop / Code MCP preview | Yes | Yes | Proxy mode, write a \`launch.json\` entry, invoke the MCP tool |
+
+Never start the proxy "just in case" — it adds the localhost hop for no benefit when no embedder needs it.
+
+## Starting the server yourself
+
+Use this when no \`launch.json\`-aware runtime is available, regardless of mode.
+
+For flows / scripts:
+\`\`\`bash
+# Direct mode — gives you the remote dev-page URL
+wmill dev --path <wmill_path> --no-open
+
+# Proxy mode — gives you a localhost URL that 302s to the remote dev page
+wmill dev --proxy-port 4000 --path <wmill_path> --no-open
+\`\`\`
+
+For apps:
+\`\`\`bash
+cd <app_path>__raw_app && wmill app dev --no-open --port 4000
+\`\`\`
+
+Each command prints the URL on stdout. Line shapes differ:
+
+- \`wmill dev --no-open\` (direct) prints \`Go to <url>\` with the full remote URL (workspace, token, path baked in).
+- \`wmill dev --proxy-port\` prints \`Dev proxy listening on http://localhost:<port>\` — the URL to hand to an embedder is \`http://localhost:<port>/\`.
+- \`wmill app dev --no-open\` prints \`\uD83D\uDE80 Dev server running at <url>\` — the local app server.
+
+Capture the URL with a loose match (the first \`https?://…\` token after startup) and either hand it to your embedder or relay it to the user: *"Preview is running — open \`<url>\` in your browser."* Don't construct the URL yourself; you don't have the workspace ID or auth token.
+
+These commands are long-running — start them in the background, don't block waiting.
+
+## Letting \`launch.json\` start the server (Claude Desktop / Code MCP only)
+
+Take this path when **and only when** an \`mcp__Claude_Preview__*\` MCP tool is exposed in your tool list. Skip it otherwise — without an MCP tool reading the file, \`wmill dev\` never starts.
+
+**Each flow / script / app gets its own named entry** in the user's \`.claude/launch.json\` so multiple previews coexist without colliding — each entry pins a different port + path. Never reuse a generic "windmill" entry for different targets.
+
+### Step 1 — Reuse or add a per-target entry in \`.claude/launch.json\`
+
+Convention: name the entry \`windmill: <wmill_path>\` (e.g. \`windmill: f/test/my_flow\`).
+
+- **Entry already exists** → reuse it; note its \`port\` for the next step.
+- **Not there** → add one. Pick a port not already taken by another entry (start at 4000 and bump). Shape:
+
+For flows / scripts:
+\`\`\`json
+{
+  "name": "windmill: f/test/my_flow",
+  "runtimeExecutable": "bash",
+  "runtimeArgs": ["-c", "wmill dev --proxy-port \${PORT:-4000} --path f/test/my_flow --no-open"],
+  "port": 4000,
+  "autoPort": true
+}
+\`\`\`
+
+For apps (\`*__raw_app/\`), \`wmill app dev\` is the equivalent — runs from the app folder, no \`--path\`:
+\`\`\`json
+{
+  "name": "windmill: f/test/my_app",
+  "runtimeExecutable": "bash",
+  "runtimeArgs": ["-c", "cd f/test/my_app__raw_app && wmill app dev --no-open --port \${PORT:-4001}"],
+  "port": 4001,
+  "autoPort": true
+}
+\`\`\`
+
+If \`.claude/launch.json\` doesn't exist yet, create it with the standard shell \`{ "version": "0.0.1", "configurations": [...] }\`.
+
+### Step 2 — Invoke the MCP preview tool
+
+Point it at the entry you just added/found. Use \`http://localhost:<port>/\` as the URL — the proxy's redirect at \`/\` is what appends the workspace ID, the auth token, and the path. Do **NOT** construct a \`/dev?...\` URL yourself.
+
+The MCP tool launches the configuration on demand, so you don't need to start the \`wmill dev\` process manually.
+
+## Non-visual alternative
+
+If the user wants a programmatic test rather than a visual one:
+- Flow: \`wmill flow preview <path> -d '<args>'\`
+- Script: \`wmill script preview <path> -d '<args>'\`
+
+Both print the job result, are safe to run yourself, and don't deploy.
+
+## Anti-patterns to avoid
+
+- ❌ Writing a \`.claude/launch.json\` entry when no \`mcp__Claude_Preview__*\` tool is in your tool list. Nothing will read the file; the server never starts. Spawn \`wmill dev\` yourself instead.
+- ❌ Starting the proxy when no embedder needs a localhost URL. Direct mode is the right choice — the proxy is overhead with no purpose.
+- ❌ Reusing a single generic \`launch.json\` entry for every preview target. Each flow/script/app gets its own named entry on its own port — that's how multiple sessions coexist without one preview clobbering another.
+- ❌ Mutating an existing entry's \`--path\` to retarget it. Add a new entry instead.
+- ❌ Constructing \`http://localhost:<port>/dev?path=<X>\` yourself. The proxy's \`/\` redirect is what appends the workspace ID and auth token; bypassing it gives a broken page. Always use \`http://localhost:<port>/\`.
+- ❌ Starting \`wmill dev\` in the foreground (you'll hang). Always background.
+- ❌ Listing both "open in IDE pane" and "open in browser" as a menu — pick one based on context.
 `
 };
 var SCHEMAS = {
@@ -84234,16 +85732,17 @@ var WMILL_INIT_AI_AGENTS_SOURCE_ENV = "WMILL_INIT_AI_AGENTS_SOURCE";
 var WMILL_INIT_AI_CLAUDE_SOURCE_ENV = "WMILL_INIT_AI_CLAUDE_SOURCE";
 var CLAUDE_MD_DEFAULT = `Instructions are in @AGENTS.md
 `;
+var SKILL_TARGET_ROOTS = [".claude", ".agents"];
 async function writeAiGuidanceFiles(options) {
   const nonDottedPaths = options.nonDottedPaths ?? true;
   const skillMetadata = options.skillsSourcePath ? await readSkillMetadataFromDirectory(options.skillsSourcePath) : getGeneratedSkillMetadata();
   const agentsWritten = await writeProjectGuidanceFile({
-    targetPath: join17(options.targetDir, "AGENTS.md"),
+    targetPath: join18(options.targetDir, "AGENTS.md"),
     overwrite: options.overwriteProjectGuidance ?? false,
     content: options.agentsSourcePath != null ? await readTextFile(options.agentsSourcePath) : generateAgentsMdContent(buildSkillsReference(skillMetadata))
   });
   const claudeWritten = await writeProjectGuidanceFile({
-    targetPath: join17(options.targetDir, "CLAUDE.md"),
+    targetPath: join18(options.targetDir, "CLAUDE.md"),
     overwrite: options.overwriteProjectGuidance ?? false,
     content: options.claudeSourcePath != null ? await readTextFile(options.claudeSourcePath) : CLAUDE_MD_DEFAULT
   });
@@ -84263,17 +85762,17 @@ function buildSkillsReference(skills) {
 `);
 }
 async function copySkillsFromSource(targetDir, skillsSourcePath) {
-  const skillsDir = await ensureSkillsDirectory(targetDir);
-  await copyDirectoryContents(skillsSourcePath, skillsDir);
-  return await readSkillMetadataFromDirectory(skillsDir);
+  const skillsDirs = await ensureSkillsDirectories(targetDir);
+  await Promise.all(skillsDirs.map((skillsDir) => copyDirectoryContents(skillsSourcePath, skillsDir)));
+  return await readSkillMetadataFromDirectory(skillsDirs[0]);
 }
 async function writeGeneratedSkills(targetDir, nonDottedPaths) {
-  const skillsDir = await ensureSkillsDirectory(targetDir);
-  await Promise.all(SKILLS.map(async (skill) => {
-    const skillDir = join17(skillsDir, skill.name);
+  const skillsDirs = await ensureSkillsDirectories(targetDir);
+  await Promise.all(skillsDirs.flatMap((skillsDir) => SKILLS.map(async (skill) => {
+    const skillDir = join18(skillsDir, skill.name);
     await mkdir13(skillDir, { recursive: true });
-    await writeFile19(join17(skillDir, "SKILL.md"), renderGeneratedSkillContent(skill.name, nonDottedPaths), "utf8");
-  }));
+    await writeFile20(join18(skillDir, "SKILL.md"), renderGeneratedSkillContent(skill.name, nonDottedPaths), "utf8");
+  })));
   return SKILLS.map((skill) => ({
     ...skill,
     directoryName: skill.name
@@ -84285,15 +85784,15 @@ function getGeneratedSkillMetadata() {
     directoryName: skill.name
   }));
 }
-async function ensureSkillsDirectory(targetDir) {
-  const skillsDir = join17(targetDir, ".claude", "skills");
-  await mkdir13(skillsDir, { recursive: true });
-  return skillsDir;
+async function ensureSkillsDirectories(targetDir) {
+  const skillsDirs = SKILL_TARGET_ROOTS.map((root) => join18(targetDir, root, "skills"));
+  await Promise.all(skillsDirs.map((skillsDir) => mkdir13(skillsDir, { recursive: true })));
+  return skillsDirs;
 }
 async function copyDirectoryContents(sourceDir, targetDir) {
-  const entries = await readdir10(sourceDir, { withFileTypes: true });
+  const entries = await readdir11(sourceDir, { withFileTypes: true });
   await Promise.all(entries.map(async (entry) => {
-    await cp(join17(sourceDir, entry.name), join17(targetDir, entry.name), {
+    await cp(join18(sourceDir, entry.name), join18(targetDir, entry.name), {
       recursive: true,
       force: true
     });
@@ -84330,14 +85829,14 @@ ${schemaDocs.join(`
 `)}`;
 }
 async function readSkillMetadataFromDirectory(skillsDir) {
-  const entries = await readdir10(skillsDir, { withFileTypes: true });
+  const entries = await readdir11(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const skillPath = join17(skillsDir, entry.name, "SKILL.md");
-    if (!await stat17(skillPath).catch(() => null)) {
+    const skillPath = join18(skillsDir, entry.name, "SKILL.md");
+    if (!await stat18(skillPath).catch(() => null)) {
       continue;
     }
     const content = await readTextFile(skillPath);
@@ -84373,10 +85872,10 @@ function parseSkillMetadata(content, fallbackName) {
   return { name, description, directoryName: fallbackName };
 }
 async function writeProjectGuidanceFile(options) {
-  if (!options.overwrite && await stat17(options.targetPath).catch(() => null)) {
+  if (!options.overwrite && await stat18(options.targetPath).catch(() => null)) {
     return false;
   }
-  await writeFile19(options.targetPath, options.content, "utf8");
+  await writeFile20(options.targetPath, options.content, "utf8");
   return true;
 }
 function formatSchemaForMarkdown(schemaYaml, schemaName, filePattern) {
@@ -84860,7 +86359,7 @@ function formatConfigReferenceJson() {
 async function initAction(opts) {
   let didBindWorkspace = false;
   let boundProfile;
-  if (await stat18("wmill.yaml").catch(() => null)) {
+  if (await stat19("wmill.yaml").catch(() => null)) {
     info("wmill.yaml already exists, skipping config generation");
   } else {
     const { isGitRepository: isGitRepository2, getCurrentGitBranch: getCurrentGitBranch2 } = await Promise.resolve().then(() => (init_git(), exports_git));
@@ -84886,13 +86385,16 @@ async function initAction(opts) {
           selectedProfile = profiles.length > 0 ? await getActiveWorkspace(opts) : undefined;
         } else {
           const activeProfile = await getActiveWorkspace(opts);
+          const orderedProfiles = activeProfile ? [
+            ...profiles.filter((p) => p.name === activeProfile.name),
+            ...profiles.filter((p) => p.name !== activeProfile.name)
+          ] : profiles;
           const selectedName = await Select.prompt({
             message: "Select workspace profile",
-            options: profiles.map((p) => ({
-              name: `${p.name} (${p.workspaceId} on ${p.remote})`,
+            options: orderedProfiles.map((p) => ({
+              name: `${p.name} (${p.workspaceId} on ${p.remote})${activeProfile?.name === p.name ? " — active" : ""}`,
               value: p.name
-            })),
-            default: activeProfile?.name
+            }))
           });
           selectedProfile = profiles.find((p) => p.name === selectedName);
         }
@@ -84932,7 +86434,7 @@ async function initAction(opts) {
         boundProfile = activeWorkspace;
       }
     }
-    await writeFile20("wmill.yaml", generateCommentedTemplate(branchName, undefined, wsBindings), "utf-8");
+    await writeFile21("wmill.yaml", generateCommentedTemplate(branchName, undefined, wsBindings), "utf-8");
     info(colors.green("wmill.yaml created with default settings"));
     if (wsBindings && wsBindings.length > 0) {
       didBindWorkspace = true;
@@ -84967,8 +86469,8 @@ async function initAction(opts) {
             });
             if (choice === "cancel") {
               try {
-                await rm4("wmill.yaml");
-                await rm4("wmill-lock.yaml");
+                await rm5("wmill.yaml");
+                await rm5("wmill-lock.yaml");
               } catch {}
               info("Init cancelled");
               process.exit(0);
@@ -85018,7 +86520,7 @@ async function initAction(opts) {
     if (guidanceResult.claudeWritten) {
       info(colors.green("Created CLAUDE.md"));
     }
-    info(colors.green(`Created .claude/skills/ with ${guidanceResult.skillCount} skills`));
+    info(colors.green(`Created .claude/skills/ and .agents/skills/ with ${guidanceResult.skillCount} skills`));
   } catch (error2) {
     if (error2 instanceof Error) {
       warn(`Could not create guidance files: ${error2.message}`);
@@ -85053,7 +86555,7 @@ await __promiseAll([
   init_conf(),
   init_utils()
 ]);
-import * as fs13 from "node:fs/promises";
+import * as fs14 from "node:fs/promises";
 async function pullJobs(opts, workspace) {
   opts = await mergeConfigWithConfigFile(opts);
   const ws = await resolveWorkspace({ ...opts, workspace });
@@ -85097,7 +86599,7 @@ Warning: Found ${workers.length} active worker(s) on the instance.`));
     page++;
   }
   const completedPath = opts.completedOutput || "completed_jobs.json";
-  await fs13.writeFile(completedPath, JSON.stringify(completedJobs, null, 2));
+  await fs14.writeFile(completedPath, JSON.stringify(completedJobs, null, 2));
   info(colors.green(`Successfully pulled ${completedJobs.length} completed jobs to ${completedPath}`));
   let queuedJobs = [];
   page = 1;
@@ -85115,7 +86617,7 @@ Warning: Found ${workers.length} active worker(s) on the instance.`));
     page++;
   }
   const queuedPath = opts.queuedOutput || "queued_jobs.json";
-  await fs13.writeFile(queuedPath, JSON.stringify(queuedJobs, null, 2));
+  await fs14.writeFile(queuedPath, JSON.stringify(queuedJobs, null, 2));
   info(colors.green(`Successfully pulled ${queuedJobs.length} queued jobs to ${queuedPath}`));
   const allJobs = [...queuedJobs, ...completedJobs];
   if (allJobs.length > 0) {
@@ -85990,8 +87492,8 @@ async function generateMetadata2(opts, folder) {
   info("");
   if (errors.length > 0) {
     info(`Done. Updated ${colors.bold(String(succeeded))}/${total} item(s). ${colors.red(String(errors.length) + " failed")}:`);
-    for (const { path: path20, error: error2 } of errors) {
-      error(`  ${path20}: ${error2}`);
+    for (const { path: path21, error: error2 } of errors) {
+      error(`  ${path21}: ${error2}`);
     }
     process.exitCode = 1;
   } else {
@@ -86078,8 +87580,8 @@ var docs_default = command34;
 init_mod3();
 init_log();
 init_colors2();
-var import_yaml40 = __toESM(require_dist(), 1);
-import { writeFile as writeFile22 } from "node:fs/promises";
+var import_yaml41 = __toESM(require_dist(), 1);
+import { writeFile as writeFile23 } from "node:fs/promises";
 await __promiseAll([
   init_conf(),
   init_yaml()
@@ -86133,7 +87635,7 @@ async function migrateAction() {
   } else {
     newConf.workspaces = workspaces;
   }
-  await writeFile22(wmillYamlPath, import_yaml40.stringify(newConf), "utf-8");
+  await writeFile23(wmillYamlPath, import_yaml41.stringify(newConf), "utf-8");
   info(colors.green(`✅ Migrated '${legacyKey}' to 'workspaces' in ${wmillYamlPath}`));
   if (wsNames.length > 0) {
     info(`   Workspace entries: ${wsNames.join(", ")}`);
@@ -86147,7 +87649,7 @@ var config_default = command35;
 
 // src/main.ts
 await init_context();
-var VERSION = "1.691.1";
+var VERSION = "1.692.0";
 async function checkVersionSafe(cmd) {
   const mainCommand = cmd.getMainCommand();
   const upgradeCommand = mainCommand.getCommand("upgrade");