@kw-yeh/vibeflow 4.11.2 → 4.11.4

package/dist/vibeflow.mjs

@@ -257,6 +257,9 @@ var init_pty = __esm({
       scrollback(key) {
         return this.scrollbacks.get(key) ?? null;
       }
+      discardScrollback(key) {
+        this.scrollbacks.delete(key);
+      }
       async isScrolledBack() {
         return false;
       }
@@ -650,7 +653,8 @@ function buildAgentCommand(task, systemPrompt, opts, workspacePath) {
   const customPrompt = resolveSystemPrompt(systemPrompt);
   const sys = [builtInPrompt, libraryPrompt, customPrompt].filter(Boolean).join("\n\n");
   const includeTaskPrompt = opts?.includeTaskPrompt !== false;
-  const prompt = includeTaskPrompt && !opts?.resume ? buildPrompt(task) : "";
+  const prompt = includeTaskPrompt && !opts?.resume ? [buildPrompt(task), opts?.preflightPlan ? `\u524D\u7F6E\u898F\u5283\uFF08\u4F9B\u53C3\u8003\uFF0C\u8ACB\u5148\u6838\u5C0D\u7A0B\u5F0F\u78BC\u518D\u57F7\u884C\uFF09\uFF1A
+${opts.preflightPlan}` : ""].filter(Boolean).join("\n\n") : "";
   const sessionId = agent === "claude" && includeTaskPrompt ? executorSessionId(task.id, task.runId) : void 0;
   return boardEnvPrefix(task, opts) + assembleCommand(
     agent,
@@ -1099,9 +1103,9 @@ var init_progress = __esm({
 
 // packages/tui/src/task-form.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import fs23 from "fs";
+import fs24 from "fs";
 import os9 from "os";
-import path27 from "path";
+import path28 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render as render2, useApp, useInput } from "ink";
 function newFormState(defaultAutoMode, agents) {
@@ -1227,17 +1231,17 @@ function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs23.mkdtempSync(path27.join(os9.tmpdir(), "vibeflow-"));
-  const file = path27.join(dir, "description.md");
+  const dir = fs24.mkdtempSync(path28.join(os9.tmpdir(), "vibeflow-"));
+  const file = path28.join(dir, "description.md");
   try {
-    fs23.writeFileSync(file, text);
+    fs24.writeFileSync(file, text);
     const cmd = editorCommand(process.env, process.platform);
     const r = spawnSync2(`${cmd} "${file}"`, { stdio: "inherit", shell: true });
     if (r.error) return { error: `\u7121\u6CD5\u555F\u52D5\u7DE8\u8F2F\u5668\uFF08${cmd}\uFF09\uFF1A${r.error.message}` };
     if (r.status !== 0) return { error: `\u7DE8\u8F2F\u5668\uFF08${cmd}\uFF09\u7D50\u675F\u78BC ${r.status}\uFF0C\u63CF\u8FF0\u672A\u8B8A\u66F4` };
-    return { text: fs23.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
+    return { text: fs24.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
   } finally {
-    fs23.rmSync(dir, { recursive: true, force: true });
+    fs24.rmSync(dir, { recursive: true, force: true });
   }
 }
 function cycle(list, current, step) {
@@ -1308,10 +1312,10 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
     if (editing === "title") setS((prev) => ({ ...prev, title: draft }));
     else if (editing === "branch") setS((prev) => ({ ...prev, branch: value2 }));
     else if (editing === "project") {
-      if (value2) setProject(path27.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir())));
+      if (value2) setProject(path28.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path27.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir()));
-      if (!fs23.existsSync(file) || !fs23.statSync(file).isFile()) {
+      const file = path28.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir()));
+      if (!fs24.existsSync(file) || !fs24.statSync(file).isFile()) {
         setMessage(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
         return;
       }
@@ -1394,7 +1398,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       case "branch":
         return s.branch || "\uFF08\u7559\u7A7A\u5247\u81EA\u52D5\u547D\u540D\uFF0C\u4F8B\u5982 feature/login-fix\uFF09";
       case "attachments":
-        return s.attachments.length ? s.attachments.map((a) => path27.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
+        return s.attachments.length ? s.attachments.map((a) => path28.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
       case "description": {
         if (!s.description) return "\uFF08Enter \u7528\u7DE8\u8F2F\u5668\u64B0\u5BEB\uFF09";
         const lines = s.description.split("\n");
@@ -1430,7 +1434,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       if (info && !info.isRepo) return "\u9019\u500B\u8CC7\u6599\u593E\u4E0D\u662F Git repository\u3002\u8ACB\u6539\u9078\u4E00\u500B Git \u5C08\u6848\uFF0C\u6216\u5728\u4E0B\u65B9\u521D\u59CB\u5316\u3002";
       if (s.mode === "edit" && projectChanged(s)) return "\u5206\u652F\u6703\u5728\u65B0\u5C08\u6848\u3001\u5361\u7247\u958B\u59CB\u57F7\u884C\u6642\u624D\u5EFA\u7ACB\u3002";
       if (info?.isRepo && !info.hasRemote) return `\u6B64 repository \u6C92\u6709 remote\uFF0C\u5C07\u4EE5\u76EE\u524D\u5206\u652F (${info.currentBranch ?? "HEAD"}) \u70BA\u57FA\u6E96\u5EFA\u7ACB\u672C\u5730 worktree\u3002`;
-      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path27.basename(s.projectPath)}`;
+      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path28.basename(s.projectPath)}`;
     }
     if (field === "branch") {
       const when = info?.hasRemote ? "\u958B\u59CB\u57F7\u884C\u6642\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u4E26\u63A8\u5230 origin\uFF1B\u82E5 remote \u5DF2\u6709\u9019\u500B\u5206\u652F\uFF0C\u5247\u76F4\u63A5\u53D6\u56DE\u4E26\u63A5\u7E8C\u4E0A\u9762\u7684\u5DE5\u4F5C\u3002" : "\u958B\u59CB\u57F7\u884C\u6642\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u3002";
@@ -1558,7 +1562,7 @@ __export(src_exports, {
   showDiff: () => showDiff
 });
 import { spawnSync as spawnSync3 } from "child_process";
-import path28 from "path";
+import path29 from "path";
 import React2, { useEffect as useEffect2, useState as useState2 } from "react";
 import { Box as Box2, Text as Text2, render as render3, useApp as useApp2, useInput as useInput2, useStdout } from "ink";
 function findDetachKey(text) {
@@ -1854,7 +1858,7 @@ function showDiff(task) {
   });
 }
 function tmuxAttach(opts, sessionName) {
-  const conf = path28.join(opts.userDataDir, "tmux.conf");
+  const conf = path29.join(opts.userDataDir, "tmux.conf");
   const inOurServer = (process.env.TMUX ?? "").split(",")[0].endsWith(`/${TMUX_SOCKET}`);
   const args = inOurServer ? ["-L", TMUX_SOCKET, "-f", conf, "switch-client", "-t", `=${sessionName}`] : ["-L", TMUX_SOCKET, "-f", conf, "attach-session", "-t", `=${sessionName}`];
   spawnSync3("tmux", args, { stdio: "inherit", env: { ...process.env, TMUX: inOurServer ? process.env.TMUX : "" } });
@@ -1985,8 +1989,8 @@ var init_src = __esm({
 });
 
 // packages/cli/src/main.ts
-import fs24 from "fs";
-import path29 from "path";
+import fs25 from "fs";
+import path30 from "path";
 import { fileURLToPath } from "url";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -2460,6 +2464,9 @@ function createBridge(t) {
     },
     setBoard: (board) => t.invoke("vibeflow:setBoard", board),
     setSettings: (patch) => t.invoke("vibeflow:setSettings", patch),
+    getJevKeyStatus: () => t.invoke("settings:jevKeyStatus"),
+    saveJevApiKey: (apiKey) => t.invoke("settings:saveJevApiKey", { apiKey }),
+    removeJevApiKey: () => t.invoke("settings:removeJevApiKey"),
     getGithubAuthStatus: () => t.invoke("settings:githubAuthStatus"),
     startGithubAuthLogin: () => t.invoke("settings:startGithubAuthLogin"),
     cancelGithubAuthLogin: () => t.invoke("settings:cancelGithubAuthLogin"),
@@ -2576,6 +2583,7 @@ function createBridge(t) {
        * `sessionKey` defaults to `taskId`.
        */
       start: (payload) => t.invoke("pty:start", payload),
+      startStandalone: (payload) => t.invoke("terminal:start", payload),
       /** Join a running session without restarting it. */
       peek: (sessionKey) => t.invoke("pty:peek", sessionKey),
       /** Which session backend runs terminals, and the sessions it has running. */
@@ -4634,8 +4642,8 @@ async function taskCommand(argv) {
 }
 
 // packages/cli/src/host.ts
-import fs21 from "fs";
-import path25 from "path";
+import fs22 from "fs";
+import path26 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // packages/core/src/events.ts
@@ -5173,10 +5181,10 @@ async function syncBuiltinsAtStartup() {
 }
 
 // packages/core/src/service.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import os8 from "os";
-import path22 from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+import path23 from "path";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // packages/core/src/agent-models.ts
 import fs13 from "fs";
@@ -5529,6 +5537,170 @@ function createModelCatalog(opts) {
   };
 }
 
+// packages/core/src/jev-router.ts
+init_launch();
+var API_URL = "https://api.typesafe.ai/v1/systemone";
+var MAX_TASK_CHARS = 12e3;
+var MAX_PLAN_CHARS = 8e3;
+function tier(model, agent) {
+  const name = `${model.id} ${model.label}`.toLowerCase();
+  if (/haiku|mini|nano|luna|flash/.test(name)) return 0;
+  if (/opus|astra|pro\b/.test(name)) return 2;
+  if (agent === "codex" && /gpt-5\.5|gpt-5\.4(?!-mini)/.test(name)) return 2;
+  return 1;
+}
+function routeCandidates(agent, models) {
+  const valid = models.filter((m) => /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(m.id));
+  const byTier = /* @__PURE__ */ new Map();
+  for (const model of valid) {
+    const rank = tier(model, agent);
+    if (!byTier.has(rank)) byTier.set(rank, model);
+  }
+  return [...byTier.entries()].sort(([a], [b]) => a - b).map(([, model]) => model);
+}
+function isChoice(value) {
+  return !!value && typeof value === "object" && value.type === "choice" && typeof value.choice === "string";
+}
+function createJevRouter(opts = {}) {
+  const getApiKey = opts.getApiKey ?? (() => opts.apiKey ?? process.env.TYPESAFE_API_KEY?.trim());
+  const fetcher = opts.fetcher ?? fetch;
+  const planner = opts.planner ?? (async (agent, model, prompt, cwd) => {
+    const args = agent === "claude" ? ["-p", "--model", model, "--permission-mode", "plan"] : ["exec", "--model", model, "--sandbox", "read-only", "--skip-git-repo-check", "-"];
+    return (opts.printAgent ?? runAgentPrint)(agent, args, prompt, { cwd, timeout: 12e4, maxBuffer: 128 * 1024 });
+  });
+  async function ask(state, questions) {
+    const apiKey = getApiKey();
+    if (!apiKey) throw new Error("\u672A\u8A2D\u5B9A Jev API key\uFF08\u53EF\u5728\u8A2D\u5B9A\u4E2D\u8F38\u5165\u6216\u63D0\u4F9B TYPESAFE_API_KEY\uFF09");
+    const response = await fetcher(API_URL, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "jev-latest", state, questions }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) throw new Error(`Jev API \u56DE\u61C9 ${response.status}`);
+    const body = await response.json();
+    if (!body.answers) throw new Error("Jev API \u6C92\u6709\u56DE\u50B3\u5224\u65B7");
+    return body.answers;
+  }
+  return {
+    get enabled() {
+      return Boolean(getApiKey());
+    },
+    async route(task, catalog) {
+      const agent = task.agentCli === "codex" ? "codex" : "claude";
+      const candidates = routeCandidates(agent, catalog);
+      if (candidates.length === 0) return { status: "fallback", reason: "\u6A21\u578B\u6E05\u55AE\u6C92\u6709\u53EF\u7528\u7684\u6A21\u578B" };
+      const expensive = candidates[candidates.length - 1];
+      const taskText = buildPrompt(task).slice(0, MAX_TASK_CHARS);
+      try {
+        const first = await ask({ task: taskText, agent }, {
+          complexity: {
+            type: "choice",
+            instructions: "How difficult is this software task to implement correctly?",
+            criteria: {
+              simple: "Small, well scoped and routine",
+              moderate: "Some design choices or multiple files",
+              complex: "Architecture, ambiguous requirements, high risk, or many interacting parts"
+            }
+          },
+          preparation: {
+            type: "choice",
+            instructions: "Would a separate read-only planning pass materially improve the implementation?",
+            criteria: {
+              direct: "The request is clear enough to start implementation directly",
+              plan: "The request is unclear, broad or complex enough to benefit from a plan first"
+            }
+          }
+        });
+        if (!isChoice(first.complexity) || !isChoice(first.preparation) || !["simple", "moderate", "complex"].includes(first.complexity.choice) || !["direct", "plan"].includes(first.preparation.choice)) throw new Error("Jev \u56DE\u50B3\u4E0D\u53D7\u652F\u63F4\u7684\u5224\u65B7");
+        let plan;
+        if (first.preparation.choice === "plan") {
+          if (!task.worktreePath) throw new Error("\u898F\u5283\u6642\u627E\u4E0D\u5230 worktree");
+          const instruction = `Read the repository and make a concise implementation plan for the following task. Do not edit files. Identify unclear requirements, affected areas, and verification. Return only the plan.
+
+${taskText}`;
+          plan = (await planner(agent, expensive.id, instruction, task.worktreePath)).trim().slice(0, MAX_PLAN_CHARS);
+          if (!plan) throw new Error("\u898F\u5283\u6A21\u578B\u6C92\u6709\u56DE\u50B3\u8A08\u756B");
+        }
+        const options = Object.fromEntries(candidates.map((m) => [
+          m.id,
+          `${m.label}; relative cost tier ${tier(m, agent) + 1}/3 (${tier(m, agent) === 2 ? "highest capability" : tier(m, agent) === 0 ? "lowest cost" : "balanced"})`
+        ]));
+        const second = await ask({ task: taskText, complexity: first.complexity.choice, plan }, {
+          model: {
+            type: "choice",
+            instructions: "Choose the lowest-cost available model likely to implement this task correctly. Prefer more capable models as complexity or uncertainty rises.",
+            criteria: options
+          }
+        });
+        if (!isChoice(second.model) || !candidates.some((m) => m.id === second.model.choice)) {
+          throw new Error("Jev \u9078\u4E86\u4E0D\u5728\u6A21\u578B\u6E05\u55AE\u4E2D\u7684\u6A21\u578B");
+        }
+        return {
+          status: "routed",
+          model: second.model.choice,
+          ...plan ? { plannerModel: expensive.id, plan } : {}
+        };
+      } catch (err) {
+        return { status: "fallback", reason: err instanceof Error ? err.message : String(err) };
+      }
+    }
+  };
+}
+
+// packages/core/src/jev-credentials.ts
+import fs14 from "fs";
+import path18 from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+function keyPath(dir) {
+  return path18.join(dir, "jev-api-key");
+}
+function dataDir() {
+  return getPlatform().userDataDir();
+}
+function readJevApiKey(dir = dataDir()) {
+  try {
+    const file = keyPath(dir);
+    if (fs14.lstatSync(file).isSymbolicLink()) throw new Error("Jev key file must not be a symlink");
+    const saved = fs14.readFileSync(file, "utf8").trim();
+    if (saved) return saved;
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  return process.env.TYPESAFE_API_KEY?.trim() || void 0;
+}
+function jevKeyStatus(dir = dataDir()) {
+  try {
+    const file = keyPath(dir);
+    if (fs14.lstatSync(file).isSymbolicLink()) throw new Error("Jev key file must not be a symlink");
+    if (fs14.readFileSync(file, "utf8").trim()) return { configured: true, source: "saved" };
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  return process.env.TYPESAFE_API_KEY?.trim() ? { configured: true, source: "environment" } : { configured: false, source: "none" };
+}
+function saveJevApiKey(value, dir = dataDir()) {
+  const key = value.trim();
+  if (!key || key.length > 4096 || !/^[\x21-\x7e]+$/.test(key)) {
+    throw new Error("Jev API key \u683C\u5F0F\u7121\u6548");
+  }
+  fs14.mkdirSync(dir, { recursive: true, mode: 448 });
+  const file = keyPath(dir);
+  const tmp = `${file}.${randomUUID3()}.tmp`;
+  try {
+    fs14.writeFileSync(tmp, key, { mode: 384, flag: "wx" });
+    fs14.renameSync(tmp, file);
+    if (process.platform !== "win32") fs14.chmodSync(file, 384);
+  } finally {
+    fs14.rmSync(tmp, { force: true });
+  }
+  return { configured: true, source: "saved" };
+}
+function removeJevApiKey(dir = dataDir()) {
+  fs14.rmSync(keyPath(dir), { force: true });
+  return jevKeyStatus(dir);
+}
+
 // packages/core/src/service.ts
 init_effort();
 
@@ -6031,45 +6203,45 @@ function createJiraService(options) {
 }
 
 // packages/core/src/board-cli.ts
-import fs14 from "fs";
-import path18 from "path";
+import fs15 from "fs";
+import path19 from "path";
 import { pathToFileURL } from "url";
 async function boardCliLaunchInfo() {
-  const storeDir = path18.dirname(getStorePath());
+  const storeDir = path19.dirname(getStorePath());
   const entry = getPlatform().cliEntry?.();
-  if (entry && fs14.existsSync(entry)) return { storeDir, cliPath: entry };
+  if (entry && fs15.existsSync(entry)) return { storeDir, cliPath: entry };
   const root = getPlatform().sourceRoot();
   if (!root) return { storeDir };
-  const cliPath = path18.join(root, "scripts", "vibeflow.mjs");
-  const loaderPath = path18.join(root, "test", "support", "register.mjs");
-  if (!fs14.existsSync(cliPath) || !fs14.existsSync(loaderPath)) return { storeDir };
+  const cliPath = path19.join(root, "scripts", "vibeflow.mjs");
+  const loaderPath = path19.join(root, "test", "support", "register.mjs");
+  if (!fs15.existsSync(cliPath) || !fs15.existsSync(loaderPath)) return { storeDir };
   return { storeDir, cliPath, loaderPath: pathToFileURL(loaderPath).href };
 }
 
 // packages/core/src/decisions.ts
-import fs15 from "fs";
-import path19 from "path";
+import fs16 from "fs";
+import path20 from "path";
 var DECISIONS_FILE_SUFFIX = ".DECISIONS.md";
 function decisionsKey(worktreePath, branch) {
-  return worktreePath ? path19.basename(worktreePath) : branch.replace(/\//g, "-");
+  return worktreePath ? path20.basename(worktreePath) : branch.replace(/\//g, "-");
 }
 function decisionsPath(workspacePath, key) {
-  return path19.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
+  return path20.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
 }
 function deleteDecisions(workspacePath, key) {
   try {
-    fs15.rmSync(decisionsPath(workspacePath, key), { force: true });
+    fs16.rmSync(decisionsPath(workspacePath, key), { force: true });
   } catch {
   }
 }
 
 // packages/core/src/specs.ts
-import fs16 from "fs";
-import path20 from "path";
+import fs17 from "fs";
+import path21 from "path";
 var SPEC_FILE_NAME = "spec.md";
 var MAX_SPEC_BYTES = 256 * 1024;
 function isSpecPath(p) {
-  return path20.posix.basename(p) === SPEC_FILE_NAME;
+  return path21.posix.basename(p) === SPEC_FILE_NAME;
 }
 function clip2(buf) {
   return {
@@ -6084,10 +6256,10 @@ async function readWorktreeSpecs(worktreePath, baseBranch) {
   for (const entry of entries) {
     if (entry.status === "D" || !isSpecPath(entry.path)) continue;
     try {
-      const full = path20.join(worktreePath, entry.path);
-      const stat = fs16.statSync(full);
+      const full = path21.join(worktreePath, entry.path);
+      const stat = fs17.statSync(full);
       if (!stat.isFile()) continue;
-      specs.push({ path: entry.path, ...clip2(fs16.readFileSync(full)), updatedAt: stat.mtimeMs });
+      specs.push({ path: entry.path, ...clip2(fs17.readFileSync(full)), updatedAt: stat.mtimeMs });
     } catch {
     }
   }
@@ -6153,7 +6325,7 @@ async function readSpecsAt(cwd, ref, paths) {
 init_env();
 init_git_bash();
 import { spawn as spawn7 } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // packages/core/src/chat-store.ts
 var _chatStore = null;
@@ -6283,7 +6455,7 @@ function sendChatMessage(opts, sender) {
   const fullText = attachmentLines.length ? `${text}
 
 ${attachmentLines.join("\n")}` : text;
-  const userMsgId = randomUUID3().slice(0, 8);
+  const userMsgId = randomUUID4().slice(0, 8);
   appendMessage(taskId, {
     id: userMsgId,
     role: "user",
@@ -6402,7 +6574,7 @@ ${attachmentLines.join("\n")}` : text;
   proc.on("close", (code2) => {
     const assistantText = accumulated || "\uFF08\u7121\u56DE\u61C9\uFF09";
     appendMessage(taskId, {
-      id: randomUUID3().slice(0, 8),
+      id: randomUUID4().slice(0, 8),
       role: "assistant",
       text: assistantText,
       ts: Date.now()
@@ -6439,17 +6611,17 @@ init_launch();
 // packages/core/src/progress-tracker.ts
 init_progress();
 init_launch();
-import fs17 from "fs";
+import fs18 from "fs";
 import os7 from "os";
-import path21 from "path";
+import path22 from "path";
 var SINCE_SLACK_MS = 5e3;
 function claudeProjectDir(home, cwd) {
-  return path21.join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+  return path22.join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
 }
 function pathAliases(p) {
-  const resolved = path21.resolve(p);
+  const resolved = path22.resolve(p);
   try {
-    const real = fs17.realpathSync(resolved);
+    const real = fs18.realpathSync(resolved);
     return real === resolved ? [resolved] : [resolved, real];
   } catch {
     return [resolved];
@@ -6465,7 +6637,7 @@ function samePath(a, b) {
 }
 function listFiles(dir, test) {
   try {
-    return fs17.readdirSync(dir).filter(test).map((name) => path21.join(dir, name));
+    return fs18.readdirSync(dir).filter(test).map((name) => path22.join(dir, name));
   } catch {
     return [];
   }
@@ -6473,22 +6645,22 @@ function listFiles(dir, test) {
 function firstLine(file) {
   let fd;
   try {
-    fd = fs17.openSync(file, "r");
+    fd = fs18.openSync(file, "r");
     const buf = Buffer.alloc(64 * 1024);
-    const n = fs17.readSync(fd, buf, 0, buf.length, 0);
+    const n = fs18.readSync(fd, buf, 0, buf.length, 0);
     const text = buf.subarray(0, n).toString("utf8");
     const nl = text.indexOf("\n");
     return nl === -1 ? null : text.slice(0, nl);
   } catch {
     return null;
   } finally {
-    if (fd !== void 0) fs17.closeSync(fd);
+    if (fd !== void 0) fs18.closeSync(fd);
   }
 }
 function advance(file, cursor, reduce, initial) {
   let size;
   try {
-    size = fs17.statSync(file).size;
+    size = fs18.statSync(file).size;
   } catch {
     return;
   }
@@ -6500,9 +6672,9 @@ function advance(file, cursor, reduce, initial) {
   if (size === cursor.offset) return;
   let fd;
   try {
-    fd = fs17.openSync(file, "r");
+    fd = fs18.openSync(file, "r");
     const chunk = Buffer.alloc(size - cursor.offset);
-    const n = fs17.readSync(fd, chunk, 0, chunk.length, cursor.offset);
+    const n = fs18.readSync(fd, chunk, 0, chunk.length, cursor.offset);
     cursor.offset += n;
     const data = Buffer.concat([cursor.rest, chunk.subarray(0, n)]);
     const nl = data.lastIndexOf(10);
@@ -6516,7 +6688,7 @@ function advance(file, cursor, reduce, initial) {
     }
   } catch {
   } finally {
-    if (fd !== void 0) fs17.closeSync(fd);
+    if (fd !== void 0) fs18.closeSync(fd);
   }
 }
 function newCursor(state) {
@@ -6535,14 +6707,14 @@ function codexDayDirs(sessionsRoot, since) {
   const cur = new Date(start.getFullYear(), start.getMonth(), start.getDate());
   while (cur <= end) {
     const pad = (n) => String(n).padStart(2, "0");
-    days.push(path21.join(sessionsRoot, String(cur.getFullYear()), pad(cur.getMonth() + 1), pad(cur.getDate())));
+    days.push(path22.join(sessionsRoot, String(cur.getFullYear()), pad(cur.getMonth() + 1), pad(cur.getDate())));
     cur.setDate(cur.getDate() + 1);
   }
   return days;
 }
 function createProgressTracker(opts) {
   const home = opts.homeDir ?? os7.homedir();
-  const codexHomes = opts.codexHomes ?? (() => [path21.join(home, ".codex")]);
+  const codexHomes = opts.codexHomes ?? (() => [path22.join(home, ".codex")]);
   const pollMs = opts.pollMs ?? 2e3;
   const entries = /* @__PURE__ */ new Map();
   const belongsToRun = (target, startedAt) => target.since == null || startedAt != null && startedAt >= target.since - SINCE_SLACK_MS;
@@ -6551,7 +6723,7 @@ function createProgressTracker(opts) {
     const dirs = pathAliases(target.worktreePath).map((p) => claudeProjectDir(home, p));
     for (const file of dirs.flatMap((dir) => listFiles(dir, (n) => n.endsWith(".jsonl")))) {
       if (entry.claude.has(file) || entry.rejected.has(file)) continue;
-      const session = path21.basename(file, ".jsonl");
+      const session = path22.basename(file, ".jsonl");
       if (session !== target.sessionId) {
         const head = firstLine(file);
         if (head == null) continue;
@@ -6564,8 +6736,8 @@ function createProgressTracker(opts) {
       entry.claude.set(file, newCursor(initialClaudeState()));
     }
     for (const file of Array.from(entry.claude.keys())) {
-      if (file.includes(`${path21.sep}subagents${path21.sep}`)) continue;
-      const sub = path21.join(file.slice(0, -".jsonl".length), "subagents");
+      if (file.includes(`${path22.sep}subagents${path22.sep}`)) continue;
+      const sub = path22.join(file.slice(0, -".jsonl".length), "subagents");
       for (const f of listFiles(sub, (n) => n.endsWith(".jsonl"))) {
         if (!entry.claude.has(f)) entry.claude.set(f, newCursor(initialClaudeState()));
       }
@@ -6574,7 +6746,7 @@ function createProgressTracker(opts) {
   function discoverCodex(entry) {
     const { target } = entry;
     for (const codexHome of codexHomes()) {
-      for (const day of codexDayDirs(path21.join(codexHome, "sessions"), target.since)) {
+      for (const day of codexDayDirs(path22.join(codexHome, "sessions"), target.since)) {
         for (const file of listFiles(day, (n) => n.startsWith("rollout-") && n.endsWith(".jsonl"))) {
           if (entry.codex.has(file) || entry.rejected.has(file)) continue;
           const head = firstLine(file);
@@ -6591,11 +6763,11 @@ function createProgressTracker(opts) {
     }
   }
   function drainHooks(entry) {
-    const dir = path21.join(entry.target.worktreePath, PROGRESS_EVENTS_DIR);
+    const dir = path22.join(entry.target.worktreePath, PROGRESS_EVENTS_DIR);
     for (const file of listFiles(dir, (n) => n.endsWith(".json")).sort()) {
       try {
-        const at = fs17.statSync(file).mtimeMs;
-        const event = JSON.parse(fs17.readFileSync(file, "utf8"));
+        const at = fs18.statSync(file).mtimeMs;
+        const event = JSON.parse(fs18.readFileSync(file, "utf8"));
         const foreign = entry.target.sessionId && typeof event.session_id === "string" && event.session_id !== entry.target.sessionId;
         const activity = foreign ? null : activityFromHook(event, at);
         if (activity) entry.hookActivity = latestActivity(entry.hookActivity ?? activity, activity);
@@ -6603,7 +6775,7 @@ function createProgressTracker(opts) {
         continue;
       }
       try {
-        fs17.unlinkSync(file);
+        fs18.unlinkSync(file);
       } catch {
       }
     }
@@ -6615,8 +6787,8 @@ function createProgressTracker(opts) {
     if (target.agent === "claude") {
       for (const [file, cursor] of entry.claude) {
         runUsage = addUsage(runUsage, claudeUsageTotal(cursor.state));
-        if (file.includes(`${path21.sep}subagents${path21.sep}`)) continue;
-        const isExecutor = path21.basename(file, ".jsonl") === target.sessionId;
+        if (file.includes(`${path22.sep}subagents${path22.sep}`)) continue;
+        const isExecutor = path22.basename(file, ".jsonl") === target.sessionId;
         const s = cursor.state;
         if (isExecutor || !target.sessionId && (!primary || (s.startedAt ?? 0) > (primary.startedAt ?? 0))) {
           primary = { todos: s.todos, contextTokens: s.contextTokens, activity: s.activity, startedAt: s.startedAt };
@@ -6695,10 +6867,10 @@ function createProgressTracker(opts) {
       };
       entry.timer.unref?.();
       entries.set(target.taskId, entry);
-      const eventsDir = path21.join(target.worktreePath, PROGRESS_EVENTS_DIR);
+      const eventsDir = path22.join(target.worktreePath, PROGRESS_EVENTS_DIR);
       try {
-        fs17.mkdirSync(eventsDir, { recursive: true });
-        entry.watcher = fs17.watch(eventsDir, () => {
+        fs18.mkdirSync(eventsDir, { recursive: true });
+        entry.watcher = fs18.watch(eventsDir, () => {
           if (entry.pending) return;
           entry.pending = setTimeout(() => {
             entry.pending = null;
@@ -6783,9 +6955,12 @@ function validBoard(value) {
   }
   return next;
 }
-function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatus, acliRunner, jiraAuthStatus, modelCatalog }) {
+function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatus, acliRunner, jiraAuthStatus, modelCatalog, jevRouter }) {
   const sink = bus.sink();
   const models = modelCatalog ?? createModelCatalog({ version });
+  const router = jevRouter ?? createJevRouter({ getApiKey: readJevApiKey });
+  const routing = /* @__PURE__ */ new Map();
+  const standaloneTerminals = /* @__PURE__ */ new Map();
   let libraryCodexHome = null;
   void libraryRoot().then((root) => {
     libraryCodexHome = libraryPaths(root).codexHome;
@@ -6794,7 +6969,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
   const home = homeDir ?? os8.homedir();
   const progress = createProgressTracker({
     homeDir: home,
-    codexHomes: () => [path22.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
+    codexHomes: () => [path23.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
     onUpdate: (taskId, value) => bus.emit("progress:update", { taskId, progress: value }),
     onNotify: (taskId, list) => {
       const prefs = resolveNotificationSettings(getSettings());
@@ -6840,7 +7015,10 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
   } catch {
   }
   async function teardownSession(key) {
+    const standalone = standaloneTerminals.has(key);
     await sessions.kill(key);
+    if (standalone) sessions.discardScrollback?.(key);
+    standaloneTerminals.delete(key);
     unwatchSubAgents(key);
   }
   async function teardownTask(taskId) {
@@ -6855,39 +7033,57 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
   }
   function requireSessionKey(sessionKey) {
     const key = str(sessionKey, "sessionKey");
+    if (standaloneTerminals.has(key)) return key;
     requireTask(key.split(":")[0]);
     return key;
   }
-  function launchEffort(task) {
-    const model = models.findModel(taskAgent(task), taskModel(task));
+  function launchEffort(task, selectedModel = taskModel(task)) {
+    const model = models.findModel(taskAgent(task), selectedModel);
     return model?.efforts ? clampEffort(task.effort, model.efforts) : task.effort;
   }
   async function launchCommand(task, intent) {
     const settings = getSettings();
     const library = await libraryLaunchInfo(task.worktreePath);
     const boardCli = await boardCliLaunchInfo();
+    let route = task.model?.trim() ? void 0 : task.jevRoute;
+    if (!task.model?.trim() && !intent.resume && intent.includeTaskPrompt !== false) {
+      let pending = routing.get(task.id);
+      if (!pending) {
+        pending = (async () => {
+          const candidateModels = (await (router.enabled === false ? models.get(taskAgent(task)) : models.refresh(taskAgent(task)))).models;
+          const selected = await router.route(task, candidateModels);
+          updateTask(task.id, { jevRoute: selected });
+          bus.emit("state:changed", getState());
+          return selected;
+        })().finally(() => routing.delete(task.id));
+        routing.set(task.id, pending);
+      }
+      route = await pending;
+    }
+    const selectedModel = task.model?.trim() ? taskModel(task) : route?.model;
     return buildAgentCommand(
-      { ...task, effort: launchEffort(task) },
+      { ...task, model: selectedModel, effort: launchEffort(task, selectedModel) },
       settings.systemPrompt ?? "",
       {
         resume: intent.resume === true,
         includeTaskPrompt: intent.includeTaskPrompt !== false,
         library: library ?? void 0,
         boardCli,
-        autoMode: task.autoMode ?? settings.autoMode
+        autoMode: task.autoMode ?? settings.autoMode,
+        preflightPlan: !intent.resume ? route?.plan : void 0
       },
       task.workspacePath
     );
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path22.join(os8.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path23.join(os8.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
   }
   async function removeTaskWorktree(task) {
     if (!task.projectPath || !task.worktreePath) return;
     const branch = task.branch || fallbackBranchName(task.id);
     await removeWorktree(task.projectPath, task.worktreePath);
-    deleteArtifacts(task.workspacePath ?? path22.dirname(task.worktreePath), task.worktreePath);
+    deleteArtifacts(task.workspacePath ?? path23.dirname(task.worktreePath), task.worktreePath);
     await deleteBranch(task.projectPath, branch);
   }
   function columnOf(taskId) {
@@ -6968,6 +7164,12 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       setSettings(value);
       return getState();
     },
+    "settings:jevKeyStatus": () => jevKeyStatus(),
+    "settings:saveJevApiKey": (payload) => {
+      const p = obj(payload, "payload");
+      return saveJevApiKey(str(p.apiKey, "apiKey"));
+    },
+    "settings:removeJevApiKey": () => removeJevApiKey(),
     "settings:githubAuthStatus": () => getGitHubCliAuthStatus(),
     "settings:startGithubAuthLogin": () => {
       startGitHubCliLogin((payload) => bus.emit("github-auth:event", payload));
@@ -7023,8 +7225,8 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "projects:listRecent": () => listRecentProjects(getStore()),
     // `vibeflow open <path>` while a host runs: only the host writes the store.
     "projects:record": (projectPath) => {
-      const p = path22.resolve(str(projectPath, "projectPath"));
-      if (!fs18.existsSync(p) || !fs18.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
+      const p = path23.resolve(str(projectPath, "projectPath"));
+      if (!fs19.existsSync(p) || !fs19.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
       recordRecentProject(getStore(), p);
       return listRecentProjects(getStore());
     },
@@ -7069,7 +7271,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       if (!task.worktreePath) {
         await teardownTask(task.id);
         progress.untrack(task.id);
-        updateTask(task.id, { launchedAt: Date.now(), runId: randomUUID4() });
+        updateTask(task.id, { launchedAt: Date.now(), runId: randomUUID5(), jevRoute: void 0 });
         const reset2 = findTask(task.id);
         if (!reset2) throw new Error("\u627E\u4E0D\u5230\u8981\u91CD\u7F6E\u7684\u4EFB\u52D9");
         return { state: getState(), task: reset2 };
@@ -7077,13 +7279,13 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       if (!task.baseBranch) throw new Error("\u4EFB\u52D9\u6C92\u6709\u8A18\u9304 base branch\uFF0C\u7121\u6CD5\u9084\u539F worktree");
       await teardownTask(task.id);
       await resetWorktreeToBase(task.worktreePath, task.baseBranch);
-      const workspacePath = task.workspacePath ?? path22.dirname(task.worktreePath);
+      const workspacePath = task.workspacePath ?? path23.dirname(task.worktreePath);
       deleteArtifacts(workspacePath, task.worktreePath);
       deleteDecisions(workspacePath, decisionsKey(task.worktreePath, task.branch));
       resetSubAgents(task.worktreePath);
       const usage = usageThroughCurrentRun(task);
       progress.untrack(task.id);
-      updateTask(task.id, { launchedAt: Date.now(), runId: randomUUID4(), ...usage ? { usage } : {} });
+      updateTask(task.id, { launchedAt: Date.now(), runId: randomUUID5(), jevRoute: void 0, ...usage ? { usage } : {} });
       const reset = findTask(task.id);
       if (!reset) throw new Error("\u627E\u4E0D\u5230\u8981\u91CD\u7F6E\u7684\u4EFB\u52D9");
       bus.emit("subagents:update", { taskId: task.id, subAgents: [] });
@@ -7121,7 +7323,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
         }
         const info = await getGitInfo(nextProject);
         if (!info.isRepo) throw new Error("\u76EE\u6A19\u8CC7\u6599\u593E\u4E0D\u662F git repository");
-        const projectName = path22.basename(nextProject);
+        const projectName = path23.basename(nextProject);
         const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
         await teardownTask(existing.id);
         await removeTaskWorktree(existing);
@@ -7145,6 +7347,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
         description: p.description?.trim() || void 0,
         agentCli: p.agentCli,
         model: p.model || void 0,
+        jevRoute: void 0,
         effort: p.effort,
         autoMode: p.autoMode,
         ...gitPatch
@@ -7190,6 +7393,26 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       }
       return result;
     },
+    "terminal:start": async (payload) => {
+      const p = obj(payload, "payload");
+      const key = str(p.sessionKey, "sessionKey");
+      if (!/^terminal_[0-9a-f-]{36}$/.test(key)) invalid("invalid standalone terminal key");
+      if (Boolean(p.taskId) === Boolean(p.projectPath)) invalid("provide taskId or projectPath");
+      const cwd = str(p.taskId ? requireTask(p.taskId).projectPath : p.projectPath, "projectPath");
+      if (!path23.isAbsolute(cwd) || !fs19.existsSync(cwd) || !fs19.statSync(cwd).isDirectory()) {
+        invalid("projectPath must be an existing absolute directory");
+      }
+      const previous = standaloneTerminals.get(key);
+      if (previous && previous !== cwd) invalid("terminal key already belongs to another directory");
+      const result = await sessions.start(key, {
+        cwd,
+        cols: typeof p.cols === "number" ? p.cols : void 0,
+        rows: typeof p.rows === "number" ? p.rows : void 0
+      });
+      standaloneTerminals.set(key, cwd);
+      if (!p.taskId) recordRecentProject(getStore(), cwd);
+      return result;
+    },
     // Join a session as it is: no restart, for a frontend that attaches
     // after it started (the TUI's terminal view).
     "pty:peek": async (sessionKey) => {
@@ -7215,7 +7438,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "claude:sessionExists": (taskId) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return false;
-      return fs18.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
+      return fs19.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
     },
     "sessions:list": async () => {
       const keys = await sessions.list();
@@ -7234,9 +7457,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "git:getDiffEntries": (taskId, opts) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return [];
-      const fetch = opts && typeof opts === "object" ? opts.fetch : void 0;
+      const fetch2 = opts && typeof opts === "object" ? opts.fetch : void 0;
       return getWorktreeDiffEntries(task.worktreePath, task.baseBranch ?? "HEAD", {
-        fetch: typeof fetch === "boolean" ? fetch : void 0
+        fetch: typeof fetch2 === "boolean" ? fetch2 : void 0
       });
     },
     "git:getDiffFile": (taskId, filePath) => {
@@ -7262,7 +7485,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       const task = requireTask(taskId);
       if (!task.worktreePath || !task.workspacePath) return "task has no worktree";
       const dir = agentArtifactsPath(task.workspacePath, task.worktreePath);
-      if (!fs18.existsSync(dir)) return "artifacts directory does not exist yet";
+      if (!fs19.existsSync(dir)) return "artifacts directory does not exist yet";
       return getPlatform().openPath(dir);
     },
     "task:getSpecs": async (taskId) => {
@@ -7396,7 +7619,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       }
       await removeTaskWorktree(task);
       if (task.workspacePath) {
-        fs18.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
+        fs19.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
       }
       clearConversation(task.id);
       removeTask(task.id);
@@ -7436,7 +7659,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       );
     },
     "chat:compact": (taskId) => {
-      const newSessionId = randomUUID4();
+      const newSessionId = randomUUID5();
       clearMessages(requireTask(taskId).id, newSessionId);
       return { newSessionId };
     }
@@ -7449,9 +7672,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     // Watch the containing directory, not the file: JsonStore renames a temp
     // file over the target and so replaces the inode on every save.
     watchStore() {
-      const file = path22.basename(getStorePath());
+      const file = path23.basename(getStorePath());
       let debounce = null;
-      storeWatcher = fs18.watch(path22.dirname(getStorePath()), (_event, filename) => {
+      storeWatcher = fs19.watch(path23.dirname(getStorePath()), (_event, filename) => {
         if (filename !== file) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -7488,9 +7711,9 @@ function createSessionBackend(sink, choice) {
 }
 
 // packages/core/src/web-server.ts
-import fs19 from "fs";
+import fs20 from "fs";
 import http from "http";
-import path23 from "path";
+import path24 from "path";
 import { timingSafeEqual } from "crypto";
 import { WebSocketServer } from "ws";
 var TOKEN_COOKIE = "vf_token";
@@ -7543,14 +7766,14 @@ function resolveStatic(root, urlPath) {
     return null;
   }
   if (decoded.includes("\0")) return null;
-  const rel = path23.posix.normalize(decoded).replace(/^\/+/, "");
-  const base2 = path23.resolve(root);
-  const candidates = [rel, path23.posix.join(rel, "index.html"), `${rel}.html`];
+  const rel = path24.posix.normalize(decoded).replace(/^\/+/, "");
+  const base2 = path24.resolve(root);
+  const candidates = [rel, path24.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path23.resolve(base2, c);
-    if (full !== base2 && !full.startsWith(base2 + path23.sep)) return null;
+    const full = path24.resolve(base2, c);
+    if (full !== base2 && !full.startsWith(base2 + path24.sep)) return null;
     try {
-      if (fs19.statSync(full).isFile()) return full;
+      if (fs20.statSync(full).isFile()) return full;
     } catch {
     }
   }
@@ -7611,7 +7834,7 @@ async function startWebServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const ext = path23.extname(file).toLowerCase();
+    const ext = path24.extname(file).toLowerCase();
     const immutable = url.pathname.startsWith("/_next/static/");
     res.writeHead(200, {
       "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream",
@@ -7624,7 +7847,7 @@ async function startWebServer(options) {
       res.end();
       return;
     }
-    fs19.createReadStream(file).pipe(res);
+    fs20.createReadStream(file).pipe(res);
   }
   const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
   function reject(socket, status, reason) {
@@ -7723,8 +7946,8 @@ Content-Length: 0\r
 }
 
 // packages/cli/src/update-command.ts
-import fs20 from "node:fs";
-import path24 from "node:path";
+import fs21 from "node:fs";
+import path25 from "node:path";
 import { spawnSync } from "node:child_process";
 function npmRunner(args, inherit) {
   const windows = process.platform === "win32";
@@ -7737,7 +7960,7 @@ function npmRunner(args, inherit) {
 }
 function packageName(packageRoot) {
   try {
-    const pkg = JSON.parse(fs20.readFileSync(path24.join(packageRoot, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs21.readFileSync(path25.join(packageRoot, "package.json"), "utf8"));
     if (typeof pkg.name !== "string") return null;
     return /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/i.test(pkg.name) ? pkg.name : null;
   } catch {
@@ -7752,7 +7975,7 @@ function runUpdate(options) {
     error("vibeflow update \u53EA\u9069\u7528\u65BC\u5168\u57DF npm \u5B89\u88DD\uFF1B\u76EE\u524D\u662F\u539F\u59CB\u78BC\u7248\u672C\u3002");
     return 1;
   }
-  const packageRoot = path24.dirname(path24.dirname(options.cliEntry));
+  const packageRoot = path25.dirname(path25.dirname(options.cliEntry));
   const name = packageName(packageRoot);
   if (!name) {
     error("\u7121\u6CD5\u8FA8\u8B58\u76EE\u524D VibeFlow \u7684 npm \u5957\u4EF6\u540D\u7A31\uFF0C\u5DF2\u53D6\u6D88\u66F4\u65B0\u3002");
@@ -7764,8 +7987,8 @@ function runUpdate(options) {
     return 1;
   }
   try {
-    const globalPackage = path24.join(String(root.stdout).trim(), ...name.split("/"));
-    if (fs20.lstatSync(globalPackage).isSymbolicLink() || fs20.realpathSync(globalPackage) !== fs20.realpathSync(packageRoot)) {
+    const globalPackage = path25.join(String(root.stdout).trim(), ...name.split("/"));
+    if (fs21.lstatSync(globalPackage).isSymbolicLink() || fs21.realpathSync(globalPackage) !== fs21.realpathSync(packageRoot)) {
       error("vibeflow update \u53EA\u9069\u7528\u65BC\u5168\u57DF npm \u5B89\u88DD\uFF1B\u76EE\u524D\u57F7\u884C\u7684\u5957\u4EF6\u4F86\u81EA\u5176\u4ED6\u4F4D\u7F6E\u3002");
       return 1;
     }
@@ -7861,7 +8084,7 @@ async function startHost(options) {
     let availableUpdate = null;
     let updateTimer = null;
     let stopped = false;
-    const installedPackage = options.sourceRoot || !options.cliEntry ? null : packageName(path25.dirname(path25.dirname(options.cliEntry)));
+    const installedPackage = options.sourceRoot || !options.cliEntry ? null : packageName(path26.dirname(path26.dirname(options.cliEntry)));
     const checkUpdates = async () => {
       if (!installedPackage) return;
       try {
@@ -7923,7 +8146,7 @@ function loginUrl(lock, pathname = "/home/") {
   return `http://127.0.0.1:${lock.port}${pathname}?token=${encodeURIComponent(lock.token)}`;
 }
 function isWebDir(dir) {
-  return fs21.existsSync(path25.join(dir, "home", "index.html"));
+  return fs22.existsSync(path26.join(dir, "home", "index.html"));
 }
 
 // packages/cli/src/remote.ts
@@ -8040,8 +8263,8 @@ function connectToHost(lock) {
 }
 
 // packages/cli/src/doctor.ts
-import fs22 from "fs";
-import path26 from "path";
+import fs23 from "fs";
+import path27 from "path";
 import { execFile as execFile10 } from "child_process";
 import { promisify as promisify7 } from "util";
 init_env();
@@ -8181,10 +8404,10 @@ async function runDoctor(options) {
     });
   }
   try {
-    fs22.mkdirSync(options.userDataDir, { recursive: true });
-    const probe = path26.join(options.userDataDir, `.doctor-${process.pid}`);
-    fs22.writeFileSync(probe, "");
-    fs22.rmSync(probe);
+    fs23.mkdirSync(options.userDataDir, { recursive: true });
+    const probe = path27.join(options.userDataDir, `.doctor-${process.pid}`);
+    fs23.writeFileSync(probe, "");
+    fs23.rmSync(probe);
     checks.push({ id: "data", name: "\u8CC7\u6599\u76EE\u9304", level: "ok", detail: options.userDataDir });
   } catch (err) {
     checks.push({
@@ -8239,24 +8462,24 @@ Options:
 `.trim();
 function detectLayout() {
   const file = fileURLToPath(import.meta.url);
-  const here = path29.dirname(file);
-  const bundledWeb = path29.join(here, "web");
-  if (isWebDir(bundledWeb) || path29.basename(here) === "dist") {
+  const here = path30.dirname(file);
+  const bundledWeb = path30.join(here, "web");
+  if (isWebDir(bundledWeb) || path30.basename(here) === "dist") {
     return {
-      version: readVersion(path29.join(here, "..", "package.json")),
+      version: readVersion(path30.join(here, "..", "package.json")),
       webDir: isWebDir(bundledWeb) ? bundledWeb : null,
       sourceRoot: null,
       cliEntry: file
     };
   }
-  const root = path29.resolve(here, "..", "..", "..");
+  const root = path30.resolve(here, "..", "..", "..");
   const override = process.env.VIBEFLOW_WEB_DIR;
-  const webDir = override && isWebDir(override) ? override : isWebDir(path29.join(root, "app")) ? path29.join(root, "app") : null;
-  return { version: readVersion(path29.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
+  const webDir = override && isWebDir(override) ? override : isWebDir(path30.join(root, "app")) ? path30.join(root, "app") : null;
+  return { version: readVersion(path30.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
 }
 function readVersion(pkgPath) {
   try {
-    return JSON.parse(fs24.readFileSync(pkgPath, "utf8")).version;
+    return JSON.parse(fs25.readFileSync(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -8462,8 +8685,8 @@ async function cmdOpen(values, target, layout, userDataDir) {
     console.error("\u7528\u6CD5\uFF1Avibeflow open <path>");
     return 1;
   }
-  const dir = path29.resolve(target);
-  if (!fs24.existsSync(dir) || !fs24.statSync(dir).isDirectory()) {
+  const dir = path30.resolve(target);
+  if (!fs25.existsSync(dir) || !fs25.statSync(dir).isDirectory()) {
     console.error(`\u4E0D\u662F\u8CC7\u6599\u593E\uFF1A${dir}`);
     return 1;
   }