@kw-yeh/vibeflow 4.0.4 → 4.0.6

package/dist/vibeflow.mjs

@@ -598,9 +598,9 @@ var init_attachments = __esm({
 
 // packages/tui/src/task-form.ts
 import { spawnSync } from "child_process";
-import fs17 from "fs";
-import os5 from "os";
-import path21 from "path";
+import fs18 from "fs";
+import os6 from "os";
+import path22 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render, useApp, useInput } from "ink";
 function newFormState(defaultAutoMode, agents) {
@@ -667,7 +667,7 @@ function visibleFields(s, ctx) {
   return fields;
 }
 function modelOptions(ctx, agentCli, current) {
-  const listed = ctx.connections[agentCli]?.models ?? [];
+  const listed = ctx.models[agentCli] ?? [];
   const options = ["", ...listed];
   if (current && !listed.includes(current)) options.push(current);
   return options;
@@ -719,17 +719,17 @@ function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs17.mkdtempSync(path21.join(os5.tmpdir(), "vibeflow-"));
-  const file = path21.join(dir, "description.md");
+  const dir = fs18.mkdtempSync(path22.join(os6.tmpdir(), "vibeflow-"));
+  const file = path22.join(dir, "description.md");
   try {
-    fs17.writeFileSync(file, text);
+    fs18.writeFileSync(file, text);
     const cmd = editorCommand(process.env, process.platform);
     const r = spawnSync(`${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: fs17.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
+    return { text: fs18.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
   } finally {
-    fs17.rmSync(dir, { recursive: true, force: true });
+    fs18.rmSync(dir, { recursive: true, force: true });
   }
 }
 function cycle(list, current, step) {
@@ -797,10 +797,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(path21.resolve(value2.replace(/^~(?=$|\/)/, os5.homedir())));
+      if (value2) setProject(path22.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path21.resolve(value2.replace(/^~(?=$|\/)/, os5.homedir()));
-      if (!fs17.existsSync(file) || !fs17.statSync(file).isFile()) {
+      const file = path22.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir()));
+      if (!fs18.existsSync(file) || !fs18.statSync(file).isFile()) {
         setMessage(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
         return;
       }
@@ -870,7 +870,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       case "title":
         return s.title || "\uFF08\u4F8B\u5982\uFF1A\u5BE6\u4F5C\u767B\u5165\u9801\u9762\uFF09";
       case "project": {
-        if (projectLocked) return `${s.projectPath ? path21.basename(s.projectPath) : "\u2014"}\uFF08\u4EFB\u52D9\u5DF2\u958B\u59CB\uFF0C\u9396\u5B9A\uFF09`;
+        if (projectLocked) return `${s.projectPath ? path22.basename(s.projectPath) : "\u2014"}\uFF08\u4EFB\u52D9\u5DF2\u958B\u59CB\uFF0C\u9396\u5B9A\uFF09`;
         if (!s.projectPath) return ctx.recent.length ? "\u2190/\u2192 \u9078\u64C7\u4F7F\u7528\u904E\u7684\u5C08\u6848\uFF0C\u6216 Enter \u8F38\u5165\u8DEF\u5F91" : "Enter \u8F38\u5165\u5C08\u6848\u8CC7\u6599\u593E\u7684\u7D55\u5C0D\u8DEF\u5F91";
         return `${s.projectPath}${missing ? "\uFF08\u8DEF\u5F91\u907A\u5931\uFF09" : ""}`;
       }
@@ -881,7 +881,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) => path21.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
+        return s.attachments.length ? s.attachments.map((a) => path22.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");
@@ -899,7 +899,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
         return `\u2039 ${ctx.agents.find((a) => a.id === s.agentCli)?.name ?? s.agentCli} \u203A`;
       }
       case "model":
-        return modelOptions(ctx, s.agentCli, s.model).length > 1 ? `\u2039 ${s.model || "\u4F7F\u7528\u9810\u8A2D model"} \u203A` : "\u5C1A\u672A\u9023\u7DDA\u6216\u7121\u6CD5\u53D6\u5F97 model list\uFF0C\u5C07\u4F7F\u7528\u9810\u8A2D model";
+        return modelOptions(ctx, s.agentCli, s.model).length > 1 ? `\u2039 ${s.model || "\u4F7F\u7528\u9810\u8A2D model"} \u203A` : "\u7121\u6CD5\u53D6\u5F97 model list\uFF0C\u5C07\u4F7F\u7528\u9810\u8A2D model";
       case "submit":
         return busy ?? (s.mode === "new" ? "\uFF3B \u5EFA\u7ACB\u4EFB\u52D9 \uFF3D" : "\uFF3B \u5132\u5B58\u8B8A\u66F4 \uFF3D");
     }
@@ -912,7 +912,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 "\u66F4\u63DB\u5C08\u6848\u6703\u5728\u65B0\u5C08\u6848\u91CD\u5EFA worktree\uFF08\u6B64\u4EFB\u52D9\u5C1A\u672A\u958B\u59CB\uFF0C\u7121\u8B8A\u66F4\u6703\u907A\u5931\uFF09\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"}/${path21.basename(s.projectPath)}`;
+      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path22.basename(s.projectPath)}`;
     }
     if (field === "branch") return info?.hasRemote ? "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\uFF1B\u82E5 remote \u5DF2\u6709\u9019\u500B\u5206\u652F\uFF0C\u5247\u76F4\u63A5\u53D6\u56DE\u4E26\u63A5\u7E8C\u4E0A\u9762\u7684\u5DE5\u4F5C\u3002" : "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u3002";
     if (field === "effort") return `${EFFORTS.find((x) => x.value === s.effort).description} Claude Code \u8207 Codex \u6703\u5728\u555F\u52D5\u6B64\u4EFB\u52D9\u6642\u5957\u7528\uFF1B\u5BE6\u969B\u53EF\u7528\u7D1A\u8DDD\u4F9D model \u800C\u5B9A\u3002`;
@@ -967,11 +967,17 @@ async function loadFormContext(api) {
     api.listRecentProjects(),
     Promise.race([api.detectAgents(), timeout]).catch(() => null)
   ]).finally(() => clearTimeout(timer));
+  const lists = await Promise.all(
+    (agents ?? []).map(async (a) => {
+      const list = await api.listAgentModels(a.id).catch(() => null);
+      return [a.id, list ? list.models.map((m) => m.id) : []];
+    })
+  );
   return {
     ctx: {
       recent,
       agents,
-      connections: state.settings.agentConnections ?? {},
+      models: Object.fromEntries(lists),
       workstationPath: state.settings.workstationPath?.trim() ?? ""
     },
     autoMode: state.settings.autoMode
@@ -1023,7 +1029,7 @@ __export(src_exports, {
   showDiff: () => showDiff
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import path22 from "path";
+import path23 from "path";
 import React2, { useEffect as useEffect2, useState as useState2 } from "react";
 import { Box as Box2, Text as Text2, render as render2, useApp as useApp2, useInput as useInput2, useStdout } from "ink";
 function findDetachKey(text) {
@@ -1285,7 +1291,7 @@ function showDiff(task) {
   });
 }
 function tmuxAttach(opts, sessionName) {
-  const conf = path22.join(opts.userDataDir, "tmux.conf");
+  const conf = path23.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}`];
   spawnSync2("tmux", args, { stdio: "inherit", env: { ...process.env, TMUX: inOurServer ? process.env.TMUX : "" } });
@@ -1415,8 +1421,8 @@ var init_src = __esm({
 });
 
 // packages/cli/src/main.ts
-import fs18 from "fs";
-import path23 from "path";
+import fs19 from "fs";
+import path24 from "path";
 import { fileURLToPath } from "url";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -1681,6 +1687,11 @@ function migrateStore(store) {
   if (!store.has("recentProjects")) {
     store.set("recentProjects", recentProjectsFromBoard(store.get("board")));
   }
+  const settings = store.get("settings");
+  if (settings && "agentConnections" in settings) {
+    const { agentConnections: _dropped, ...rest } = settings;
+    store.set("settings", rest);
+  }
   if (persistedVersion < STATE_VERSION) {
     store.set("version", STATE_VERSION);
   }
@@ -1760,8 +1771,6 @@ function createBridge(t) {
     },
     setBoard: (board) => t.invoke("vibeflow:setBoard", board),
     setSettings: (patch) => t.invoke("vibeflow:setSettings", patch),
-    connectAgent: (agentId2, apiKey) => t.invoke("settings:connectAgent", { agentId: agentId2, apiKey }),
-    refreshAgentModels: (agentId2) => t.invoke("settings:refreshAgentModels", agentId2),
     getGithubAuthStatus: () => t.invoke("settings:githubAuthStatus"),
     startGithubAuthLogin: () => t.invoke("settings:startGithubAuthLogin"),
     cancelGithubAuthLogin: () => t.invoke("settings:cancelGithubAuthLogin"),
@@ -1776,6 +1785,8 @@ function createBridge(t) {
     initRepository: (projectPath) => t.invoke("git:initRepository", projectPath),
     /** Agent CLIs (claude / codex) actually installed on PATH. */
     detectAgents: () => t.invoke("env:detectAgents"),
+    /** Models the agent's own CLI offers; `refresh` asks the CLI instead of its cache. */
+    listAgentModels: (agentId2, refresh = false) => t.invoke("agents:listModels", { agentId: agentId2, refresh }),
     createTask: (payload) => t.invoke("vibeflow:createTask", payload),
     updateTask: (payload) => t.invoke("vibeflow:updateTask", payload),
     /** Clear prior execution state and prepare a fresh run of this task. */
@@ -3519,8 +3530,8 @@ async function taskCommand(argv) {
 }
 
 // packages/cli/src/host.ts
-import fs15 from "fs";
-import path19 from "path";
+import fs16 from "fs";
+import path20 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // packages/core/src/events.ts
@@ -3547,53 +3558,89 @@ var EventBus = class {
 };
 
 // packages/core/src/service.ts
-import fs13 from "fs";
-import os4 from "os";
-import path17 from "path";
+import fs14 from "fs";
+import os5 from "os";
+import path18 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
-// packages/core/src/agent-connections.ts
-function modelIdFromUnknown(value) {
-  if (!value || typeof value !== "object") return null;
-  const id = value.id;
-  return typeof id === "string" && id.trim() ? id.trim() : null;
-}
-function sortModels(ids) {
-  return Array.from(new Set(ids)).sort((a, b) => a.localeCompare(b));
-}
-function providerAuthError(status) {
-  if (status === 401 || status === 403) {
-    return "API key \u7121\u6548\u6216\u6C92\u6709\u6B0A\u9650\uFF0C\u8ACB\u78BA\u8A8D\u5F8C\u91CD\u65B0\u8F38\u5165\u3002";
-  }
-  return `\u53D6\u5F97 model list \u5931\u6557\uFF08HTTP ${status}\uFF09\u3002`;
-}
-async function fetchAgentModels(agentId2, apiKey) {
-  const key = apiKey.trim();
-  if (!key) throw new Error("\u8ACB\u8F38\u5165 API key\u3002");
-  const response = agentId2 === "claude" ? await fetch("https://api.anthropic.com/v1/models", {
-    headers: {
-      "x-api-key": key,
-      "anthropic-version": "2023-06-01"
-    }
-  }) : await fetch("https://api.openai.com/v1/models", {
-    headers: {
-      Authorization: `Bearer ${key}`
-    }
+// packages/core/src/agent-models.ts
+import { execFile as execFile5 } from "child_process";
+import fs10 from "fs";
+import os3 from "os";
+import path14 from "path";
+import { promisify as promisify3 } from "util";
+init_env();
+var pexec3 = promisify3(execFile5);
+var CODEX_MODELS_TIMEOUT_MS = 2e4;
+function builtinModels(id) {
+  return (AGENT_CLIS.find((a) => a.id === id) ?? AGENT_CLIS[0]).models;
+}
+function defaultCodexHome() {
+  const configured = process.env.CODEX_HOME?.trim();
+  return configured ? configured : path14.join(os3.homedir(), ".codex");
+}
+async function defaultRunCodexModels() {
+  const { stdout } = await pexec3("codex", ["debug", "models"], {
+    env: execEnv(),
+    timeout: CODEX_MODELS_TIMEOUT_MS,
+    maxBuffer: 16 * 1024 * 1024,
+    windowsHide: true
   });
-  if (!response.ok) {
-    throw new Error(providerAuthError(response.status));
+  return stdout;
+}
+function parseCodexCatalog(raw) {
+  const body = JSON.parse(raw);
+  if (!Array.isArray(body.models)) throw new Error("Codex model catalog has no models array");
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  for (const entry of body.models) {
+    if (!entry || typeof entry !== "object") continue;
+    const { slug, display_name: displayName, visibility } = entry;
+    if (typeof slug !== "string" || !slug.trim() || visibility === "hide") continue;
+    const id = slug.trim();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    models.push({
+      id,
+      label: typeof displayName === "string" && displayName.trim() ? displayName.trim() : id
+    });
+  }
+  if (models.length === 0) throw new Error("Codex model catalog lists no selectable models");
+  return models;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function listAgentModels(id, opts = {}) {
+  if (id !== "codex") return { models: builtinModels(id), source: "builtin" };
+  if (opts.refresh) {
+    try {
+      const stdout = await (opts.runCodexModels ?? defaultRunCodexModels)();
+      return { models: parseCodexCatalog(stdout), source: "codex-cli" };
+    } catch (err) {
+      return { models: builtinModels(id), source: "builtin", error: errorMessage(err) };
+    }
+  }
+  const cachePath = path14.join(opts.codexHome ?? defaultCodexHome(), "models_cache.json");
+  try {
+    const raw = await fs10.promises.readFile(cachePath, "utf8");
+    return { models: parseCodexCatalog(raw), source: "codex-cache" };
+  } catch (err) {
+    const missing = err.code === "ENOENT";
+    return {
+      models: builtinModels(id),
+      source: "builtin",
+      ...missing ? {} : { error: errorMessage(err) }
+    };
   }
-  const body = await response.json();
-  const data = Array.isArray(body.data) ? body.data : [];
-  return sortModels(data.map(modelIdFromUnknown).filter((id) => Boolean(id)));
 }
 
 // packages/core/src/github-auth.ts
 init_env();
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify3 } from "util";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify4 } from "util";
 import * as nodePty3 from "node-pty";
-var pexec3 = promisify3(execFile5);
+var pexec4 = promisify4(execFile6);
 var GITHUB_HOST = "github.com";
 var DEVICE_URL = "https://github.com/login/device";
 var activeLogin = null;
@@ -3622,13 +3669,13 @@ function statusFromBody(body) {
     error: active.error
   };
 }
-function errorMessage(err) {
+function errorMessage2(err) {
   if (err instanceof Error) return err.message;
   return String(err);
 }
 async function getGitHubCliAuthStatus() {
   try {
-    const { stdout } = await pexec3(
+    const { stdout } = await pexec4(
       "gh",
       ["auth", "status", "--hostname", GITHUB_HOST, "--json", "hosts"],
       {
@@ -3648,7 +3695,7 @@ async function getGitHubCliAuthStatus() {
       } catch {
       }
     }
-    const message = errorMessage(err);
+    const message = errorMessage2(err);
     return {
       installed: !/ENOENT|not found/i.test(message),
       authenticated: false,
@@ -3660,7 +3707,7 @@ async function logoutGitHubCli() {
   const status = await getGitHubCliAuthStatus();
   if (!status.installed) throw new Error("\u627E\u4E0D\u5230 GitHub CLI\uFF08gh\uFF09\u3002");
   if (!status.login) return status;
-  await pexec3(
+  await pexec4(
     "gh",
     ["auth", "logout", "--hostname", GITHUB_HOST, "--user", status.login],
     {
@@ -3701,7 +3748,7 @@ function startGitHubCliLogin(onEvent) {
       }
     );
   } catch (err) {
-    onEvent({ type: "error", error: errorMessage(err) });
+    onEvent({ type: "error", error: errorMessage2(err) });
     return;
   }
   activeLogin = proc;
@@ -3743,38 +3790,38 @@ function startGitHubCliLogin(onEvent) {
 }
 
 // packages/core/src/board-cli.ts
-import fs10 from "fs";
-import path14 from "path";
+import fs11 from "fs";
+import path15 from "path";
 import { pathToFileURL } from "url";
 async function boardCliLaunchInfo() {
-  const storeDir = path14.dirname(getStorePath());
+  const storeDir = path15.dirname(getStorePath());
   const entry = getPlatform().cliEntry?.();
-  if (entry && fs10.existsSync(entry)) return { storeDir, cliPath: entry };
+  if (entry && fs11.existsSync(entry)) return { storeDir, cliPath: entry };
   const root = getPlatform().sourceRoot();
   if (!root) return { storeDir };
-  const cliPath = path14.join(root, "scripts", "vibeflow.mjs");
-  const loaderPath = path14.join(root, "test", "support", "register.mjs");
-  if (!fs10.existsSync(cliPath) || !fs10.existsSync(loaderPath)) return { storeDir };
+  const cliPath = path15.join(root, "scripts", "vibeflow.mjs");
+  const loaderPath = path15.join(root, "test", "support", "register.mjs");
+  if (!fs11.existsSync(cliPath) || !fs11.existsSync(loaderPath)) return { storeDir };
   return { storeDir, cliPath, loaderPath: pathToFileURL(loaderPath).href };
 }
 
 // packages/core/src/decisions.ts
-import fs11 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path16 from "path";
 var DECISIONS_FILE_SUFFIX = ".DECISIONS.md";
 var MAX_DECISION_BYTES = 256 * 1024;
 function decisionsKey(worktreePath, branch) {
-  return worktreePath ? path15.basename(worktreePath) : branch.replace(/\//g, "-");
+  return worktreePath ? path16.basename(worktreePath) : branch.replace(/\//g, "-");
 }
 function decisionsPath(workspacePath, key) {
-  return path15.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
+  return path16.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
 }
 function readDecisions(workspacePath, key) {
   const target = decisionsPath(workspacePath, key);
   try {
-    const stat = fs11.statSync(target);
+    const stat = fs12.statSync(target);
     if (!stat.isFile()) return { path: target, markdown: null };
-    const buf = fs11.readFileSync(target);
+    const buf = fs12.readFileSync(target);
     return {
       path: target,
       markdown: buf.subarray(0, MAX_DECISION_BYTES).toString("utf8"),
@@ -3787,7 +3834,7 @@ function readDecisions(workspacePath, key) {
 }
 function deleteDecisions(workspacePath, key) {
   try {
-    fs11.rmSync(decisionsPath(workspacePath, key), { force: true });
+    fs12.rmSync(decisionsPath(workspacePath, key), { force: true });
   } catch {
   }
 }
@@ -4079,9 +4126,9 @@ function startChatSend(opts, sender) {
 init_attachments();
 
 // packages/core/src/library.ts
-import fs12 from "fs";
-import os3 from "os";
-import path16 from "path";
+import fs13 from "fs";
+import os4 from "os";
+import path17 from "path";
 var LIBRARY_DIR = "library";
 var LIBRARY_KINDS = ["skill", "prompt", "script"];
 var KIND_DIR = {
@@ -4094,15 +4141,15 @@ var MAX_NAME_BYTES = 100;
 function libraryPaths(root) {
   return {
     root,
-    skills: path16.join(root, KIND_DIR.skill),
-    prompts: path16.join(root, KIND_DIR.prompt),
-    scripts: path16.join(root, KIND_DIR.script),
-    plugin: path16.join(root, "plugin"),
-    codexHome: path16.join(root, "codex-home")
+    skills: path17.join(root, KIND_DIR.skill),
+    prompts: path17.join(root, KIND_DIR.prompt),
+    scripts: path17.join(root, KIND_DIR.script),
+    plugin: path17.join(root, "plugin"),
+    codexHome: path17.join(root, "codex-home")
   };
 }
 async function libraryRoot() {
-  return path16.join(getPlatform().userDataDir(), LIBRARY_DIR);
+  return path17.join(getPlatform().userDataDir(), LIBRARY_DIR);
 }
 function truncateUtf82(value, maxBytes) {
   let result = "";
@@ -4124,11 +4171,11 @@ function entryKey(kind, name) {
   return `${kind}/${name}`;
 }
 function indexPath(root) {
-  return path16.join(root, INDEX_FILE);
+  return path17.join(root, INDEX_FILE);
 }
 function readIndex(root) {
   try {
-    const parsed = JSON.parse(fs12.readFileSync(indexPath(root), "utf8"));
+    const parsed = JSON.parse(fs13.readFileSync(indexPath(root), "utf8"));
     if (parsed && typeof parsed === "object" && "entries" in parsed) {
       const entries = parsed.entries;
       if (entries && typeof entries === "object") return { version: 1, entries };
@@ -4138,21 +4185,21 @@ function readIndex(root) {
   return { version: 1, entries: {} };
 }
 function writeIndex(root, index) {
-  fs12.mkdirSync(root, { recursive: true });
-  fs12.writeFileSync(indexPath(root), `${JSON.stringify(index, null, 2)}
+  fs13.mkdirSync(root, { recursive: true });
+  fs13.writeFileSync(indexPath(root), `${JSON.stringify(index, null, 2)}
 `);
 }
 function ensureLibrary(root) {
   const paths = libraryPaths(root);
   for (const kind of LIBRARY_KINDS) {
-    fs12.mkdirSync(path16.join(root, KIND_DIR[kind]), { recursive: true });
+    fs13.mkdirSync(path17.join(root, KIND_DIR[kind]), { recursive: true });
   }
   return paths;
 }
 function readSkillDescription(skillMdPath) {
   let content;
   try {
-    content = fs12.readFileSync(skillMdPath, "utf8");
+    content = fs13.readFileSync(skillMdPath, "utf8");
   } catch {
     return void 0;
   }
@@ -4167,16 +4214,16 @@ function readSkillDescription(skillMdPath) {
   return void 0;
 }
 function entryPath(root, kind, name) {
-  return path16.join(root, KIND_DIR[kind], name);
+  return path17.join(root, KIND_DIR[kind], name);
 }
 function listLibrary(root) {
   const index = readIndex(root);
   const entries = [];
   for (const kind of LIBRARY_KINDS) {
-    const dir = path16.join(root, KIND_DIR[kind]);
+    const dir = path17.join(root, KIND_DIR[kind]);
     let dirents;
     try {
-      dirents = fs12.readdirSync(dir, { withFileTypes: true });
+      dirents = fs13.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -4185,14 +4232,14 @@ function listLibrary(root) {
       const wantsDirectory = kind === "skill";
       let stat;
       try {
-        stat = fs12.statSync(path16.join(dir, dirent.name));
+        stat = fs13.statSync(path17.join(dir, dirent.name));
       } catch {
         continue;
       }
       if (stat.isDirectory() !== wantsDirectory) continue;
       const name = dirent.name;
-      const full = path16.join(dir, name);
-      if (wantsDirectory && !fs12.existsSync(path16.join(full, "SKILL.md"))) continue;
+      const full = path17.join(dir, name);
+      if (wantsDirectory && !fs13.existsSync(path17.join(full, "SKILL.md"))) continue;
       const key = entryKey(kind, name);
       const record = index.entries[key] ?? {};
       entries.push({
@@ -4200,7 +4247,7 @@ function listLibrary(root) {
         kind,
         name,
         path: full,
-        description: wantsDirectory ? readSkillDescription(path16.join(full, "SKILL.md")) : record.description,
+        description: wantsDirectory ? readSkillDescription(path17.join(full, "SKILL.md")) : record.description,
         sourcePath: record.sourcePath,
         importedAt: record.importedAt,
         enabled: record.enabled !== false
@@ -4216,21 +4263,21 @@ function annotate(root, key, patch) {
 }
 function importEntry(root, kind, sourcePath) {
   ensureLibrary(root);
-  const resolved = path16.resolve(sourcePath);
-  const stat = fs12.statSync(resolved);
+  const resolved = path17.resolve(sourcePath);
+  const stat = fs13.statSync(resolved);
   if (kind === "skill") {
     if (!stat.isDirectory()) throw new Error("skill \u5FC5\u9808\u662F\u542B SKILL.md \u7684\u76EE\u9304");
-    if (!fs12.existsSync(path16.join(resolved, "SKILL.md"))) {
+    if (!fs13.existsSync(path17.join(resolved, "SKILL.md"))) {
       throw new Error("\u76EE\u9304\u5167\u627E\u4E0D\u5230 SKILL.md");
     }
   } else if (!stat.isFile()) {
     throw new Error(`${kind} \u5FC5\u9808\u662F\u55AE\u4E00\u6A94\u6848`);
   }
-  const name = safeLibraryName(path16.basename(resolved));
+  const name = safeLibraryName(path17.basename(resolved));
   const target = entryPath(root, kind, name);
-  fs12.rmSync(target, { recursive: true, force: true });
-  fs12.cpSync(resolved, target, { recursive: kind === "skill", dereference: true });
-  if (kind === "script") fs12.chmodSync(target, 493);
+  fs13.rmSync(target, { recursive: true, force: true });
+  fs13.cpSync(resolved, target, { recursive: kind === "skill", dereference: true });
+  if (kind === "script") fs13.chmodSync(target, 493);
   annotate(root, entryKey(kind, name), {
     sourcePath: resolved,
     importedAt: Date.now(),
@@ -4242,13 +4289,13 @@ function createEntry(root, kind, rawName, content, description) {
   ensureLibrary(root);
   const name = safeLibraryName(rawName);
   const target = entryPath(root, kind, name);
-  if (fs12.existsSync(target)) throw new Error(`\u5DF2\u5B58\u5728\u540C\u540D\u9805\u76EE\uFF1A${name}`);
+  if (fs13.existsSync(target)) throw new Error(`\u5DF2\u5B58\u5728\u540C\u540D\u9805\u76EE\uFF1A${name}`);
   if (kind === "skill") {
-    fs12.mkdirSync(target, { recursive: true });
-    fs12.writeFileSync(path16.join(target, "SKILL.md"), content);
+    fs13.mkdirSync(target, { recursive: true });
+    fs13.writeFileSync(path17.join(target, "SKILL.md"), content);
   } else {
-    fs12.writeFileSync(target, content);
-    if (kind === "script") fs12.chmodSync(target, 493);
+    fs13.writeFileSync(target, content);
+    if (kind === "script") fs13.chmodSync(target, 493);
   }
   annotate(root, entryKey(kind, name), {
     importedAt: Date.now(),
@@ -4262,16 +4309,16 @@ function setEntryDescription(root, kind, name, description) {
 }
 function updateEntry(root, kind, name, content) {
   const target = entryPath(root, kind, name);
-  if (!fs12.existsSync(target)) throw new Error(`\u627E\u4E0D\u5230\u9805\u76EE\uFF1A${name}`);
-  fs12.writeFileSync(kind === "skill" ? path16.join(target, "SKILL.md") : target, content);
+  if (!fs13.existsSync(target)) throw new Error(`\u627E\u4E0D\u5230\u9805\u76EE\uFF1A${name}`);
+  fs13.writeFileSync(kind === "skill" ? path17.join(target, "SKILL.md") : target, content);
   return requireEntry(root, kind, name);
 }
 function readEntryContent(root, kind, name) {
   const target = entryPath(root, kind, name);
-  return fs12.readFileSync(kind === "skill" ? path16.join(target, "SKILL.md") : target, "utf8");
+  return fs13.readFileSync(kind === "skill" ? path17.join(target, "SKILL.md") : target, "utf8");
 }
 function deleteEntry(root, kind, name) {
-  fs12.rmSync(entryPath(root, kind, name), { recursive: true, force: true });
+  fs13.rmSync(entryPath(root, kind, name), { recursive: true, force: true });
   const index = readIndex(root);
   delete index.entries[entryKey(kind, name)];
   writeIndex(root, index);
@@ -4285,11 +4332,11 @@ function requireEntry(root, kind, name) {
   return found2;
 }
 function projectSkillsDir(worktreePath) {
-  return path16.join(worktreePath, ".claude", "skills");
+  return path17.join(worktreePath, ".claude", "skills");
 }
 function skillNamesIn(dir) {
   try {
-    return fs12.readdirSync(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).map((d) => d.name).filter((name) => fs12.existsSync(path16.join(dir, name, "SKILL.md"))).sort();
+    return fs13.readdirSync(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).map((d) => d.name).filter((name) => fs13.existsSync(path17.join(dir, name, "SKILL.md"))).sort();
   } catch {
     return [];
   }
@@ -4298,11 +4345,11 @@ var PLUGIN_MANIFEST_DIR = ".claude-plugin";
 function buildPluginDir(root) {
   const paths = libraryPaths(root);
   const enabled = listLibrary(root).filter((e) => e.kind === "skill" && e.enabled);
-  fs12.rmSync(path16.join(paths.plugin, "skills"), { recursive: true, force: true });
-  fs12.mkdirSync(path16.join(paths.plugin, PLUGIN_MANIFEST_DIR), { recursive: true });
-  fs12.mkdirSync(path16.join(paths.plugin, "skills"), { recursive: true });
-  fs12.writeFileSync(
-    path16.join(paths.plugin, PLUGIN_MANIFEST_DIR, "plugin.json"),
+  fs13.rmSync(path17.join(paths.plugin, "skills"), { recursive: true, force: true });
+  fs13.mkdirSync(path17.join(paths.plugin, PLUGIN_MANIFEST_DIR), { recursive: true });
+  fs13.mkdirSync(path17.join(paths.plugin, "skills"), { recursive: true });
+  fs13.writeFileSync(
+    path17.join(paths.plugin, PLUGIN_MANIFEST_DIR, "plugin.json"),
     `${JSON.stringify(
       {
         name: "vibeflow-library",
@@ -4315,7 +4362,7 @@ function buildPluginDir(root) {
 `
   );
   for (const entry of enabled) {
-    fs12.cpSync(entry.path, path16.join(paths.plugin, "skills", entry.name), {
+    fs13.cpSync(entry.path, path17.join(paths.plugin, "skills", entry.name), {
       recursive: true,
       dereference: true
     });
@@ -4323,19 +4370,19 @@ function buildPluginDir(root) {
   return { pluginDir: paths.plugin, skills: enabled.map((e) => e.name) };
 }
 function linkOrSkip(target, linkPath) {
-  if (!fs12.existsSync(target)) return false;
-  const source = path16.resolve(target);
-  const attempts = fs12.statSync(source).isDirectory() ? [
-    () => fs12.symlinkSync(source, linkPath, "junction"),
-    () => fs12.cpSync(source, linkPath, { recursive: true, dereference: true })
+  if (!fs13.existsSync(target)) return false;
+  const source = path17.resolve(target);
+  const attempts = fs13.statSync(source).isDirectory() ? [
+    () => fs13.symlinkSync(source, linkPath, "junction"),
+    () => fs13.cpSync(source, linkPath, { recursive: true, dereference: true })
   ] : [
-    () => fs12.symlinkSync(source, linkPath),
-    () => fs12.linkSync(source, linkPath),
-    () => fs12.copyFileSync(source, linkPath)
+    () => fs13.symlinkSync(source, linkPath),
+    () => fs13.linkSync(source, linkPath),
+    () => fs13.copyFileSync(source, linkPath)
   ];
   for (const attempt of attempts) {
     try {
-      fs12.rmSync(linkPath, { recursive: true, force: true });
+      fs13.rmSync(linkPath, { recursive: true, force: true });
       attempt();
       return true;
     } catch {
@@ -4343,13 +4390,13 @@ function linkOrSkip(target, linkPath) {
   }
   return false;
 }
-function buildCodexHome(root, worktreePath, userCodexHome = path16.join(os3.homedir(), ".codex")) {
+function buildCodexHome(root, worktreePath, userCodexHome = path17.join(os4.homedir(), ".codex")) {
   const paths = libraryPaths(root);
-  const skillsDir = path16.join(paths.codexHome, "skills");
-  fs12.rmSync(skillsDir, { recursive: true, force: true });
-  fs12.mkdirSync(skillsDir, { recursive: true });
+  const skillsDir = path17.join(paths.codexHome, "skills");
+  fs13.rmSync(skillsDir, { recursive: true, force: true });
+  fs13.mkdirSync(skillsDir, { recursive: true });
   for (const file of ["auth.json", "config.toml"]) {
-    linkOrSkip(path16.join(userCodexHome, file), path16.join(paths.codexHome, file));
+    linkOrSkip(path17.join(userCodexHome, file), path17.join(paths.codexHome, file));
   }
   const result = {
     codexHome: paths.codexHome,
@@ -4362,20 +4409,20 @@ function buildCodexHome(root, worktreePath, userCodexHome = path16.join(os3.home
   const projectDir = worktreePath ? projectSkillsDir(worktreePath) : void 0;
   if (projectDir) {
     for (const name of skillNamesIn(projectDir)) {
-      if (linkOrSkip(path16.join(projectDir, name), path16.join(skillsDir, name))) {
+      if (linkOrSkip(path17.join(projectDir, name), path17.join(skillsDir, name))) {
         result.project.push(name);
         claimed.set(name, "project");
       }
     }
   }
-  const userDir = path16.join(userCodexHome, "skills");
+  const userDir = path17.join(userCodexHome, "skills");
   for (const name of skillNamesIn(userDir)) {
     const owner = claimed.get(name);
     if (owner) {
       result.shadowed.push({ name, keptFrom: owner, dropped: "user" });
       continue;
     }
-    if (linkOrSkip(path16.join(userDir, name), path16.join(skillsDir, name))) {
+    if (linkOrSkip(path17.join(userDir, name), path17.join(skillsDir, name))) {
       result.user.push(name);
       claimed.set(name, "user");
     }
@@ -4387,7 +4434,7 @@ function buildCodexHome(root, worktreePath, userCodexHome = path16.join(os3.home
       result.shadowed.push({ name: entry.name, keptFrom: owner, dropped: "library" });
       continue;
     }
-    fs12.cpSync(entry.path, path16.join(skillsDir, entry.name), {
+    fs13.cpSync(entry.path, path17.join(skillsDir, entry.name), {
       recursive: true,
       dereference: true
     });
@@ -4703,13 +4750,13 @@ function createCore({ sessions, bus, version }) {
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path17.join(os4.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path18.join(os5.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 ?? path17.dirname(task.worktreePath), task.worktreePath);
+    deleteArtifacts(task.workspacePath ?? path18.dirname(task.worktreePath), task.worktreePath);
     await deleteBranch(task.projectPath, branch);
   }
   const handlers = {
@@ -4720,66 +4767,7 @@ function createCore({ sessions, bus, version }) {
       return getState();
     },
     "vibeflow:setSettings": (patch) => {
-      const p = obj(patch, "patch");
-      const { agentConnections: _ignored, ...rest } = p;
-      setSettings(rest);
-      return getState();
-    },
-    "settings:connectAgent": async (payload) => {
-      const { agentId: rawId, apiKey } = obj(payload, "payload");
-      const id = agentId(rawId);
-      const key = str(apiKey, "apiKey");
-      const models = await fetchAgentModels(id, key);
-      const state = getState();
-      setSettings({
-        agentConnections: {
-          ...state.settings.agentConnections ?? {},
-          [id]: {
-            connected: true,
-            apiKey: key.trim(),
-            models,
-            error: void 0,
-            updatedAt: Date.now()
-          }
-        }
-      });
-      return getState();
-    },
-    "settings:refreshAgentModels": async (rawId) => {
-      const id = agentId(rawId);
-      const connections = getState().settings.agentConnections ?? {};
-      const existing = connections[id];
-      if (!existing?.apiKey) {
-        setSettings({
-          agentConnections: {
-            ...connections,
-            [id]: { connected: false, models: [], error: "\u5C1A\u672A\u7D81\u5B9A API key\u3002", updatedAt: Date.now() }
-          }
-        });
-        return getState();
-      }
-      try {
-        const models = await fetchAgentModels(id, existing.apiKey);
-        setSettings({
-          agentConnections: {
-            ...connections,
-            [id]: { ...existing, connected: true, models, error: void 0, updatedAt: Date.now() }
-          }
-        });
-      } catch (err) {
-        setSettings({
-          agentConnections: {
-            ...connections,
-            [id]: {
-              ...existing,
-              connected: false,
-              models: [],
-              error: err instanceof Error ? err.message : String(err),
-              updatedAt: Date.now()
-            }
-          }
-        });
-      }
+      setSettings(obj(patch, "patch"));
       return getState();
     },
     "settings:githubAuthStatus": () => getGitHubCliAuthStatus(),
@@ -4791,6 +4779,10 @@ function createCore({ sessions, bus, version }) {
     },
     "settings:logoutGithubAuth": () => logoutGitHubCli(),
     "env:detectAgents": () => detectAgents(),
+    "agents:listModels": (payload) => {
+      const { agentId: rawId, refresh } = obj(payload, "payload");
+      return listAgentModels(agentId(rawId), { refresh: refresh === true });
+    },
     // A task does not exist yet when a project is picked, so these two are the
     // ones that must take a path. They only inspect or `git init` it.
     "git:getInfo": (projectPath) => getGitInfo(str(projectPath ?? "", "projectPath")),
@@ -4803,8 +4795,8 @@ function createCore({ sessions, bus, version }) {
     "projects:listRecent": () => listRecentProjects(getStore()),
     // `vibeflow open <path>` while a host runs: only the host writes the store.
     "projects:record": (projectPath) => {
-      const p = path17.resolve(str(projectPath, "projectPath"));
-      if (!fs13.existsSync(p) || !fs13.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
+      const p = path18.resolve(str(projectPath, "projectPath"));
+      if (!fs14.existsSync(p) || !fs14.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
       recordRecentProject(getStore(), p);
       return listRecentProjects(getStore());
     },
@@ -4844,7 +4836,7 @@ function createCore({ sessions, bus, version }) {
       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 ?? path17.dirname(task.worktreePath);
+      const workspacePath = task.workspacePath ?? path18.dirname(task.worktreePath);
       deleteArtifacts(workspacePath, task.worktreePath);
       deleteDecisions(workspacePath, decisionsKey(task.worktreePath, task.branch));
       resetSubAgents(task.worktreePath);
@@ -4883,9 +4875,9 @@ function createCore({ sessions, bus, version }) {
         if (!info.isRepo) throw new Error("\u76EE\u6A19\u8CC7\u6599\u593E\u4E0D\u662F git repository");
         await teardownTask(existing.id);
         await removeTaskWorktree(existing);
-        const projectName = path17.basename(nextProject);
+        const projectName = path18.basename(nextProject);
         const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
-        await fs13.promises.mkdir(workspacePath, { recursive: true });
+        await fs14.promises.mkdir(workspacePath, { recursive: true });
         const result = await provisionWorktree(
           nextProject,
           workspacePath,
@@ -4973,7 +4965,7 @@ function createCore({ sessions, bus, version }) {
     "claude:sessionExists": (taskId) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return false;
-      return fs13.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
+      return fs14.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
     },
     "sessions:list": async () => {
       const keys = await sessions.list();
@@ -4992,9 +4984,9 @@ function createCore({ sessions, bus, version }) {
     "git:getDiffEntries": (taskId, opts) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return [];
-      const fetch2 = opts && typeof opts === "object" ? opts.fetch : void 0;
+      const fetch = opts && typeof opts === "object" ? opts.fetch : void 0;
       return getWorktreeDiffEntries(task.worktreePath, task.baseBranch ?? "HEAD", {
-        fetch: typeof fetch2 === "boolean" ? fetch2 : void 0
+        fetch: typeof fetch === "boolean" ? fetch : void 0
       });
     },
     "git:getDiffFile": (taskId, filePath) => {
@@ -5020,7 +5012,7 @@ function createCore({ sessions, bus, version }) {
       const task = requireTask(taskId);
       if (!task.worktreePath || !task.workspacePath) return "task has no worktree";
       const dir = agentArtifactsPath(task.workspacePath, task.worktreePath);
-      if (!fs13.existsSync(dir)) return "artifacts directory does not exist yet";
+      if (!fs14.existsSync(dir)) return "artifacts directory does not exist yet";
       return getPlatform().openPath(dir);
     },
     "task:getDecisions": (taskId) => {
@@ -5173,9 +5165,9 @@ function createCore({ sessions, bus, version }) {
     // 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 = path17.basename(getStorePath());
+      const file = path18.basename(getStorePath());
       let debounce = null;
-      storeWatcher = fs13.watch(path17.dirname(getStorePath()), (_event, filename) => {
+      storeWatcher = fs14.watch(path18.dirname(getStorePath()), (_event, filename) => {
         if (filename !== file) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -5207,9 +5199,9 @@ function createSessionBackend(sink, choice) {
 }
 
 // packages/core/src/web-server.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import http from "http";
-import path18 from "path";
+import path19 from "path";
 import { timingSafeEqual } from "crypto";
 import { WebSocketServer } from "ws";
 var TOKEN_COOKIE = "vf_token";
@@ -5262,14 +5254,14 @@ function resolveStatic(root, urlPath) {
     return null;
   }
   if (decoded.includes("\0")) return null;
-  const rel = path18.posix.normalize(decoded).replace(/^\/+/, "");
-  const base = path18.resolve(root);
-  const candidates = [rel, path18.posix.join(rel, "index.html"), `${rel}.html`];
+  const rel = path19.posix.normalize(decoded).replace(/^\/+/, "");
+  const base = path19.resolve(root);
+  const candidates = [rel, path19.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path18.resolve(base, c);
-    if (full !== base && !full.startsWith(base + path18.sep)) return null;
+    const full = path19.resolve(base, c);
+    if (full !== base && !full.startsWith(base + path19.sep)) return null;
     try {
-      if (fs14.statSync(full).isFile()) return full;
+      if (fs15.statSync(full).isFile()) return full;
     } catch {
     }
   }
@@ -5330,7 +5322,7 @@ async function startWebServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const ext = path18.extname(file).toLowerCase();
+    const ext = path19.extname(file).toLowerCase();
     const immutable = url.pathname.startsWith("/_next/static/");
     res.writeHead(200, {
       "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream",
@@ -5343,7 +5335,7 @@ async function startWebServer(options) {
       res.end();
       return;
     }
-    fs14.createReadStream(file).pipe(res);
+    fs15.createReadStream(file).pipe(res);
   }
   const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
   function reject(socket, status, reason) {
@@ -5514,7 +5506,7 @@ function loginUrl(lock, pathname = "/home/") {
   return `http://127.0.0.1:${lock.port}${pathname}?token=${encodeURIComponent(lock.token)}`;
 }
 function isWebDir(dir) {
-  return fs15.existsSync(path19.join(dir, "home", "index.html"));
+  return fs16.existsSync(path20.join(dir, "home", "index.html"));
 }
 
 // packages/cli/src/remote.ts
@@ -5631,14 +5623,14 @@ function connectToHost(lock) {
 }
 
 // packages/cli/src/doctor.ts
-import fs16 from "fs";
-import path20 from "path";
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify4 } from "util";
+import fs17 from "fs";
+import path21 from "path";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify5 } from "util";
 init_env();
 init_git_bash();
 init_tmux_backend();
-var pexec4 = promisify4(execFile6);
+var pexec5 = promisify5(execFile7);
 function parseVersion(text) {
   const m = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(text);
   return m ? [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)] : [];
@@ -5652,7 +5644,7 @@ function versionAtLeast(have, want) {
 }
 async function run(cmd, args) {
   try {
-    const { stdout } = await pexec4(cmd, args, { env: execEnv(), timeout: 1e4, windowsHide: true });
+    const { stdout } = await pexec5(cmd, args, { env: execEnv(), timeout: 1e4, windowsHide: true });
     return String(stdout).trim();
   } catch {
     return null;
@@ -5772,10 +5764,10 @@ async function runDoctor(options) {
     });
   }
   try {
-    fs16.mkdirSync(options.userDataDir, { recursive: true });
-    const probe = path20.join(options.userDataDir, `.doctor-${process.pid}`);
-    fs16.writeFileSync(probe, "");
-    fs16.rmSync(probe);
+    fs17.mkdirSync(options.userDataDir, { recursive: true });
+    const probe = path21.join(options.userDataDir, `.doctor-${process.pid}`);
+    fs17.writeFileSync(probe, "");
+    fs17.rmSync(probe);
     checks.push({ id: "data", name: "\u8CC7\u6599\u76EE\u9304", level: "ok", detail: options.userDataDir });
   } catch (err) {
     checks.push({
@@ -5829,24 +5821,24 @@ Options:
 `.trim();
 function detectLayout() {
   const file = fileURLToPath(import.meta.url);
-  const here = path23.dirname(file);
-  const bundledWeb = path23.join(here, "web");
-  if (isWebDir(bundledWeb) || path23.basename(here) === "dist") {
+  const here = path24.dirname(file);
+  const bundledWeb = path24.join(here, "web");
+  if (isWebDir(bundledWeb) || path24.basename(here) === "dist") {
     return {
-      version: readVersion(path23.join(here, "..", "package.json")),
+      version: readVersion(path24.join(here, "..", "package.json")),
       webDir: isWebDir(bundledWeb) ? bundledWeb : null,
       sourceRoot: null,
       cliEntry: file
     };
   }
-  const root = path23.resolve(here, "..", "..", "..");
+  const root = path24.resolve(here, "..", "..", "..");
   const override = process.env.VIBEFLOW_WEB_DIR;
-  const webDir = override && isWebDir(override) ? override : isWebDir(path23.join(root, "app")) ? path23.join(root, "app") : null;
-  return { version: readVersion(path23.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
+  const webDir = override && isWebDir(override) ? override : isWebDir(path24.join(root, "app")) ? path24.join(root, "app") : null;
+  return { version: readVersion(path24.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
 }
 function readVersion(pkgPath) {
   try {
-    return JSON.parse(fs18.readFileSync(pkgPath, "utf8")).version;
+    return JSON.parse(fs19.readFileSync(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -6052,8 +6044,8 @@ async function cmdOpen(values, target, layout, userDataDir) {
     console.error("\u7528\u6CD5\uFF1Avibeflow open <path>");
     return 1;
   }
-  const dir = path23.resolve(target);
-  if (!fs18.existsSync(dir) || !fs18.statSync(dir).isDirectory()) {
+  const dir = path24.resolve(target);
+  if (!fs19.existsSync(dir) || !fs19.statSync(dir).isDirectory()) {
     console.error(`\u4E0D\u662F\u8CC7\u6599\u593E\uFF1A${dir}`);
     return 1;
   }