@kw-yeh/vibeflow 4.11.13 → 4.11.16

package/dist/vibeflow.mjs

@@ -514,16 +514,6 @@ function agentArtifactsDir(worktreePath, workspacePath) {
   const ws = pathBasename(worktreePath);
   return `${dir}/${ws}${ARTIFACTS_DIR_SUFFIX}`;
 }
-function buildArtifactPrompt(artifactsDir = ARTIFACTS_FALLBACK_DIR) {
-  return [
-    "Artifact \u8A2D\u5B9A\uFF08\u672C\u6B21 session \u5168\u7A0B\u9069\u7528\uFF09\uFF1A",
-    `1. \u672C\u4EFB\u52D9\u7684 Artifact \u8CC7\u6599\u593E\u662F ${artifactsDir}/\uFF1B\u9700\u8981\u4FDD\u5B58\u7D66\u4F7F\u7528\u8005\u7684\u9A57\u8B49\u8B49\u64DA\u6216\u5831\u544A\u6642\uFF0C\u8ACB\u5BEB\u5165\u6B64\u8CC7\u6599\u593E\uFF08\u4E0D\u5B58\u5728\u8ACB\u5EFA\u7ACB\uFF09\u3002`,
-    `2. \u4F7F\u7528\u8005\u6703\u5728 VibeFlow \u7684 Artifacts \u5206\u9801\u6AA2\u8996\u6839\u76EE\u9304\u5167\u5BB9\uFF1B\u53EA\u653E\u4F60\u6703\u4E3B\u52D5\u8ACB\u4F7F\u7528\u8005\u904E\u76EE\u7684\u6A94\u6848\u3002`,
-    `3. \u4F60\u81EA\u5DF1\u7684\u5DE5\u4F5C\u66AB\u5B58\uFF08\u4E00\u6B21\u6027 script\u3001log\u3001\u4E2D\u9593\u8F38\u51FA\u3001debug \u6A94\uFF09\u653E\u5728 ${artifactsDir}/${SCRATCH_DIR_NAME}/\u3002`,
-    `4. \u82E5\u5DE5\u5177\u5148\u8F38\u51FA\u5230 /tmp\u3001/private/tmp\u3001$TMPDIR \u6216 ~/Downloads\uFF0C\u8ACB\u628A\u6700\u7D42\u8981\u5448\u73FE\u7684\u6A94\u6848\u8907\u88FD\u5230 ${artifactsDir}/ \u4E26\u78BA\u8A8D\u5B58\u5728\u3002`,
-    "5. Artifact \u8CC7\u6599\u593E\u4F4D\u65BC worktree \u4E4B\u5916\uFF1B\u4E0D\u8981\u628A\u5176\u4E2D\u5167\u5BB9\u52A0\u5165 git commit\uFF0C\u4E5F\u4E0D\u8981\u628A\u6700\u7D42\u4EA4\u4ED8\u7269\u53EA\u7559\u5728\u9019\u88E1\u3002"
-  ].join("\n");
-}
 function claudePermissionFlag(autoMode) {
   return autoMode ? ` --permission-mode ${AUTO_PERMISSION_MODE}` : "";
 }
@@ -533,8 +523,9 @@ function shellQuote(s) {
 function toShellPath(p) {
   return p.replace(/\\/g, "/");
 }
-function boardEnvPrefix(task, opts) {
+function boardEnvPrefix(task, opts, workspacePath) {
   const board = opts?.boardCli;
+  const artifactsDir = agentArtifactsDir(task.worktreePath, workspacePath) ?? (task.worktreePath ? `${toShellPath(task.worktreePath)}/${ARTIFACTS_FALLBACK_DIR}` : void 0);
   if (!board) return "";
   const entries = [
     ["VIBEFLOW_TASK_ID", task.id],
@@ -544,7 +535,9 @@ function boardEnvPrefix(task, opts) {
     ["VIBEFLOW_STORE_DIR", board?.storeDir],
     ["VIBEFLOW_CLI", board?.cliPath],
     ["VIBEFLOW_CLI_LOADER", board?.loaderPath],
-    ["VIBEFLOW_AUTO_MODE", opts?.autoMode ? "1" : "0"]
+    ["VIBEFLOW_AUTO_MODE", opts?.autoMode ? "1" : "0"],
+    ["VIBEFLOW_ARTIFACTS_DIR", artifactsDir],
+    ["VIBEFLOW_SCRATCH_DIR", artifactsDir ? `${artifactsDir}/${SCRATCH_DIR_NAME}` : void 0]
   ];
   const exports = entries.filter((entry) => Boolean(entry[1])).map(([key, value]) => `${key}=${shellQuote(toShellPath(value))}`);
   return exports.length ? `export ${exports.join(" ")}; ` : "";
@@ -612,25 +605,22 @@ function assembleCommand(agent, systemPrompt, prompt, model, effort, opts, workt
     const settings = ` --settings ${shellQuote(buildClaudeSettings(worktreePath))}`;
     const addDir = workspacePath ? ` --add-dir ${shellQuote(toShellPath(workspacePath))}` : "";
     const modelFlag = model ? ` --model ${model}` : "";
-    const effortFlag = effort ? ` --effort ${effort}` : "";
-    const library = opts?.library;
-    const libraryFlags = library ? ` --plugin-dir ${shellQuote(toShellPath(library.pluginDir))} --add-dir ${shellQuote(toShellPath(library.libraryDir))}` : "";
-    const flags = `--chrome${claudePermissionFlag(opts?.autoMode)}${modelFlag}${effortFlag}${settings}${addDir}${libraryFlags}`;
+    const effortFlag = effort && effort !== "auto" ? ` --effort ${effort}` : "";
+    const flags = `--chrome${claudePermissionFlag(opts?.autoMode)}${modelFlag}${effortFlag}${settings}${addDir}`;
     const sysFlag = systemPrompt ? ` --append-system-prompt ${shellQuote(systemPrompt)}` : "";
     const promptArg = prompt ? ` ${shellQuote(prompt)}` : "";
     const tail = `${flags}${sysFlag}${promptArg}`;
     cmd = sessionId && opts?.resume ? claudeResumeOrFresh(sessionId, worktreePath, tail) : `claude ${sessionId ? `--session-id ${sessionId} ` : opts?.resume ? "--continue " : ""}${tail}\r`;
   } else {
     const combined = [systemPrompt, prompt].filter(Boolean).join("\n\n");
-    const codexEffortFlag = effort ? `-c ${shellQuote(`model_reasoning_effort="${effort}"`)} ` : "";
-    const codexHome = opts?.library ? `CODEX_HOME=${shellQuote(toShellPath(opts.library.codexHome))} ` : "";
+    const codexEffortFlag = effort && effort !== "auto" ? `-c ${shellQuote(`model_reasoning_effort="${effort}"`)} ` : "";
     const args = [
       codexAutoFlag(opts?.autoMode).trim(),
       codexEffortFlag.trim(),
       model ? `--model ${model}` : "",
       combined ? shellQuote(combined) : ""
     ].filter(Boolean);
-    cmd = `${codexHome}${["codex", ...args].join(" ")}\r`;
+    cmd = `${["codex", ...args].join(" ")}\r`;
   }
   if (cmd.length > 2e5) console.warn(`[VibeFlow] launch command is ${cmd.length} bytes \u2014 approaching ARG_MAX`);
   return cmd;
@@ -647,16 +637,11 @@ function taskModel(task) {
 function buildAgentCommand(task, systemPrompt, opts, workspacePath) {
   const agent = taskAgent(task);
   const model = taskModel(task);
-  const artifactsDir = agentArtifactsDir(task.worktreePath, workspacePath) ?? ARTIFACTS_FALLBACK_DIR;
-  const builtInPrompt = buildArtifactPrompt(artifactsDir);
-  const libraryPrompt = opts?.library?.promptText?.trim();
-  const customPrompt = resolveSystemPrompt(systemPrompt);
-  const sys = [builtInPrompt, libraryPrompt, customPrompt].filter(Boolean).join("\n\n");
+  const sys = resolveSystemPrompt(systemPrompt);
   const includeTaskPrompt = opts?.includeTaskPrompt !== false;
-  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 prompt = includeTaskPrompt && !opts?.resume ? buildPrompt(task) : "";
   const sessionId = agent === "claude" && includeTaskPrompt ? executorSessionId(task.id, task.runId) : void 0;
-  return boardEnvPrefix(task, opts) + assembleCommand(
+  return boardEnvPrefix(task, opts, workspacePath) + assembleCommand(
     agent,
     sys,
     prompt,
@@ -793,8 +778,8 @@ var init_attachments = __esm({
 function modelFor(models, modelId) {
   return modelId ? models?.find((m) => m.id === modelId) : models?.find((m) => m.isDefault);
 }
-function isAgentEffort(value) {
-  return typeof value === "string" && AGENT_EFFORTS.includes(value);
+function isManualEffort(value) {
+  return typeof value === "string" && MANUAL_EFFORTS.includes(value);
 }
 function allowedEfforts(model) {
   return model?.efforts ?? null;
@@ -804,17 +789,19 @@ function selectableEfforts(model) {
 }
 function clampEffort(effort, allowed) {
   if (allowed.length === 0) return void 0;
-  if (effort === void 0 || allowed.includes(effort)) return effort;
-  const rank = AGENT_EFFORTS.indexOf(effort);
-  const ordered = AGENT_EFFORTS.filter((level) => allowed.includes(level));
-  const notDeeper = ordered.filter((level) => AGENT_EFFORTS.indexOf(level) <= rank);
+  if (effort === void 0 || effort === "auto") return void 0;
+  if (allowed.includes(effort)) return effort;
+  const rank = MANUAL_EFFORTS.indexOf(effort);
+  const ordered = MANUAL_EFFORTS.filter((level) => allowed.includes(level));
+  const notDeeper = ordered.filter((level) => MANUAL_EFFORTS.indexOf(level) <= rank);
   return notDeeper.length > 0 ? notDeeper[notDeeper.length - 1] : ordered[0];
 }
-var AGENT_EFFORTS, UNKNOWN_MODEL_EFFORTS;
+var MANUAL_EFFORTS, AGENT_EFFORTS, UNKNOWN_MODEL_EFFORTS;
 var init_effort = __esm({
   "packages/core/src/effort.ts"() {
     "use strict";
-    AGENT_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
+    MANUAL_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
+    AGENT_EFFORTS = ["auto", ...MANUAL_EFFORTS];
     UNKNOWN_MODEL_EFFORTS = ["low", "medium", "high", "xhigh"];
   }
 });
@@ -1104,7 +1091,7 @@ var init_progress = __esm({
 // packages/tui/src/task-form.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import fs24 from "fs";
-import os9 from "os";
+import os8 from "os";
 import path28 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render as render2, useApp, useInput } from "ink";
@@ -1177,10 +1164,10 @@ function modelOptions(ctx, agentCli, current) {
   return options;
 }
 function effortOptions(ctx, agentCli, model) {
-  return selectableEfforts(modelFor(ctx.models[agentCli], taskModel({ agentCli, model })));
+  return ["auto", ...selectableEfforts(modelFor(ctx.models[agentCli], taskModel({ agentCli, model })))];
 }
 function fitEffort(ctx, s) {
-  const effort = clampEffort(s.effort, effortOptions(ctx, s.agentCli, s.model)) ?? s.effort;
+  const effort = s.effort === "auto" ? "auto" : clampEffort(s.effort, effortOptions(ctx, s.agentCli, s.model).filter(isManualEffort)) ?? s.effort;
   return effort === s.effort ? s : { ...s, effort };
 }
 function blockReason(s, ctx, loadingGit) {
@@ -1231,7 +1218,7 @@ function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs24.mkdtempSync(path28.join(os9.tmpdir(), "vibeflow-"));
+  const dir = fs24.mkdtempSync(path28.join(os8.tmpdir(), "vibeflow-"));
   const file = path28.join(dir, "description.md");
   try {
     fs24.writeFileSync(file, text);
@@ -1312,9 +1299,9 @@ 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(path28.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir())));
+      if (value2) setProject(path28.resolve(value2.replace(/^~(?=$|\/)/, os8.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path28.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir()));
+      const file = path28.resolve(value2.replace(/^~(?=$|\/)/, os8.homedir()));
       if (!fs24.existsSync(file) || !fs24.statSync(file).isFile()) {
         setMessage(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
         return;
@@ -1405,7 +1392,6 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
         return lines.length > 1 ? `${lines[0]} \u2026\uFF08\u5171 ${lines.length} \u884C\uFF09` : lines[0];
       }
       case "effort": {
-        if (effortOptions(ctx, s.agentCli, s.model).length === 0) return "\u4E0D\u9069\u7528";
         const e = EFFORTS.find((x) => x.value === s.effort) ?? EFFORTS[0];
         return `\u2039 ${e.label} \xB7 ${e.value} \u203A`;
       }
@@ -1441,7 +1427,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       return s.mode === "edit" && s.worktreePath ? `${when} \u9019\u5F35\u5361\u5DF2\u6709 worktree\uFF1A\u66F4\u6539\u5206\u652F\u3001\u5C08\u6848\u6216\u57FA\u6E96\u5206\u652F\u6703\u79FB\u9664\u5B83\uFF08\u6709\u672A\u5B8C\u6210\u8B8A\u66F4\u6642\u7121\u6CD5\u5132\u5B58\uFF09\u3002` : when;
     }
     if (field === "effort") {
-      if (effortOptions(ctx, s.agentCli, s.model).length === 0) return "\u9019\u500B model \u4E0D\u652F\u63F4\u8ABF\u6574\u63A8\u7406\u5F37\u5EA6\uFF0C\u555F\u52D5\u6642\u4E0D\u6703\u6307\u5B9A\u4EFB\u52D9\u8907\u96DC\u5EA6\u3002";
+      if (effortOptions(ctx, s.agentCli, s.model).length === 1) return "\u9019\u500B model \u4E0D\u652F\u63F4\u8ABF\u6574\u63A8\u7406\u5F37\u5EA6\uFF0C\u555F\u52D5\u6642\u4F7F\u7528\u6A21\u578B\u9810\u8A2D\u503C\u3002";
       const e = EFFORTS.find((x) => x.value === s.effort) ?? EFFORTS[0];
       return `${e.description} Claude Code \u8207 Codex \u6703\u5728\u555F\u52D5\u6B64\u4EFB\u52D9\u6642\u5957\u7528\uFF1B\u53EF\u9078\u7684\u7D1A\u8DDD\u4F9D model \u800C\u5B9A\u3002`;
     }
@@ -1521,6 +1507,7 @@ var init_task_form = __esm({
     init_attachments();
     h = React.createElement;
     EFFORTS = [
+      { value: "auto", label: "\u81EA\u52D5", description: "Jev \u4F9D\u4EFB\u52D9\u8207\u76EE\u524D\u6A21\u578B\u9078\u64C7\u63A8\u7406\u5F37\u5EA6\u3002" },
       { value: "low", label: "\u5FEB\u901F", description: "\u9069\u5408\u7BC4\u570D\u660E\u78BA\u3001\u4F4E\u98A8\u96AA\u7684\u5C0F\u4EFB\u52D9\u3002" },
       { value: "medium", label: "\u6A19\u6E96", description: "\u517C\u9867\u901F\u5EA6\u8207\u63A8\u7406\u6DF1\u5EA6\uFF0C\u9069\u5408\u4E00\u822C\u958B\u767C\u4EFB\u52D9\u3002" },
       { value: "high", label: "\u6DF1\u5165", description: "\u9069\u5408\u8DE8\u6A94\u6848\u3001\u9664\u932F\u6216\u9700\u8981\u8F03\u591A\u5224\u65B7\u7684\u4EFB\u52D9\u3002" },
@@ -1528,7 +1515,7 @@ var init_task_form = __esm({
       { value: "max", label: "\u6700\u5927", description: "\u6700\u6DF1\u7684\u63A8\u7406\uFF0C\u9069\u5408\u6700\u56F0\u96E3\u7684\u554F\u984C\u3002" },
       { value: "ultra", label: "\u59D4\u6D3E", description: "\u6700\u6DF1\u63A8\u7406\u4E26\u81EA\u52D5\u59D4\u6D3E\u5B50\u4EFB\u52D9\uFF0C\u8017\u6642\u8207\u7528\u91CF\u53EF\u80FD\u660E\u986F\u589E\u52A0\u3002" }
     ];
-    DEFAULT_EFFORT = "medium";
+    DEFAULT_EFFORT = "auto";
     LABELS = {
       title: "\u4EFB\u52D9\u6A19\u984C",
       project: "\u5C08\u6848\u8CC7\u6599\u593E",
@@ -2470,6 +2457,7 @@ function createBridge(t) {
     /** Running app version (package.json version baked into the build). */
     getVersion: () => t.invoke("app:getVersion"),
     getUpdateStatus: () => t.invoke("host:updateStatus"),
+    openUpdateTerminal: () => t.invoke("host:openUpdateTerminal"),
     onUpdateAvailable: (callback) => t.on("update:available", (payload) => callback(payload)),
     /**
      * Fired when an external write (e.g. CLI) changes the store backing file.
@@ -3336,6 +3324,30 @@ var SNIFF_BYTES = 8 * 1024;
 function agentArtifactsPath(baseDir, worktreePath) {
   return path11.join(baseDir, `${path11.basename(worktreePath)}${ARTIFACTS_DIR_SUFFIX2}`);
 }
+function ensureTaskArtifactDirs(task) {
+  if (!task.worktreePath) throw new Error("\u4EFB\u52D9\u5C1A\u672A\u5EFA\u7ACB worktree");
+  const dir = task.workspacePath ? agentArtifactsPath(task.workspacePath, task.worktreePath) : path11.join(task.worktreePath, ARTIFACTS_FALLBACK_DIR2);
+  fs7.mkdirSync(path11.join(dir, SCRATCH_DIR_NAME2), { recursive: true });
+  return dir;
+}
+function addTaskArtifact(task, filePath) {
+  const source = path11.resolve(filePath);
+  const stat = fs7.lstatSync(source);
+  if (!stat.isFile()) throw new Error("Artifact \u4F86\u6E90\u5FC5\u9808\u662F\u4E00\u822C\u6A94\u6848");
+  const dir = ensureTaskArtifactDirs(task);
+  if (path11.dirname(source) === dir) return source;
+  const { name, ext } = path11.parse(source);
+  for (let index = 0; index < 1e3; index += 1) {
+    const destination = path11.join(dir, index === 0 ? `${name}${ext}` : `${name}-${index}${ext}`);
+    try {
+      fs7.copyFileSync(source, destination, fs7.constants.COPYFILE_EXCL);
+      return destination;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  }
+  throw new Error("Artifact \u8CC7\u6599\u593E\u6709\u592A\u591A\u540C\u540D\u6A94\u6848");
+}
 function mediaKind(filePath, size) {
   const extension = path11.extname(filePath).toLowerCase();
   const imageMime = IMAGE_MIME[extension];
@@ -4271,7 +4283,7 @@ init_effort();
 import { execFile as execFile6 } from "child_process";
 import { promisify as promisify3 } from "util";
 var pexec3 = promisify3(execFile6);
-var DEFAULT_TASK_EFFORT = "medium";
+var DEFAULT_TASK_EFFORT = "auto";
 var AGENT_CLIS = [
   {
     id: "claude",
@@ -4462,7 +4474,7 @@ function updateTaskFromInput(input) {
 init_attachments();
 var AGENT_IDS = AGENT_CLIS.map((agent) => agent.id);
 var STATUSES = ["backlog", "in_progress", "done"];
-var SUBCOMMANDS = ["create", "update"];
+var SUBCOMMANDS = ["create", "update", "artifact"];
 var MODES = ["existing", "new"];
 var AUTO_MODES = ["on", "off"];
 var TASK_USAGE = `
@@ -4471,6 +4483,7 @@ VibeFlow task commands
 Usage:
   vibeflow task create [options]
   vibeflow task update [options]
+  vibeflow task artifact add --file <path> [options]
 
 task create options:
   --project <path>       Target project directory (required)
@@ -4484,7 +4497,7 @@ task create options:
   --mode <mode>          ${MODES.join(" | ")}  (default: existing; "new" runs git init first)
   --agent <id>           Task agent: ${AGENT_IDS.join(" | ")}  (default: claude)
   --model <id>           Task model (default: the agent's own default)
-  --effort <level>       ${AGENT_EFFORTS.join(" | ")}  (default: medium, same as the UI)
+  --effort <level>       ${AGENT_EFFORTS.join(" | ")}  (default: auto, same as the UI)
   --auto-mode <on|off>   Let the agent act without asking for approval
                          (default: the board-wide setting, same as the UI)
   --attach <path>        Attach a file; repeat the flag for several files
@@ -4503,6 +4516,12 @@ task update options:
   At least one of --title / --prompt / --status is required. Branch, worktree
   and project path are provisioned on disk and cannot be changed here.
 
+task artifact add options:
+  --file <path>         Copy a file into the card's user-facing Artifacts folder
+  --task <id>           Card ID (defaults to VIBEFLOW_TASK_ID in a task shell)
+  --store-path <dir>    Store directory (defaults to VIBEFLOW_STORE_DIR in a task shell)
+  --profile <name>      dev | prod \u2014 when no store path is given
+
 Notes:
   A card created with --status in_progress does NOT start running by itself.
   Every launch is started by hand from the app.
@@ -4570,6 +4589,7 @@ async function taskCommand(argv) {
         effort: { type: "string" },
         "auto-mode": { type: "string" },
         attach: { type: "string", multiple: true },
+        file: { type: "string" },
         "store-path": { type: "string" },
         profile: { type: "string" },
         help: { type: "boolean", short: "h" }
@@ -4581,13 +4601,24 @@ async function taskCommand(argv) {
     fail("INVALID_ARGUMENT", err.message);
   }
   const { values, positionals } = parsed;
-  const [sub] = positionals;
+  const [sub, action] = positionals;
   if (values.help || !sub) return null;
-  const storePath = resolveStorePath(values["store-path"], values.profile);
+  const storePath = resolveStorePath(
+    values["store-path"] ?? (sub === "artifact" ? process.env.VIBEFLOW_STORE_DIR : void 0),
+    values.profile
+  );
   setPlatform(createNodePlatform({ userDataDir: storePath }));
   if (!SUBCOMMANDS.includes(sub)) {
     fail("UNKNOWN_COMMAND", `Unknown command: "task ${sub}". Use: ${SUBCOMMANDS.map((s) => `task ${s}`).join(" | ")}`);
   }
+  if (sub === "artifact") {
+    if (action !== "add") fail("UNKNOWN_COMMAND", "Use: task artifact add --file <path>");
+    const taskId = values.task ?? process.env.VIBEFLOW_TASK_ID;
+    if (!taskId || !values.file) fail("MISSING_ARGUMENT", "task artifact add needs --file and --task (or VIBEFLOW_TASK_ID)");
+    const task2 = findTask(taskId);
+    if (!task2) fail("TASK_NOT_FOUND", `Task not found: ${taskId}`);
+    return { taskId, path: addTaskArtifact(task2, values.file) };
+  }
   if (sub === "update") {
     if (!values.task) fail("MISSING_ARGUMENT", "Missing required arguments: --task");
     requireOneOf("--status", values.status, STATUSES);
@@ -4695,7 +4726,6 @@ import path15 from "path";
 // packages/core/src/library.ts
 import { createHash } from "crypto";
 import fs10 from "fs";
-import os3 from "os";
 import path14 from "path";
 var LIBRARY_DIR = "library";
 var LIBRARY_KINDS = ["skill", "prompt", "script"];
@@ -4712,7 +4742,6 @@ function libraryPaths(root) {
     skills: path14.join(root, KIND_DIR.skill),
     prompts: path14.join(root, KIND_DIR.prompt),
     scripts: path14.join(root, KIND_DIR.script),
-    plugin: path14.join(root, "plugin"),
     codexHome: path14.join(root, "codex-home")
   };
 }
@@ -4960,9 +4989,6 @@ function requireEntry(root, kind, name) {
   if (!found2) throw new Error(`\u9805\u76EE\u5BEB\u5165\u5F8C\u8B80\u4E0D\u56DE\u4F86\uFF1A${kind}/${name}`);
   return found2;
 }
-function projectSkillsDir(worktreePath) {
-  return path14.join(worktreePath, ".claude", "skills");
-}
 function skillNamesIn(dir) {
   try {
     return fs10.readdirSync(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).map((d) => d.name).filter((name) => fs10.existsSync(path14.join(dir, name, "SKILL.md"))).sort();
@@ -4970,132 +4996,6 @@ function skillNamesIn(dir) {
     return [];
   }
 }
-var PLUGIN_MANIFEST_DIR = ".claude-plugin";
-function buildPluginDir(root) {
-  const paths = libraryPaths(root);
-  const enabled = listLibrary(root).filter((e) => e.kind === "skill" && e.enabled);
-  fs10.rmSync(path14.join(paths.plugin, "skills"), { recursive: true, force: true });
-  fs10.mkdirSync(path14.join(paths.plugin, PLUGIN_MANIFEST_DIR), { recursive: true });
-  fs10.mkdirSync(path14.join(paths.plugin, "skills"), { recursive: true });
-  fs10.writeFileSync(
-    path14.join(paths.plugin, PLUGIN_MANIFEST_DIR, "plugin.json"),
-    `${JSON.stringify(
-      {
-        name: "vibeflow-library",
-        version: "1.0.0",
-        description: "Skills delivered by VibeFlow for this task."
-      },
-      null,
-      2
-    )}
-`
-  );
-  for (const entry of enabled) {
-    fs10.cpSync(entry.path, path14.join(paths.plugin, "skills", entry.name), {
-      recursive: true,
-      dereference: true
-    });
-  }
-  return { pluginDir: paths.plugin, skills: enabled.map((e) => e.name) };
-}
-function linkOrSkip(target, linkPath) {
-  if (!fs10.existsSync(target)) return false;
-  const source = path14.resolve(target);
-  const attempts = fs10.statSync(source).isDirectory() ? [
-    () => fs10.symlinkSync(source, linkPath, "junction"),
-    () => fs10.cpSync(source, linkPath, { recursive: true, dereference: true })
-  ] : [
-    () => fs10.symlinkSync(source, linkPath),
-    () => fs10.linkSync(source, linkPath),
-    () => fs10.copyFileSync(source, linkPath)
-  ];
-  for (const attempt of attempts) {
-    try {
-      fs10.rmSync(linkPath, { recursive: true, force: true });
-      attempt();
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-function buildCodexHome(root, worktreePath, userCodexHome = path14.join(os3.homedir(), ".codex")) {
-  const paths = libraryPaths(root);
-  const skillsDir = path14.join(paths.codexHome, "skills");
-  fs10.rmSync(skillsDir, { recursive: true, force: true });
-  fs10.mkdirSync(skillsDir, { recursive: true });
-  for (const file of ["auth.json", "config.toml"]) {
-    linkOrSkip(path14.join(userCodexHome, file), path14.join(paths.codexHome, file));
-  }
-  const result = {
-    codexHome: paths.codexHome,
-    project: [],
-    user: [],
-    library: [],
-    shadowed: []
-  };
-  const claimed = /* @__PURE__ */ new Map();
-  const projectDir = worktreePath ? projectSkillsDir(worktreePath) : void 0;
-  if (projectDir) {
-    for (const name of skillNamesIn(projectDir)) {
-      if (linkOrSkip(path14.join(projectDir, name), path14.join(skillsDir, name))) {
-        result.project.push(name);
-        claimed.set(name, "project");
-      }
-    }
-  }
-  const userDir = path14.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(path14.join(userDir, name), path14.join(skillsDir, name))) {
-      result.user.push(name);
-      claimed.set(name, "user");
-    }
-  }
-  for (const entry of listLibrary(root)) {
-    if (entry.kind !== "skill" || !entry.enabled) continue;
-    const owner = claimed.get(entry.name);
-    if (owner) {
-      result.shadowed.push({ name: entry.name, keptFrom: owner, dropped: "library" });
-      continue;
-    }
-    fs10.cpSync(entry.path, path14.join(skillsDir, entry.name), {
-      recursive: true,
-      dereference: true
-    });
-    result.library.push(entry.name);
-  }
-  return result;
-}
-function libraryLaunchInfoAt(root, worktreePath, userCodexHome) {
-  const entries = listLibrary(root).filter((e) => e.enabled);
-  if (entries.length === 0) return null;
-  const { pluginDir } = buildPluginDir(root);
-  const { codexHome } = buildCodexHome(root, worktreePath, userCodexHome);
-  const scripts = entries.filter((e) => e.kind === "script").map((e) => ({ name: e.name, path: e.path, description: e.description }));
-  const promptBodies = entries.filter((e) => e.kind === "prompt").map((e) => readEntryContent(root, "prompt", e.name).trim()).filter(Boolean);
-  const lines = [...promptBodies];
-  if (scripts.length > 0) {
-    lines.push(
-      "\u53EF\u7528\u7684\u5DE5\u5177\u8173\u672C\uFF08\u9700\u8981\u6642\u81EA\u884C\u57F7\u884C\uFF0C\u4E0D\u9700\u8981\u5C31\u5225\u8DD1\uFF09\uFF1A",
-      ...scripts.map((s) => `- ${s.path}${s.description ? ` \u2014 ${s.description}` : ""}`)
-    );
-  }
-  return {
-    pluginDir,
-    codexHome,
-    libraryDir: root,
-    scripts,
-    promptText: lines.join("\n\n")
-  };
-}
-async function libraryLaunchInfo(worktreePath) {
-  return libraryLaunchInfoAt(await libraryRoot(), worktreePath);
-}
 
 // packages/core/src/library-builtins.ts
 function builtinSkillsDir() {
@@ -5201,19 +5101,19 @@ async function syncBuiltinsAtStartup() {
 
 // packages/core/src/service.ts
 import fs19 from "fs";
-import os8 from "os";
+import os7 from "os";
 import path23 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // packages/core/src/agent-models.ts
 import fs13 from "fs";
-import os6 from "os";
+import os5 from "os";
 import path17 from "path";
 
 // packages/core/src/claude-models.ts
 init_effort();
 import fs12 from "fs";
-import os4 from "os";
+import os3 from "os";
 import path16 from "path";
 
 // packages/core/src/json-lines-process.ts
@@ -5318,7 +5218,7 @@ var CLAUDE_MODELS_TIMEOUT_MS = 15e3;
 var REQUEST_ID = "vibeflow-models";
 var CLAUDE_ARGS = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"];
 function openClaude() {
-  const cwd = fs12.mkdtempSync(path16.join(os4.tmpdir(), "vf-claude-models-"));
+  const cwd = fs12.mkdtempSync(path16.join(os3.tmpdir(), "vf-claude-models-"));
   return spawnJsonLines("claude", CLAUDE_ARGS, {
     cwd,
     timeoutMs: CLAUDE_MODELS_TIMEOUT_MS,
@@ -5348,7 +5248,7 @@ function parseClaudeInitialize(message) {
     seen.add(id);
     const label = typeof entry.displayName === "string" && entry.displayName.trim() ? entry.displayName.trim() : id;
     const description = typeof entry.description === "string" && entry.description.trim() ? entry.description.trim() : void 0;
-    const levels = entry.supportsEffort === true && Array.isArray(entry.supportedEffortLevels) ? entry.supportedEffortLevels.filter(isAgentEffort) : [];
+    const levels = entry.supportsEffort === true && Array.isArray(entry.supportedEffortLevels) ? entry.supportedEffortLevels.filter(isManualEffort) : [];
     const isDefault = !defaultMarked && defaultResolved !== void 0 && entry.resolvedModel === defaultResolved;
     if (isDefault) defaultMarked = true;
     models.push({ id, label, ...description ? { description } : {}, efforts: levels, ...isDefault ? { isDefault } : {} });
@@ -5369,7 +5269,7 @@ async function fetchClaudeModels(open = openClaude) {
 // packages/core/src/codex-models.ts
 init_effort();
 init_env();
-import os5 from "os";
+import os4 from "os";
 var CODEX_MODELS_TIMEOUT_MS = 2e4;
 var MAX_PAGES = 20;
 var CodexLoginRequiredError = class extends Error {
@@ -5382,7 +5282,7 @@ function codexAppServerCommand() {
   return {
     bin: "codex",
     args: ["app-server", "--listen", "stdio://"],
-    cwd: os5.homedir(),
+    cwd: os4.homedir(),
     env: execEnv()
   };
 }
@@ -5411,7 +5311,7 @@ function parseCodexModelPage(result) {
     const id = entry.id.trim();
     const label = typeof entry.displayName === "string" && entry.displayName.trim() ? entry.displayName.trim() : id;
     const description = typeof entry.description === "string" && entry.description.trim() ? entry.description.trim() : void 0;
-    const efforts = Array.isArray(entry.supportedReasoningEfforts) ? entry.supportedReasoningEfforts.map((e) => isRecord2(e) ? e.reasoningEffort : void 0).filter(isAgentEffort) : void 0;
+    const efforts = Array.isArray(entry.supportedReasoningEfforts) ? entry.supportedReasoningEfforts.map((e) => isRecord2(e) ? e.reasoningEffort : void 0).filter(isManualEffort) : void 0;
     models.push({
       id,
       label,
@@ -5471,7 +5371,7 @@ function builtinModels(id) {
 }
 function defaultCodexHome() {
   const configured = process.env.CODEX_HOME?.trim();
-  return configured ? configured : path17.join(os6.homedir(), ".codex");
+  return configured ? configured : path17.join(os5.homedir(), ".codex");
 }
 function parseCodexCatalog(raw) {
   const body = JSON.parse(raw);
@@ -5557,118 +5457,68 @@ function createModelCatalog(opts) {
 }
 
 // packages/core/src/jev-router.ts
+init_effort();
 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, onPhase) {
-      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);
+    async route(task, catalog) {
+      const model = modelFor(catalog, taskModel(task));
+      const levels = selectableEfforts(model);
+      if (levels.length === 0) return { status: "fallback", reason: "\u76EE\u524D\u6A21\u578B\u4E0D\u652F\u63F4\u8ABF\u6574 effort" };
       try {
-        onPhase?.("judging");
-        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"
+        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: {
+              task: buildPrompt(task).slice(0, MAX_TASK_CHARS),
+              agent: task.agentCli === "codex" ? "codex" : "claude",
+              currentModel: model?.id ?? taskModel(task) ?? "CLI default (catalog unavailable)"
+            },
+            questions: {
+              effort: {
+                type: "choice",
+                instructions: "Choose the lowest reasoning effort likely to complete this software task correctly on the current model. Increase effort for complexity, ambiguity, or risk.",
+                criteria: Object.fromEntries(levels.map((level) => [level, effortDescription(level)]))
+              }
             }
-          }
+          }),
+          signal: AbortSignal.timeout(15e3)
         });
-        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");
-          onPhase?.("planning");
-          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");
+        if (!response.ok) throw new Error(`Jev API \u56DE\u61C9 ${response.status}`);
+        const body = await response.json();
+        const choice = body.answers?.effort;
+        if (choice?.type !== "choice" || !levels.includes(choice.choice)) {
+          throw new Error("Jev \u9078\u4E86\u76EE\u524D\u6A21\u578B\u4E0D\u652F\u63F4\u7684 effort");
         }
-        onPhase?.("selecting");
-        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 } : {}
-        };
+        return { status: "routed", effort: choice.choice };
       } catch (err) {
         return { status: "fallback", reason: err instanceof Error ? err.message : String(err) };
       }
     }
   };
 }
+function effortDescription(level) {
+  const descriptions = {
+    low: "Routine, small and well scoped work",
+    medium: "Typical development with limited uncertainty",
+    high: "Complex debugging or several interacting files",
+    xhigh: "Difficult design or extensive reasoning",
+    max: "The hardest, highest risk tasks",
+    ultra: "Deepest reasoning with automatic delegation"
+  };
+  return descriptions[level];
+}
 
 // packages/core/src/jev-credentials.ts
 import fs14 from "fs";
@@ -6634,7 +6484,7 @@ init_launch();
 init_progress();
 init_launch();
 import fs18 from "fs";
-import os7 from "os";
+import os6 from "os";
 import path22 from "path";
 var SINCE_SLACK_MS = 5e3;
 function claudeProjectDir(home, cwd) {
@@ -6735,7 +6585,7 @@ function codexDayDirs(sessionsRoot, since) {
   return days;
 }
 function createProgressTracker(opts) {
-  const home = opts.homeDir ?? os7.homedir();
+  const home = opts.homeDir ?? os6.homedir();
   const codexHomes = opts.codexHomes ?? (() => [path22.join(home, ".codex")]);
   const pollMs = opts.pollMs ?? 2e3;
   const entries = /* @__PURE__ */ new Map();
@@ -6989,7 +6839,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     libraryCodexHome = libraryPaths(root).codexHome;
   }).catch(() => {
   });
-  const home = homeDir ?? os8.homedir();
+  const home = homeDir ?? os7.homedir();
   const progress = createProgressTracker({
     homeDir: home,
     codexHomes: () => [path23.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
@@ -7066,16 +6916,16 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     requireTask(key.split(":")[0]);
     return key;
   }
-  function launchEffort(task, selectedModel = taskModel(task)) {
-    const model = models.findModel(taskAgent(task), selectedModel);
-    return model?.efforts ? clampEffort(task.effort, model.efforts) : task.effort;
+  function launchEffort(task, route) {
+    const effort = task.effort === "auto" ? route?.effort : task.effort;
+    const model = models.findModel(taskAgent(task), taskModel(task));
+    return model?.efforts ? clampEffort(effort, model.efforts) : effort;
   }
   async function launchCommand(task, intent) {
     const settings = getSettings();
-    const library = await libraryLaunchInfo(task.worktreePath);
     const boardCli = await boardCliLaunchInfo();
-    let route = task.model?.trim() || task.jevRoute?.status === "routing" ? void 0 : task.jevRoute;
-    if (!task.model?.trim() && !intent.resume && intent.includeTaskPrompt !== false) {
+    let route = task.jevRoute?.status === "routing" ? void 0 : task.jevRoute;
+    if (task.effort === "auto" && !intent.resume && intent.includeTaskPrompt !== false) {
       let pending = routing.get(task.id);
       if (!pending) {
         const setRoute = (jevRoute) => {
@@ -7083,9 +6933,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
           bus.emit("state:changed", getState());
         };
         pending = (async () => {
-          setRoute({ status: "routing", phase: "judging" });
+          setRoute({ status: "routing" });
           const candidateModels = (await (router.enabled === false ? models.get(taskAgent(task)) : models.refresh(taskAgent(task)))).models;
-          const selected = await router.route(task, candidateModels, (phase) => setRoute({ status: "routing", phase }));
+          const selected = await router.route(task, candidateModels);
           setRoute(selected);
           return selected;
         })().catch((err) => {
@@ -7096,24 +6946,21 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       }
       route = await pending;
     }
-    const selectedModel = task.model?.trim() ? taskModel(task) : route?.model;
     return buildAgentCommand(
-      { ...task, model: selectedModel, effort: launchEffort(task, selectedModel) },
+      { ...task, model: taskModel(task), effort: launchEffort(task, route) },
       settings.systemPrompt ?? "",
       {
         resume: intent.resume === true,
         includeTaskPrompt: intent.includeTaskPrompt !== false,
-        library: library ?? void 0,
         boardCli,
-        autoMode: task.autoMode ?? settings.autoMode,
-        preflightPlan: !intent.resume ? route?.plan : void 0
+        autoMode: task.autoMode ?? settings.autoMode
       },
       task.workspacePath
     );
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path23.join(os8.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path23.join(os7.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
   }
   async function removeTaskWorktree(task) {
     if (!task.projectPath || !task.worktreePath) return;
@@ -7411,6 +7258,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
           command = (await launchCommand(task, intent)).replace(/\r$/, "");
         }
       }
+      if (p.launch) ensureTaskArtifactDirs(task);
       const result = await sessions.start(key, {
         cwd,
         command,
@@ -8106,6 +7954,66 @@ async function checkForUpdate(packageName2, currentVersion, query = async (name)
   return { currentVersion, latestVersion: latest };
 }
 
+// packages/cli/src/update-terminal.ts
+import { spawn as spawn8 } from "node:child_process";
+function updateTerminalCommands(platform) {
+  if (platform === "win32") {
+    return [{ cmd: "powershell.exe", args: ["-NoProfile", "-Command", "Start-Process cmd.exe -ArgumentList '/k vibeflow update'"], waitForExit: true }];
+  }
+  if (platform === "darwin") {
+    return [{ cmd: "osascript", args: [
+      "-e",
+      'tell application "Terminal" to activate',
+      "-e",
+      'tell application "Terminal" to do script "sudo vibeflow update"'
+    ], waitForExit: true }];
+  }
+  const command = "sudo vibeflow update; exec sh";
+  return [
+    { cmd: "gnome-terminal", args: ["--", "sh", "-c", command] },
+    { cmd: "x-terminal-emulator", args: ["-e", "sh", "-c", command] },
+    { cmd: "konsole", args: ["-e", "sh", "-c", command] },
+    { cmd: "xfce4-terminal", args: ["--command", `sh -c '${command}'`] },
+    { cmd: "xterm", args: ["-e", "sh", "-c", command] }
+  ];
+}
+function launch(command) {
+  return new Promise((resolve, reject) => {
+    const child = spawn8(command.cmd, command.args, {
+      detached: !command.waitForExit,
+      stdio: command.waitForExit ? ["ignore", "ignore", "pipe"] : "ignore",
+      windowsHide: false
+    });
+    child.once("error", reject);
+    if (command.waitForExit) {
+      let stderr = "";
+      child.stderr?.on("data", (chunk) => {
+        stderr += String(chunk);
+      });
+      child.once("close", (code2) => code2 === 0 ? resolve() : reject(new Error(stderr.trim() || `\u7121\u6CD5\u958B\u555F\u7D42\u7AEF\u6A5F\uFF08\u7D50\u675F\u78BC ${code2 ?? "unknown"}\uFF09`)));
+    } else {
+      child.once("spawn", () => {
+        child.unref();
+        resolve();
+      });
+    }
+  });
+}
+async function openUpdateTerminal(platform = process.platform, run3 = launch) {
+  if (platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+    throw new Error("\u627E\u4E0D\u5230\u5716\u5F62\u684C\u9762\uFF0C\u7121\u6CD5\u958B\u555F\u66F4\u65B0\u7D42\u7AEF\u6A5F\u3002");
+  }
+  for (const command of updateTerminalCommands(platform)) {
+    try {
+      await run3(command);
+      return;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  throw new Error("\u627E\u4E0D\u5230\u53EF\u7528\u7684\u7D42\u7AEF\u6A5F\uFF0C\u8ACB\u624B\u52D5\u57F7\u884C\u66F4\u65B0\u6307\u4EE4\u3002");
+}
+
 // packages/cli/src/host.ts
 var DEFAULT_HOST_PORT = 47820;
 async function waitForPort(userDataDir, timeoutMs = 1e4) {
@@ -8176,7 +8084,11 @@ async function startHost(options) {
         backend: sessions.kind,
         startedAt: lock.startedAt
       }),
-      "host:updateStatus": () => availableUpdate
+      "host:updateStatus": () => availableUpdate,
+      "host:openUpdateTerminal": () => {
+        if (!installedPackage || !availableUpdate) throw new Error("\u76EE\u524D\u6C92\u6709\u53EF\u5F9E\u5168\u57DF npm \u5B89\u88DD\u66F4\u65B0\u7684\u7248\u672C\u3002");
+        return openUpdateTerminal();
+      }
     };
     const server = await startWebServer({
       handlers,
@@ -8514,7 +8426,7 @@ Usage:
   vibeflow doctor          Check Node, git, tmux, node-pty and the agent CLIs
                            (--skip agents,web,\u2026 leaves checks out, e.g. on CI)
   vibeflow update          Install the latest global npm release (restart the host afterward)
-  vibeflow task \u2026          Create / update cards (vibeflow task --help)
+  vibeflow task \u2026          Create / update cards; add artifacts (vibeflow task --help)
 
 Options:
   --profile dev|prod       Store profile (dev = the "(development)" store npm run dev uses)