@kw-yeh/vibeflow 4.7.1 → 4.9.0

package/dist/vibeflow.mjs

@@ -499,6 +499,192 @@ var init_tmux_backend = __esm({
   }
 });
 
+// packages/core/src/launch.ts
+function pathBasename(p) {
+  const norm = p.replace(/\\/g, "/").replace(/\/+$/, "");
+  const i = norm.lastIndexOf("/");
+  return i >= 0 ? norm.slice(i + 1) : norm;
+}
+function agentArtifactsDir(worktreePath, workspacePath) {
+  if (!worktreePath || !workspacePath) return null;
+  const dir = toShellPath(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}` : "";
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function toShellPath(p) {
+  return p.replace(/\\/g, "/");
+}
+function boardEnvPrefix(task, opts) {
+  const board = opts?.boardCli;
+  if (!board) return "";
+  const entries = [
+    ["VIBEFLOW_TASK_ID", task.id],
+    ["VIBEFLOW_PROJECT_PATH", task.projectPath],
+    ["VIBEFLOW_BRANCH", task.branch],
+    ["VIBEFLOW_BASE_BRANCH", task.baseBranch],
+    ["VIBEFLOW_STORE_DIR", board?.storeDir],
+    ["VIBEFLOW_CLI", board?.cliPath],
+    ["VIBEFLOW_CLI_LOADER", board?.loaderPath],
+    ["VIBEFLOW_AUTO_MODE", opts?.autoMode ? "1" : "0"]
+  ];
+  const exports = entries.filter((entry) => Boolean(entry[1])).map(([key, value]) => `${key}=${shellQuote(toShellPath(value))}`);
+  return exports.length ? `export ${exports.join(" ")}; ` : "";
+}
+function codexAutoFlag(autoMode) {
+  return autoMode ? "--dangerously-bypass-approvals-and-sandbox " : "";
+}
+function claudeResumeOrFresh(sessionId, worktreePath, tail) {
+  if (!worktreePath) return `claude --resume ${sessionId} ${tail}\r`;
+  const munged = worktreePath.replace(/[^a-zA-Z0-9]/g, "-");
+  const sessionFile = `"$HOME/.claude/projects/${munged}/${sessionId}.jsonl"`;
+  return `if [ -f ${sessionFile} ]; then claude --resume ${sessionId} ${tail}; else claude --session-id ${sessionId} ${tail}; fi\r`;
+}
+function buildClaudeSettings(worktreePath) {
+  const settings = { theme: "dark" };
+  if (worktreePath) {
+    const dir = `${toShellPath(worktreePath)}/${SUBAGENTS_DIR2}`;
+    const command = `mkdir -p "${dir}" && cat > "${dir}/$(date +%s)-$$-$RANDOM.json"`;
+    const taskHook = {
+      matcher: "Task",
+      hooks: [{ type: "command", command }]
+    };
+    const eventsDir = `${toShellPath(worktreePath)}/${PROGRESS_EVENTS_DIR}`;
+    const progress = {
+      hooks: [{ type: "command", command: `mkdir -p "${eventsDir}" && cat > "${eventsDir}/$(date +%s)-$$-$RANDOM.json"; exit 0` }]
+    };
+    settings.hooks = {
+      PreToolUse: [taskHook],
+      PostToolUse: [taskHook, { matcher: TODO_TOOLS, ...progress }],
+      Stop: [progress],
+      Notification: [progress],
+      UserPromptSubmit: [progress]
+    };
+  }
+  return JSON.stringify(settings);
+}
+function resolveSystemPrompt(custom) {
+  return custom && custom.trim() ? custom : "";
+}
+function buildPrompt(task) {
+  const lines = [`\u4EFB\u52D9\u6A19\u984C\uFF1A${task.title}`];
+  const description = task.description?.trim();
+  if (description) {
+    lines.push("", "\u4EFB\u52D9\u63CF\u8FF0\uFF1A", description);
+  }
+  return lines.join("\n");
+}
+function executorSessionId(taskId, runId) {
+  const source = runId ? `${taskId}:${runId}` : taskId;
+  const raw = source.replace(/[^0-9a-f]/gi, "").toLowerCase();
+  const hex = runId ? `${raw.slice(0, 24).padEnd(24, "0")}${namespaceHash(`executor:${source}`)}` : raw.padEnd(32, "0").slice(0, 32);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+function namespaceHash(namespace) {
+  let hash = 2166136261;
+  for (let i = 0; i < namespace.length; i += 1) {
+    hash ^= namespace.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function assembleCommand(agent, systemPrompt, prompt, model, effort, opts, worktreePath, sessionId, workspacePath) {
+  let cmd;
+  if (agent === "claude") {
+    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 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 args = [
+      codexAutoFlag(opts?.autoMode).trim(),
+      codexEffortFlag.trim(),
+      model ? `--model ${model}` : "",
+      combined ? shellQuote(combined) : ""
+    ].filter(Boolean);
+    cmd = `${codexHome}${["codex", ...args].join(" ")}\r`;
+  }
+  if (cmd.length > 2e5) console.warn(`[VibeFlow] launch command is ${cmd.length} bytes \u2014 approaching ARG_MAX`);
+  return cmd;
+}
+function taskAgent(task) {
+  const agent = task.agentCli;
+  return agent && agent in AGENT_NAMES ? agent : "claude";
+}
+function taskModel(task) {
+  const model = task.model?.trim();
+  if (!model || RETIRED_MODELS[taskAgent(task)]?.includes(model)) return void 0;
+  return model;
+}
+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 includeTaskPrompt = opts?.includeTaskPrompt !== false;
+  const prompt = includeTaskPrompt && !opts?.resume ? buildPrompt(task) : "";
+  const sessionId = agent === "claude" && includeTaskPrompt ? executorSessionId(task.id, task.runId) : void 0;
+  return boardEnvPrefix(task, opts) + assembleCommand(
+    agent,
+    sys,
+    prompt,
+    model,
+    task.effort,
+    opts,
+    task.worktreePath,
+    sessionId,
+    workspacePath
+  );
+}
+var ARTIFACTS_DIR_SUFFIX, SCRATCH_DIR_NAME, ARTIFACTS_FALLBACK_DIR, AUTO_PERMISSION_MODE, SUBAGENTS_DIR2, PROGRESS_EVENTS_DIR, TODO_TOOLS, AGENT_NAMES, RETIRED_MODELS;
+var init_launch = __esm({
+  "packages/core/src/launch.ts"() {
+    "use strict";
+    ARTIFACTS_DIR_SUFFIX = ".artifacts";
+    SCRATCH_DIR_NAME = "scratch";
+    ARTIFACTS_FALLBACK_DIR = ".vibeflow-artifacts";
+    AUTO_PERMISSION_MODE = "auto";
+    SUBAGENTS_DIR2 = ".vibeflow-subagents";
+    PROGRESS_EVENTS_DIR = ".vibeflow-events";
+    TODO_TOOLS = "TodoWrite|TaskCreate|TaskUpdate";
+    AGENT_NAMES = {
+      claude: "Claude Code",
+      codex: "Codex CLI"
+    };
+    RETIRED_MODELS = {
+      codex: ["gpt-5-codex", "gpt-5"]
+    };
+  }
+});
+
 // packages/core/src/attachments.ts
 import { randomUUID } from "crypto";
 import { execFileSync as execFileSync3 } from "child_process";
@@ -599,6 +785,36 @@ var init_attachments = __esm({
   }
 });
 
+// packages/core/src/effort.ts
+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 allowedEfforts(model) {
+  return model?.efforts ?? null;
+}
+function selectableEfforts(model) {
+  return allowedEfforts(model) ?? UNKNOWN_MODEL_EFFORTS;
+}
+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);
+  return notDeeper.length > 0 ? notDeeper[notDeeper.length - 1] : ordered[0];
+}
+var AGENT_EFFORTS, UNKNOWN_MODEL_EFFORTS;
+var init_effort = __esm({
+  "packages/core/src/effort.ts"() {
+    "use strict";
+    AGENT_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
+    UNKNOWN_MODEL_EFFORTS = ["low", "medium", "high", "xhigh"];
+  }
+});
+
 // packages/core/src/progress.ts
 function emptyUsage() {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 };
@@ -883,9 +1099,9 @@ var init_progress = __esm({
 
 // packages/tui/src/task-form.ts
 import { spawnSync } from "child_process";
-import fs21 from "fs";
-import os7 from "os";
-import path25 from "path";
+import fs22 from "fs";
+import os9 from "os";
+import path26 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render, useApp, useInput } from "ink";
 function newFormState(defaultAutoMode, agents) {
@@ -951,11 +1167,18 @@ function visibleFields(s, ctx) {
   return fields;
 }
 function modelOptions(ctx, agentCli, current) {
-  const listed = ctx.models[agentCli] ?? [];
+  const listed = (ctx.models[agentCli] ?? []).map((m) => m.id);
   const options = ["", ...listed];
   if (current && !listed.includes(current)) options.push(current);
   return options;
 }
+function effortOptions(ctx, agentCli, model) {
+  return 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;
+  return effort === s.effort ? s : { ...s, effort };
+}
 function blockReason(s, ctx, loadingGit) {
   if (!s.title.trim()) return "\u8ACB\u8F38\u5165\u4EFB\u52D9\u6A19\u984C";
   if (loadingGit) return "\u5075\u6E2C Git \u72C0\u614B\u4E2D\u2026";
@@ -1004,17 +1227,17 @@ function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs21.mkdtempSync(path25.join(os7.tmpdir(), "vibeflow-"));
-  const file = path25.join(dir, "description.md");
+  const dir = fs22.mkdtempSync(path26.join(os9.tmpdir(), "vibeflow-"));
+  const file = path26.join(dir, "description.md");
   try {
-    fs21.writeFileSync(file, text);
+    fs22.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: fs21.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
+    return { text: fs22.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
   } finally {
-    fs21.rmSync(dir, { recursive: true, force: true });
+    fs22.rmSync(dir, { recursive: true, force: true });
   }
 }
 function cycle(list, current, step) {
@@ -1085,10 +1308,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(path25.resolve(value2.replace(/^~(?=$|\/)/, os7.homedir())));
+      if (value2) setProject(path26.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path25.resolve(value2.replace(/^~(?=$|\/)/, os7.homedir()));
-      if (!fs21.existsSync(file) || !fs21.statSync(file).isFile()) {
+      const file = path26.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir()));
+      if (!fs22.existsSync(file) || !fs22.statSync(file).isFile()) {
         setMessage(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
         return;
       }
@@ -1127,13 +1350,16 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       } else if (field === "baseBranch") {
         setS((prev) => ({ ...prev, baseBranch: cycle(prev.gitInfo?.branches ?? [], prev.baseBranch, step) }));
       } else if (field === "effort") {
-        setS((prev) => ({ ...prev, effort: cycle(EFFORTS.map((e) => e.value), prev.effort, step) }));
+        setS((prev) => {
+          const levels = effortOptions(ctx, prev.agentCli, prev.model);
+          return levels.length ? { ...prev, effort: cycle([...levels], prev.effort, step) } : prev;
+        });
       } else if (field === "autoMode") {
         setS((prev) => ({ ...prev, autoMode: !prev.autoMode }));
       } else if (field === "agent" && ctx.agents?.length) {
-        setS((prev) => ({ ...prev, agentCli: cycle(ctx.agents.map((a) => a.id), prev.agentCli, step), model: "" }));
+        setS((prev) => fitEffort(ctx, { ...prev, agentCli: cycle(ctx.agents.map((a) => a.id), prev.agentCli, step), model: "" }));
       } else if (field === "model") {
-        setS((prev) => ({ ...prev, model: cycle(modelOptions(ctx, prev.agentCli, prev.model), prev.model, step) }));
+        setS((prev) => fitEffort(ctx, { ...prev, model: cycle(modelOptions(ctx, prev.agentCli, prev.model), prev.model, step) }));
       }
       return;
     }
@@ -1168,14 +1394,15 @@ 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) => path25.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
+        return s.attachments.length ? s.attachments.map((a) => path26.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");
         return lines.length > 1 ? `${lines[0]} \u2026\uFF08\u5171 ${lines.length} \u884C\uFF09` : lines[0];
       }
       case "effort": {
-        const e = EFFORTS.find((x) => x.value === s.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`;
       }
       case "autoMode":
@@ -1185,8 +1412,12 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
         if (ctx.agents.length === 0) return "\u672A\u5075\u6E2C\u5230 Agent CLI\uFF08claude / codex\uFF09";
         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` : "\u7121\u6CD5\u53D6\u5F97 model list\uFF0C\u5C07\u4F7F\u7528\u9810\u8A2D model";
+      case "model": {
+        if (modelOptions(ctx, s.agentCli, s.model).length <= 1) return "\u7121\u6CD5\u53D6\u5F97 model list\uFF0C\u5C07\u4F7F\u7528\u9810\u8A2D model";
+        const listed = ctx.models[s.agentCli]?.find((m) => m.id === s.model);
+        const fallback = ctx.models[s.agentCli]?.find((m) => m.isDefault)?.label;
+        return `\u2039 ${s.model ? listed?.label ?? s.model : fallback ? `\u4F7F\u7528\u9810\u8A2D model\uFF08${fallback}\uFF09` : "\u4F7F\u7528\u9810\u8A2D model"} \u203A`;
+      }
       case "submit":
         return busy ?? (s.mode === "new" ? "\uFF3B \u5EFA\u7ACB\u4EFB\u52D9 \uFF3D" : "\uFF3B \u5132\u5B58\u8B8A\u66F4 \uFF3D");
     }
@@ -1199,13 +1430,17 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       if (info && !info.isRepo) return "\u9019\u500B\u8CC7\u6599\u593E\u4E0D\u662F Git repository\u3002\u8ACB\u6539\u9078\u4E00\u500B Git \u5C08\u6848\uFF0C\u6216\u5728\u4E0B\u65B9\u521D\u59CB\u5316\u3002";
       if (s.mode === "edit" && projectChanged(s)) return "\u5206\u652F\u6703\u5728\u65B0\u5C08\u6848\u3001\u5361\u7247\u958B\u59CB\u57F7\u884C\u6642\u624D\u5EFA\u7ACB\u3002";
       if (info?.isRepo && !info.hasRemote) return `\u6B64 repository \u6C92\u6709 remote\uFF0C\u5C07\u4EE5\u76EE\u524D\u5206\u652F (${info.currentBranch ?? "HEAD"}) \u70BA\u57FA\u6E96\u5EFA\u7ACB\u672C\u5730 worktree\u3002`;
-      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path25.basename(s.projectPath)}`;
+      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path26.basename(s.projectPath)}`;
     }
     if (field === "branch") {
       const when = info?.hasRemote ? "\u958B\u59CB\u57F7\u884C\u6642\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u4E26\u63A8\u5230 origin\uFF1B\u82E5 remote \u5DF2\u6709\u9019\u500B\u5206\u652F\uFF0C\u5247\u76F4\u63A5\u53D6\u56DE\u4E26\u63A5\u7E8C\u4E0A\u9762\u7684\u5DE5\u4F5C\u3002" : "\u958B\u59CB\u57F7\u884C\u6642\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u3002";
       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") 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`;
+    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";
+      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`;
+    }
     if (field === "autoMode") return s.autoMode ? "\u958B\u555F\uFF1AAgent \u6703\u76F4\u63A5\u4FEE\u6539\u6A94\u6848\u3001\u57F7\u884C\u6307\u4EE4\uFF0C\u4E0D\u6703\u9010\u6B21\u5411\u4F60\u78BA\u8A8D\u3002" : "\u95DC\u9589\uFF1AAgent \u6BCF\u6B21\u8981\u52D5\u4F5C\u524D\uFF0C\u90FD\u6703\u5728\u7D42\u7AEF\u6A5F\u88E1\u7B49\u4F60\u5141\u8A31\u3002";
     if (field === "submit") return blockReason(s, ctx, loadingGit);
     return null;
@@ -1260,7 +1495,7 @@ async function loadFormContext(api) {
   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 [a.id, list ? list.models : []];
     })
   );
   return {
@@ -1277,13 +1512,17 @@ var h, EFFORTS, DEFAULT_EFFORT, LABELS, TEXT_FIELDS;
 var init_task_form = __esm({
   "packages/tui/src/task-form.ts"() {
     "use strict";
+    init_effort();
+    init_launch();
     init_attachments();
     h = React.createElement;
     EFFORTS = [
       { 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" },
-      { value: "xhigh", label: "\u6975\u81F4", description: "\u9069\u5408\u9AD8\u8907\u96DC\u5EA6\u3001\u9577\u93C8\u63A8\u7406\u6216\u9AD8\u98A8\u96AA\u8B8A\u66F4\u3002" }
+      { value: "xhigh", label: "\u6975\u81F4", description: "\u9069\u5408\u9AD8\u8907\u96DC\u5EA6\u3001\u9577\u93C8\u63A8\u7406\u6216\u9AD8\u98A8\u96AA\u8B8A\u66F4\u3002" },
+      { 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";
     LABELS = {
@@ -1319,7 +1558,7 @@ __export(src_exports, {
   showDiff: () => showDiff
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import path26 from "path";
+import path27 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) {
@@ -1615,7 +1854,7 @@ function showDiff(task) {
   });
 }
 function tmuxAttach(opts, sessionName) {
-  const conf = path26.join(opts.userDataDir, "tmux.conf");
+  const conf = path27.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 : "" } });
@@ -1746,8 +1985,8 @@ var init_src = __esm({
 });
 
 // packages/cli/src/main.ts
-import fs22 from "fs";
-import path27 from "path";
+import fs23 from "fs";
+import path28 from "path";
 import { fileURLToPath } from "url";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -2699,191 +2938,8 @@ function unwatchAllSubAgents() {
   }
 }
 
-// packages/core/src/launch.ts
-var ARTIFACTS_DIR_SUFFIX = ".artifacts";
-var SCRATCH_DIR_NAME = "scratch";
-var ARTIFACTS_FALLBACK_DIR = ".vibeflow-artifacts";
-function pathBasename(p) {
-  const norm = p.replace(/\\/g, "/").replace(/\/+$/, "");
-  const i = norm.lastIndexOf("/");
-  return i >= 0 ? norm.slice(i + 1) : norm;
-}
-function agentArtifactsDir(worktreePath, workspacePath) {
-  if (!worktreePath || !workspacePath) return null;
-  const dir = toShellPath(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");
-}
-var AUTO_PERMISSION_MODE = "auto";
-function claudePermissionFlag(autoMode) {
-  return autoMode ? ` --permission-mode ${AUTO_PERMISSION_MODE}` : "";
-}
-function shellQuote(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-function toShellPath(p) {
-  return p.replace(/\\/g, "/");
-}
-function boardEnvPrefix(task, opts) {
-  const board = opts?.boardCli;
-  if (!board) return "";
-  const entries = [
-    ["VIBEFLOW_TASK_ID", task.id],
-    ["VIBEFLOW_PROJECT_PATH", task.projectPath],
-    ["VIBEFLOW_BRANCH", task.branch],
-    ["VIBEFLOW_BASE_BRANCH", task.baseBranch],
-    ["VIBEFLOW_STORE_DIR", board?.storeDir],
-    ["VIBEFLOW_CLI", board?.cliPath],
-    ["VIBEFLOW_CLI_LOADER", board?.loaderPath],
-    ["VIBEFLOW_AUTO_MODE", opts?.autoMode ? "1" : "0"]
-  ];
-  const exports = entries.filter((entry) => Boolean(entry[1])).map(([key, value]) => `${key}=${shellQuote(toShellPath(value))}`);
-  return exports.length ? `export ${exports.join(" ")}; ` : "";
-}
-function codexAutoFlag(autoMode) {
-  return autoMode ? "--dangerously-bypass-approvals-and-sandbox " : "";
-}
-function claudeResumeOrFresh(sessionId, worktreePath, tail) {
-  if (!worktreePath) return `claude --resume ${sessionId} ${tail}\r`;
-  const munged = worktreePath.replace(/[^a-zA-Z0-9]/g, "-");
-  const sessionFile = `"$HOME/.claude/projects/${munged}/${sessionId}.jsonl"`;
-  return `if [ -f ${sessionFile} ]; then claude --resume ${sessionId} ${tail}; else claude --session-id ${sessionId} ${tail}; fi\r`;
-}
-var SUBAGENTS_DIR2 = ".vibeflow-subagents";
-var PROGRESS_EVENTS_DIR = ".vibeflow-events";
-var TODO_TOOLS = "TodoWrite|TaskCreate|TaskUpdate";
-function buildClaudeSettings(worktreePath) {
-  const settings = { theme: "dark" };
-  if (worktreePath) {
-    const dir = `${toShellPath(worktreePath)}/${SUBAGENTS_DIR2}`;
-    const command = `mkdir -p "${dir}" && cat > "${dir}/$(date +%s)-$$-$RANDOM.json"`;
-    const taskHook = {
-      matcher: "Task",
-      hooks: [{ type: "command", command }]
-    };
-    const eventsDir = `${toShellPath(worktreePath)}/${PROGRESS_EVENTS_DIR}`;
-    const progress = {
-      hooks: [{ type: "command", command: `mkdir -p "${eventsDir}" && cat > "${eventsDir}/$(date +%s)-$$-$RANDOM.json"; exit 0` }]
-    };
-    settings.hooks = {
-      PreToolUse: [taskHook],
-      PostToolUse: [taskHook, { matcher: TODO_TOOLS, ...progress }],
-      Stop: [progress],
-      Notification: [progress],
-      UserPromptSubmit: [progress]
-    };
-  }
-  return JSON.stringify(settings);
-}
-function resolveSystemPrompt(custom) {
-  return custom && custom.trim() ? custom : "";
-}
-function buildPrompt(task) {
-  const lines = [`\u4EFB\u52D9\u6A19\u984C\uFF1A${task.title}`];
-  const description = task.description?.trim();
-  if (description) {
-    lines.push("", "\u4EFB\u52D9\u63CF\u8FF0\uFF1A", description);
-  }
-  return lines.join("\n");
-}
-function executorSessionId(taskId, runId) {
-  const source = runId ? `${taskId}:${runId}` : taskId;
-  const raw = source.replace(/[^0-9a-f]/gi, "").toLowerCase();
-  const hex = runId ? `${raw.slice(0, 24).padEnd(24, "0")}${namespaceHash(`executor:${source}`)}` : raw.padEnd(32, "0").slice(0, 32);
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
-}
-function namespaceHash(namespace) {
-  let hash = 2166136261;
-  for (let i = 0; i < namespace.length; i += 1) {
-    hash ^= namespace.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function assembleCommand(agent, systemPrompt, prompt, model, effort, opts, worktreePath, sessionId, workspacePath) {
-  let cmd;
-  if (agent === "claude") {
-    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 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 promptArg = combined ? ` ${shellQuote(combined)}` : "";
-    cmd = `${codexHome}codex ${codexAutoFlag(opts?.autoMode)}${codexEffortFlag}--model ${model}${promptArg}\r`;
-  }
-  if (cmd.length > 2e5) console.warn(`[VibeFlow] launch command is ${cmd.length} bytes \u2014 approaching ARG_MAX`);
-  return cmd;
-}
-var AGENT_NAMES = {
-  claude: "Claude Code",
-  codex: "Codex CLI"
-};
-var DEFAULT_MODELS = {
-  claude: "sonnet",
-  codex: "gpt-5.5"
-};
-var LEGACY_MODEL_FALLBACKS = {
-  codex: {
-    "gpt-5-codex": "gpt-5.5",
-    "gpt-5": "gpt-5.5"
-  }
-};
-function normalizeModel(agent, model) {
-  return LEGACY_MODEL_FALLBACKS[agent]?.[model] ?? model;
-}
-function taskAgent(task) {
-  const agent = task.agentCli;
-  return agent && agent in AGENT_NAMES ? agent : "claude";
-}
-function taskModel(task) {
-  const agent = taskAgent(task);
-  return normalizeModel(agent, task.model || DEFAULT_MODELS[agent]);
-}
-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 includeTaskPrompt = opts?.includeTaskPrompt !== false;
-  const prompt = includeTaskPrompt && !opts?.resume ? buildPrompt(task) : "";
-  const sessionId = agent === "claude" && includeTaskPrompt ? executorSessionId(task.id, task.runId) : void 0;
-  return boardEnvPrefix(task, opts) + assembleCommand(
-    agent,
-    sys,
-    prompt,
-    model,
-    task.effort,
-    opts,
-    task.worktreePath,
-    sessionId,
-    workspacePath
-  );
-}
-
 // packages/core/src/git.ts
+init_launch();
 init_env();
 
 // packages/core/src/github.ts
@@ -3001,16 +3057,17 @@ async function listPrs(run3, repo, filter) {
   return rows.map((r) => toPr(r, repo));
 }
 async function fetchRepoItems(run3, repo) {
-  const [assignedIssues, authoredIssues, assignedPrs, authoredPrs, reviewPrs] = await Promise.all([
+  const [assignedIssues, authoredIssues, assignedPrs, authoredPrs, reviewPrs, reviewedPrs] = await Promise.all([
     listIssues(run3, repo, ["--assignee", "@me"]),
     listIssues(run3, repo, ["--author", "@me"]),
     listPrs(run3, repo, ["--assignee", "@me"]),
     listPrs(run3, repo, ["--author", "@me"]),
-    listPrs(run3, repo, ["--search", "review-requested:@me"])
+    listPrs(run3, repo, ["--search", "review-requested:@me"]),
+    listPrs(run3, repo, ["--search", "reviewed-by:@me"])
   ]);
   return {
     issues: mergeItems([assignedIssues, authoredIssues]),
-    prs: mergeItems([assignedPrs, authoredPrs, reviewPrs])
+    prs: mergeItems([assignedPrs, authoredPrs, reviewPrs, reviewedPrs])
   };
 }
 async function fetchPrIndex(run3, repo) {
@@ -4142,10 +4199,10 @@ function taskAttachmentStagingPath(workspacePath, taskId) {
 
 // packages/core/src/agents.ts
 init_env();
+init_effort();
 import { execFile as execFile6 } from "child_process";
 import { promisify as promisify3 } from "util";
 var pexec3 = promisify3(execFile6);
-var AGENT_EFFORTS = ["low", "medium", "high", "xhigh"];
 var DEFAULT_TASK_EFFORT = "medium";
 var AGENT_CLIS = [
   {
@@ -4153,7 +4210,7 @@ var AGENT_CLIS = [
     bin: "claude",
     name: "Claude Code",
     models: [
-      { id: "sonnet", label: "Sonnet\uFF08\u5E73\u8861\u30FB\u9810\u8A2D\uFF09" },
+      { id: "sonnet", label: "Sonnet\uFF08\u5E73\u8861\uFF09" },
       { id: "haiku", label: "Haiku\uFF08\u8F15\u91CF\uFF09" },
       { id: "opus", label: "Opus\uFF08\u6700\u5F37\uFF09" }
     ]
@@ -4163,7 +4220,7 @@ var AGENT_CLIS = [
     bin: "codex",
     name: "Codex CLI",
     models: [
-      { id: "gpt-5.5", label: "GPT-5.5\uFF08\u9810\u8A2D\uFF09" },
+      { id: "gpt-5.5", label: "GPT-5.5" },
       { id: "gpt-5.4", label: "GPT-5.4" },
       { id: "gpt-5.4-mini", label: "GPT-5.4 Mini" }
     ]
@@ -4535,8 +4592,8 @@ async function taskCommand(argv) {
 }
 
 // packages/cli/src/host.ts
-import fs19 from "fs";
-import path23 from "path";
+import fs20 from "fs";
+import path24 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // packages/core/src/events.ts
@@ -5074,35 +5131,278 @@ async function syncBuiltinsAtStartup() {
 }
 
 // packages/core/src/service.ts
-import fs17 from "fs";
-import os6 from "os";
-import path21 from "path";
+import fs18 from "fs";
+import os8 from "os";
+import path22 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // packages/core/src/agent-models.ts
-import { execFile as execFile7 } from "child_process";
+import fs13 from "fs";
+import os6 from "os";
+import path17 from "path";
+
+// packages/core/src/claude-models.ts
+init_effort();
 import fs12 from "fs";
 import os4 from "os";
 import path16 from "path";
-import { promisify as promisify4 } from "util";
+
+// packages/core/src/json-lines-process.ts
 init_env();
-var pexec4 = promisify4(execFile7);
+import { spawn as spawn4 } from "child_process";
+function spawnJsonLines(bin, args, opts) {
+  const spawnOpts = { cwd: opts.cwd, env: opts.env ?? execEnv(), windowsHide: true };
+  const proc = process.platform === "win32" ? spawn4([bin, ...args].join(" "), { ...spawnOpts, shell: true }) : spawn4(bin, args, spawnOpts);
+  const inbox = [];
+  const waiters = [];
+  let failure = null;
+  let stderr = "";
+  let exited = false;
+  const finished = () => {
+    if (exited) return;
+    exited = true;
+    opts.onExit?.();
+  };
+  const fail2 = (err) => {
+    if (failure) return;
+    failure = err;
+    for (const w of waiters.splice(0)) w.reject(err);
+  };
+  const deliver = (message) => {
+    const i = waiters.findIndex((w) => w.match(message));
+    if (i === -1) inbox.push(message);
+    else waiters.splice(i, 1)[0].resolve(message);
+  };
+  let buffered = "";
+  proc.stdout.setEncoding("utf8");
+  proc.stdout.on("data", (chunk) => {
+    buffered += chunk;
+    let nl;
+    while ((nl = buffered.indexOf("\n")) >= 0) {
+      const line = buffered.slice(0, nl).trim();
+      buffered = buffered.slice(nl + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      deliver(message);
+    }
+  });
+  proc.stderr.setEncoding("utf8");
+  proc.stderr.on("data", (chunk) => {
+    stderr = (stderr + chunk).slice(-2048);
+  });
+  proc.on("error", (err) => {
+    fail2(err);
+    if (proc.pid === void 0) {
+      clearTimeout(timer);
+      finished();
+    }
+  });
+  proc.on("exit", (code2, signal) => {
+    finished();
+    clearTimeout(timer);
+    clearTimeout(graceTimer);
+    const reason = signal ? `was killed (${signal})` : `exited with code ${code2}`;
+    fail2(new Error(`${bin} ${reason}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+  });
+  proc.stdin.on("error", () => {
+  });
+  const kill = () => {
+    if (exited) return;
+    if (process.platform === "win32" && proc.pid !== void 0) {
+      spawn4("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true }).on("error", () => proc.kill());
+      return;
+    }
+    proc.kill();
+  };
+  const timer = setTimeout(() => {
+    fail2(new Error(`${bin} did not answer within ${opts.timeoutMs}ms`));
+    kill();
+  }, opts.timeoutMs);
+  let graceTimer;
+  return {
+    send(message) {
+      if (!failure) proc.stdin.write(`${JSON.stringify(message)}
+`);
+    },
+    next(match) {
+      const i = inbox.findIndex(match);
+      if (i >= 0) return Promise.resolve(inbox.splice(i, 1)[0]);
+      if (failure) return Promise.reject(failure);
+      return new Promise((resolve, reject) => waiters.push({ match, resolve, reject }));
+    },
+    close() {
+      clearTimeout(timer);
+      fail2(new Error(`${bin} conversation closed`));
+      proc.stdin.end();
+      if (!exited && !graceTimer) graceTimer = setTimeout(kill, opts.exitGraceMs ?? 3e3);
+    }
+  };
+}
+
+// packages/core/src/claude-models.ts
+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-"));
+  return spawnJsonLines("claude", CLAUDE_ARGS, {
+    cwd,
+    timeoutMs: CLAUDE_MODELS_TIMEOUT_MS,
+    onExit: () => fs12.rmSync(cwd, { recursive: true, force: true })
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOurResponse(message) {
+  return isRecord(message) && message.type === "control_response" && isRecord(message.response) && message.response.request_id === REQUEST_ID;
+}
+function parseClaudeInitialize(message) {
+  const outer = isRecord(message) && isRecord(message.response) ? message.response : null;
+  if (outer?.subtype === "error") throw new Error(`claude refused the handshake: ${String(outer.error ?? "unknown error")}`);
+  const body = outer && isRecord(outer.response) ? outer.response : null;
+  if (!body || !Array.isArray(body.models)) throw new Error("claude handshake has no models array");
+  const defaultEntry = body.models.find((e) => isRecord(e) && e.value === "default");
+  const defaultResolved = isRecord(defaultEntry) && typeof defaultEntry.resolvedModel === "string" ? defaultEntry.resolvedModel : void 0;
+  let defaultMarked = false;
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  for (const entry of body.models) {
+    if (!isRecord(entry) || typeof entry.value !== "string") continue;
+    const id = entry.value.trim();
+    if (!id || id === "default" || seen.has(id)) continue;
+    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 isDefault = !defaultMarked && defaultResolved !== void 0 && entry.resolvedModel === defaultResolved;
+    if (isDefault) defaultMarked = true;
+    models.push({ id, label, ...description ? { description } : {}, efforts: levels, ...isDefault ? { isDefault } : {} });
+  }
+  if (models.length === 0) throw new Error("claude handshake lists no selectable models");
+  return models;
+}
+async function fetchClaudeModels(open = openClaude) {
+  const channel = open();
+  try {
+    channel.send({ type: "control_request", request_id: REQUEST_ID, request: { subtype: "initialize" } });
+    return parseClaudeInitialize(await channel.next(isOurResponse));
+  } finally {
+    channel.close();
+  }
+}
+
+// packages/core/src/codex-models.ts
+init_effort();
+init_env();
+import os5 from "os";
 var CODEX_MODELS_TIMEOUT_MS = 2e4;
+var MAX_PAGES = 20;
+var CodexLoginRequiredError = class extends Error {
+  constructor() {
+    super("Codex CLI is not signed in; run `codex login`");
+    this.name = "CodexLoginRequiredError";
+  }
+};
+function codexAppServerCommand() {
+  return {
+    bin: "codex",
+    args: ["app-server", "--listen", "stdio://"],
+    cwd: os5.homedir(),
+    env: execEnv()
+  };
+}
+function openCodex() {
+  const { bin, args, cwd, env } = codexAppServerCommand();
+  return spawnJsonLines(bin, args, { cwd, env, timeoutMs: CODEX_MODELS_TIMEOUT_MS });
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var responseTo = (id) => (message) => isRecord2(message) && message.id === id && ("result" in message || "error" in message);
+function resultOf(message, method) {
+  if (!isRecord2(message)) throw new Error(`codex ${method}: malformed response`);
+  if (isRecord2(message.error)) throw new Error(`codex ${method}: ${String(message.error.message ?? "request failed")}`);
+  if (!isRecord2(message.result)) throw new Error(`codex ${method}: response has no result`);
+  return message.result;
+}
+function isCodexSignedIn(result) {
+  return result.account != null || result.requiresOpenaiAuth === false;
+}
+function parseCodexModelPage(result) {
+  if (!Array.isArray(result.data)) throw new Error("codex model/list has no data array");
+  const models = [];
+  for (const entry of result.data) {
+    if (!isRecord2(entry) || typeof entry.id !== "string" || !entry.id.trim() || entry.hidden === true) continue;
+    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;
+    models.push({
+      id,
+      label,
+      ...description ? { description } : {},
+      ...efforts ? { efforts } : {},
+      ...entry.isDefault === true ? { isDefault: true } : {}
+    });
+  }
+  const nextCursor = typeof result.nextCursor === "string" && result.nextCursor ? result.nextCursor : null;
+  return { models, nextCursor };
+}
+async function fetchCodexModels(clientVersion, open = openCodex) {
+  const channel = open();
+  try {
+    channel.send({
+      method: "initialize",
+      id: 1,
+      params: { clientInfo: { name: "vibeflow", title: "VibeFlow", version: clientVersion } }
+    });
+    resultOf(await channel.next(responseTo(1)), "initialize");
+    channel.send({ method: "initialized", params: {} });
+    channel.send({ method: "account/read", id: 2, params: { refreshToken: false } });
+    if (!isCodexSignedIn(resultOf(await channel.next(responseTo(2)), "account/read"))) {
+      throw new CodexLoginRequiredError();
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const models = [];
+    let cursor = null;
+    for (let page = 0; page < MAX_PAGES; page++) {
+      const id = 3 + page;
+      channel.send({
+        method: "model/list",
+        id,
+        params: { limit: 100, includeHidden: false, ...cursor ? { cursor } : {} }
+      });
+      const parsed = parseCodexModelPage(resultOf(await channel.next(responseTo(id)), "model/list"));
+      for (const model of parsed.models) {
+        if (seen.has(model.id)) continue;
+        seen.add(model.id);
+        models.push(model);
+      }
+      cursor = parsed.nextCursor;
+      if (!cursor) break;
+    }
+    if (cursor) throw new Error(`codex model/list did not finish within ${MAX_PAGES} pages`);
+    if (models.length === 0) throw new Error("codex model/list lists no selectable models");
+    return models;
+  } finally {
+    channel.close();
+  }
+}
+
+// packages/core/src/agent-models.ts
+init_effort();
 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 : path16.join(os4.homedir(), ".codex");
-}
-async function defaultRunCodexModels() {
-  const { stdout } = await pexec4("codex", ["debug", "models"], {
-    env: execEnv(),
-    timeout: CODEX_MODELS_TIMEOUT_MS,
-    maxBuffer: 16 * 1024 * 1024,
-    windowsHide: true
-  });
-  return stdout;
+  return configured ? configured : path17.join(os6.homedir(), ".codex");
 }
 function parseCodexCatalog(raw) {
   const body = JSON.parse(raw);
@@ -5127,36 +5427,75 @@ function parseCodexCatalog(raw) {
 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 = path16.join(opts.codexHome ?? defaultCodexHome(), "models_cache.json");
+async function readCodexCache(codexHome) {
+  const cachePath = path17.join(codexHome, "models_cache.json");
   try {
-    const raw = await fs12.promises.readFile(cachePath, "utf8");
+    const raw = await fs13.promises.readFile(cachePath, "utf8");
     return { models: parseCodexCatalog(raw), source: "codex-cache" };
   } catch (err) {
     const missing = err.code === "ENOENT";
     return {
-      models: builtinModels(id),
+      models: builtinModels("codex"),
       source: "builtin",
       ...missing ? {} : { error: errorMessage(err) }
     };
   }
 }
+function createModelCatalog(opts) {
+  const fetchClaude = opts.fetchClaude ?? (() => fetchClaudeModels());
+  const fetchCodex = opts.fetchCodex ?? (() => fetchCodexModels(opts.version));
+  const inFlight = /* @__PURE__ */ new Map();
+  const settled = /* @__PURE__ */ new Map();
+  const fallback = (id) => id === "codex" ? readCodexCache(opts.codexHome ?? defaultCodexHome()) : Promise.resolve({ models: builtinModels(id), source: "builtin" });
+  const ask = async (id) => {
+    try {
+      const models = await (id === "codex" ? fetchCodex() : fetchClaude());
+      return { models, source: id === "codex" ? "codex-app-server" : "claude-cli" };
+    } catch (err) {
+      const list = await fallback(id);
+      return {
+        ...list,
+        error: errorMessage(err),
+        ...err instanceof CodexLoginRequiredError ? { loginRequired: true } : {}
+      };
+    }
+  };
+  const refresh = (id) => {
+    const running = inFlight.get(id);
+    if (running) return running;
+    const pending = ask(id).then((list) => {
+      settled.set(id, list);
+      return list;
+    }).finally(() => inFlight.delete(id));
+    inFlight.set(id, pending);
+    return pending;
+  };
+  return {
+    async get(id) {
+      const answer = settled.get(id);
+      if (answer) return answer;
+      const list = await fallback(id);
+      return inFlight.has(id) ? { ...list, pending: true } : list;
+    },
+    refresh,
+    warm() {
+      for (const agent of AGENT_CLIS) void refresh(agent.id);
+    },
+    findModel(id, modelId) {
+      return modelFor(settled.get(id)?.models, modelId);
+    }
+  };
+}
+
+// packages/core/src/service.ts
+init_effort();
 
 // packages/core/src/github-auth.ts
 init_env();
-import { execFile as execFile8 } from "child_process";
-import { promisify as promisify5 } from "util";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify4 } from "util";
 import * as nodePty3 from "node-pty";
-var pexec5 = promisify5(execFile8);
+var pexec4 = promisify4(execFile7);
 var GITHUB_HOST = "github.com";
 var DEVICE_URL = "https://github.com/login/device";
 var activeLogin = null;
@@ -5191,7 +5530,7 @@ function errorMessage2(err) {
 }
 async function getGitHubCliAuthStatus() {
   try {
-    const { stdout } = await pexec5(
+    const { stdout } = await pexec4(
       "gh",
       ["auth", "status", "--hostname", GITHUB_HOST, "--json", "hosts"],
       {
@@ -5223,7 +5562,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 pexec5(
+  await pexec4(
     "gh",
     ["auth", "logout", "--hostname", GITHUB_HOST, "--user", status.login],
     {
@@ -5306,45 +5645,45 @@ function startGitHubCliLogin(onEvent) {
 }
 
 // packages/core/src/board-cli.ts
-import fs13 from "fs";
-import path17 from "path";
+import fs14 from "fs";
+import path18 from "path";
 import { pathToFileURL } from "url";
 async function boardCliLaunchInfo() {
-  const storeDir = path17.dirname(getStorePath());
+  const storeDir = path18.dirname(getStorePath());
   const entry = getPlatform().cliEntry?.();
-  if (entry && fs13.existsSync(entry)) return { storeDir, cliPath: entry };
+  if (entry && fs14.existsSync(entry)) return { storeDir, cliPath: entry };
   const root = getPlatform().sourceRoot();
   if (!root) return { storeDir };
-  const cliPath = path17.join(root, "scripts", "vibeflow.mjs");
-  const loaderPath = path17.join(root, "test", "support", "register.mjs");
-  if (!fs13.existsSync(cliPath) || !fs13.existsSync(loaderPath)) return { storeDir };
+  const cliPath = path18.join(root, "scripts", "vibeflow.mjs");
+  const loaderPath = path18.join(root, "test", "support", "register.mjs");
+  if (!fs14.existsSync(cliPath) || !fs14.existsSync(loaderPath)) return { storeDir };
   return { storeDir, cliPath, loaderPath: pathToFileURL(loaderPath).href };
 }
 
 // packages/core/src/decisions.ts
-import fs14 from "fs";
-import path18 from "path";
+import fs15 from "fs";
+import path19 from "path";
 var DECISIONS_FILE_SUFFIX = ".DECISIONS.md";
 function decisionsKey(worktreePath, branch) {
-  return worktreePath ? path18.basename(worktreePath) : branch.replace(/\//g, "-");
+  return worktreePath ? path19.basename(worktreePath) : branch.replace(/\//g, "-");
 }
 function decisionsPath(workspacePath, key) {
-  return path18.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
+  return path19.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
 }
 function deleteDecisions(workspacePath, key) {
   try {
-    fs14.rmSync(decisionsPath(workspacePath, key), { force: true });
+    fs15.rmSync(decisionsPath(workspacePath, key), { force: true });
   } catch {
   }
 }
 
 // packages/core/src/specs.ts
-import fs15 from "fs";
-import path19 from "path";
+import fs16 from "fs";
+import path20 from "path";
 var SPEC_FILE_NAME = "spec.md";
 var MAX_SPEC_BYTES = 256 * 1024;
 function isSpecPath(p) {
-  return path19.posix.basename(p) === SPEC_FILE_NAME;
+  return path20.posix.basename(p) === SPEC_FILE_NAME;
 }
 function clip2(buf) {
   return {
@@ -5359,10 +5698,10 @@ async function readWorktreeSpecs(worktreePath, baseBranch) {
   for (const entry of entries) {
     if (entry.status === "D" || !isSpecPath(entry.path)) continue;
     try {
-      const full = path19.join(worktreePath, entry.path);
-      const stat = fs15.statSync(full);
+      const full = path20.join(worktreePath, entry.path);
+      const stat = fs16.statSync(full);
       if (!stat.isFile()) continue;
-      specs.push({ path: entry.path, ...clip2(fs15.readFileSync(full)), updatedAt: stat.mtimeMs });
+      specs.push({ path: entry.path, ...clip2(fs16.readFileSync(full)), updatedAt: stat.mtimeMs });
     } catch {
     }
   }
@@ -5427,7 +5766,7 @@ async function readSpecsAt(cwd, ref, paths) {
 // packages/core/src/chat-session.ts
 init_env();
 init_git_bash();
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // packages/core/src/chat-store.ts
@@ -5583,7 +5922,7 @@ ${attachmentLines.join("\n")}` : text;
     `--append-system-prompt ${quote(systemPrompt)}`,
     quote(fullText)
   ].filter(Boolean).join(" ") : buildRawAgentCommand(agentCli, model, fullText, systemPrompt, worktreePath, quote, workspacePath);
-  const proc = spawn5(shell.command, shell.args(cmd), {
+  const proc = spawn6(shell.command, shell.args(cmd), {
     cwd: worktreePath,
     env: execEnv()
   });
@@ -5709,20 +6048,22 @@ function startChatSend(opts, sender) {
 
 // packages/core/src/service.ts
 init_attachments();
+init_launch();
 
 // packages/core/src/progress-tracker.ts
 init_progress();
-import fs16 from "fs";
-import os5 from "os";
-import path20 from "path";
+init_launch();
+import fs17 from "fs";
+import os7 from "os";
+import path21 from "path";
 var SINCE_SLACK_MS = 5e3;
 function claudeProjectDir(home, cwd) {
-  return path20.join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+  return path21.join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
 }
 function pathAliases(p) {
-  const resolved = path20.resolve(p);
+  const resolved = path21.resolve(p);
   try {
-    const real = fs16.realpathSync(resolved);
+    const real = fs17.realpathSync(resolved);
     return real === resolved ? [resolved] : [resolved, real];
   } catch {
     return [resolved];
@@ -5738,7 +6079,7 @@ function samePath(a, b) {
 }
 function listFiles(dir, test) {
   try {
-    return fs16.readdirSync(dir).filter(test).map((name) => path20.join(dir, name));
+    return fs17.readdirSync(dir).filter(test).map((name) => path21.join(dir, name));
   } catch {
     return [];
   }
@@ -5746,22 +6087,22 @@ function listFiles(dir, test) {
 function firstLine(file) {
   let fd;
   try {
-    fd = fs16.openSync(file, "r");
+    fd = fs17.openSync(file, "r");
     const buf = Buffer.alloc(64 * 1024);
-    const n = fs16.readSync(fd, buf, 0, buf.length, 0);
+    const n = fs17.readSync(fd, buf, 0, buf.length, 0);
     const text = buf.subarray(0, n).toString("utf8");
     const nl = text.indexOf("\n");
     return nl === -1 ? null : text.slice(0, nl);
   } catch {
     return null;
   } finally {
-    if (fd !== void 0) fs16.closeSync(fd);
+    if (fd !== void 0) fs17.closeSync(fd);
   }
 }
 function advance(file, cursor, reduce, initial) {
   let size;
   try {
-    size = fs16.statSync(file).size;
+    size = fs17.statSync(file).size;
   } catch {
     return;
   }
@@ -5773,9 +6114,9 @@ function advance(file, cursor, reduce, initial) {
   if (size === cursor.offset) return;
   let fd;
   try {
-    fd = fs16.openSync(file, "r");
+    fd = fs17.openSync(file, "r");
     const chunk = Buffer.alloc(size - cursor.offset);
-    const n = fs16.readSync(fd, chunk, 0, chunk.length, cursor.offset);
+    const n = fs17.readSync(fd, chunk, 0, chunk.length, cursor.offset);
     cursor.offset += n;
     const data = Buffer.concat([cursor.rest, chunk.subarray(0, n)]);
     const nl = data.lastIndexOf(10);
@@ -5789,7 +6130,7 @@ function advance(file, cursor, reduce, initial) {
     }
   } catch {
   } finally {
-    if (fd !== void 0) fs16.closeSync(fd);
+    if (fd !== void 0) fs17.closeSync(fd);
   }
 }
 function newCursor(state) {
@@ -5808,14 +6149,14 @@ function codexDayDirs(sessionsRoot, since) {
   const cur = new Date(start.getFullYear(), start.getMonth(), start.getDate());
   while (cur <= end) {
     const pad = (n) => String(n).padStart(2, "0");
-    days.push(path20.join(sessionsRoot, String(cur.getFullYear()), pad(cur.getMonth() + 1), pad(cur.getDate())));
+    days.push(path21.join(sessionsRoot, String(cur.getFullYear()), pad(cur.getMonth() + 1), pad(cur.getDate())));
     cur.setDate(cur.getDate() + 1);
   }
   return days;
 }
 function createProgressTracker(opts) {
-  const home = opts.homeDir ?? os5.homedir();
-  const codexHomes = opts.codexHomes ?? (() => [path20.join(home, ".codex")]);
+  const home = opts.homeDir ?? os7.homedir();
+  const codexHomes = opts.codexHomes ?? (() => [path21.join(home, ".codex")]);
   const pollMs = opts.pollMs ?? 2e3;
   const entries = /* @__PURE__ */ new Map();
   const belongsToRun = (target, startedAt) => target.since == null || startedAt != null && startedAt >= target.since - SINCE_SLACK_MS;
@@ -5824,7 +6165,7 @@ function createProgressTracker(opts) {
     const dirs = pathAliases(target.worktreePath).map((p) => claudeProjectDir(home, p));
     for (const file of dirs.flatMap((dir) => listFiles(dir, (n) => n.endsWith(".jsonl")))) {
       if (entry.claude.has(file) || entry.rejected.has(file)) continue;
-      const session = path20.basename(file, ".jsonl");
+      const session = path21.basename(file, ".jsonl");
       if (session !== target.sessionId) {
         const head = firstLine(file);
         if (head == null) continue;
@@ -5837,8 +6178,8 @@ function createProgressTracker(opts) {
       entry.claude.set(file, newCursor(initialClaudeState()));
     }
     for (const file of Array.from(entry.claude.keys())) {
-      if (file.includes(`${path20.sep}subagents${path20.sep}`)) continue;
-      const sub = path20.join(file.slice(0, -".jsonl".length), "subagents");
+      if (file.includes(`${path21.sep}subagents${path21.sep}`)) continue;
+      const sub = path21.join(file.slice(0, -".jsonl".length), "subagents");
       for (const f of listFiles(sub, (n) => n.endsWith(".jsonl"))) {
         if (!entry.claude.has(f)) entry.claude.set(f, newCursor(initialClaudeState()));
       }
@@ -5847,7 +6188,7 @@ function createProgressTracker(opts) {
   function discoverCodex(entry) {
     const { target } = entry;
     for (const codexHome of codexHomes()) {
-      for (const day of codexDayDirs(path20.join(codexHome, "sessions"), target.since)) {
+      for (const day of codexDayDirs(path21.join(codexHome, "sessions"), target.since)) {
         for (const file of listFiles(day, (n) => n.startsWith("rollout-") && n.endsWith(".jsonl"))) {
           if (entry.codex.has(file) || entry.rejected.has(file)) continue;
           const head = firstLine(file);
@@ -5864,11 +6205,11 @@ function createProgressTracker(opts) {
     }
   }
   function drainHooks(entry) {
-    const dir = path20.join(entry.target.worktreePath, PROGRESS_EVENTS_DIR);
+    const dir = path21.join(entry.target.worktreePath, PROGRESS_EVENTS_DIR);
     for (const file of listFiles(dir, (n) => n.endsWith(".json")).sort()) {
       try {
-        const at = fs16.statSync(file).mtimeMs;
-        const event = JSON.parse(fs16.readFileSync(file, "utf8"));
+        const at = fs17.statSync(file).mtimeMs;
+        const event = JSON.parse(fs17.readFileSync(file, "utf8"));
         const foreign = entry.target.sessionId && typeof event.session_id === "string" && event.session_id !== entry.target.sessionId;
         const activity = foreign ? null : activityFromHook(event, at);
         if (activity) entry.hookActivity = latestActivity(entry.hookActivity ?? activity, activity);
@@ -5876,7 +6217,7 @@ function createProgressTracker(opts) {
         continue;
       }
       try {
-        fs16.unlinkSync(file);
+        fs17.unlinkSync(file);
       } catch {
       }
     }
@@ -5888,8 +6229,8 @@ function createProgressTracker(opts) {
     if (target.agent === "claude") {
       for (const [file, cursor] of entry.claude) {
         runUsage = addUsage(runUsage, claudeUsageTotal(cursor.state));
-        if (file.includes(`${path20.sep}subagents${path20.sep}`)) continue;
-        const isExecutor = path20.basename(file, ".jsonl") === target.sessionId;
+        if (file.includes(`${path21.sep}subagents${path21.sep}`)) continue;
+        const isExecutor = path21.basename(file, ".jsonl") === target.sessionId;
         const s = cursor.state;
         if (isExecutor || !target.sessionId && (!primary || (s.startedAt ?? 0) > (primary.startedAt ?? 0))) {
           primary = { todos: s.todos, contextTokens: s.contextTokens, activity: s.activity, startedAt: s.startedAt };
@@ -5968,10 +6309,10 @@ function createProgressTracker(opts) {
       };
       entry.timer.unref?.();
       entries.set(target.taskId, entry);
-      const eventsDir = path20.join(target.worktreePath, PROGRESS_EVENTS_DIR);
+      const eventsDir = path21.join(target.worktreePath, PROGRESS_EVENTS_DIR);
       try {
-        fs16.mkdirSync(eventsDir, { recursive: true });
-        entry.watcher = fs16.watch(eventsDir, () => {
+        fs17.mkdirSync(eventsDir, { recursive: true });
+        entry.watcher = fs17.watch(eventsDir, () => {
           if (entry.pending) return;
           entry.pending = setTimeout(() => {
             entry.pending = null;
@@ -6056,17 +6397,18 @@ function validBoard(value) {
   }
   return next;
 }
-function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatus }) {
+function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatus, modelCatalog }) {
   const sink = bus.sink();
+  const models = modelCatalog ?? createModelCatalog({ version });
   let libraryCodexHome = null;
   void libraryRoot().then((root) => {
     libraryCodexHome = libraryPaths(root).codexHome;
   }).catch(() => {
   });
-  const home = homeDir ?? os6.homedir();
+  const home = homeDir ?? os8.homedir();
   const progress = createProgressTracker({
     homeDir: home,
-    codexHomes: () => [path21.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
+    codexHomes: () => [path22.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
     onUpdate: (taskId, value) => bus.emit("progress:update", { taskId, progress: value }),
     onNotify: (taskId, list) => {
       const prefs = resolveNotificationSettings(getSettings());
@@ -6130,12 +6472,16 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     requireTask(key.split(":")[0]);
     return key;
   }
+  function launchEffort(task) {
+    const model = models.findModel(taskAgent(task), taskModel(task));
+    return model?.efforts ? clampEffort(task.effort, model.efforts) : task.effort;
+  }
   async function launchCommand(task, intent) {
     const settings = getSettings();
     const library = await libraryLaunchInfo(task.worktreePath);
     const boardCli = await boardCliLaunchInfo();
     return buildAgentCommand(
-      task,
+      { ...task, effort: launchEffort(task) },
       settings.systemPrompt ?? "",
       {
         resume: intent.resume === true,
@@ -6149,13 +6495,13 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path21.join(os6.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path22.join(os8.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
   }
   async function removeTaskWorktree(task) {
     if (!task.projectPath || !task.worktreePath) return;
     const branch = task.branch || fallbackBranchName(task.id);
     await removeWorktree(task.projectPath, task.worktreePath);
-    deleteArtifacts(task.workspacePath ?? path21.dirname(task.worktreePath), task.worktreePath);
+    deleteArtifacts(task.workspacePath ?? path22.dirname(task.worktreePath), task.worktreePath);
     await deleteBranch(task.projectPath, branch);
   }
   function columnOf(taskId) {
@@ -6246,7 +6592,8 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "env:detectAgents": () => detectAgents(),
     "agents:listModels": (payload) => {
       const { agentId: rawId, refresh } = obj(payload, "payload");
-      return listAgentModels(agentId(rawId), { refresh: refresh === true });
+      const id = agentId(rawId);
+      return refresh === true ? models.refresh(id) : models.get(id);
     },
     // 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.
@@ -6260,8 +6607,8 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "projects:listRecent": () => listRecentProjects(getStore()),
     // `vibeflow open <path>` while a host runs: only the host writes the store.
     "projects:record": (projectPath) => {
-      const p = path21.resolve(str(projectPath, "projectPath"));
-      if (!fs17.existsSync(p) || !fs17.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
+      const p = path22.resolve(str(projectPath, "projectPath"));
+      if (!fs18.existsSync(p) || !fs18.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
       recordRecentProject(getStore(), p);
       return listRecentProjects(getStore());
     },
@@ -6312,7 +6659,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       if (!task.baseBranch) throw new Error("\u4EFB\u52D9\u6C92\u6709\u8A18\u9304 base branch\uFF0C\u7121\u6CD5\u9084\u539F worktree");
       await teardownTask(task.id);
       await resetWorktreeToBase(task.worktreePath, task.baseBranch);
-      const workspacePath = task.workspacePath ?? path21.dirname(task.worktreePath);
+      const workspacePath = task.workspacePath ?? path22.dirname(task.worktreePath);
       deleteArtifacts(workspacePath, task.worktreePath);
       deleteDecisions(workspacePath, decisionsKey(task.worktreePath, task.branch));
       resetSubAgents(task.worktreePath);
@@ -6336,6 +6683,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       if (columnOf(existing.id) !== "backlog") {
         throw new Error("\u53EA\u6709 Backlog \u7684\u4EFB\u52D9\u53EF\u4EE5\u7DE8\u8F2F");
       }
+      if (p.effort !== void 0 && !AGENT_EFFORTS.includes(p.effort)) invalid("unknown effort");
       let gitPatch = {};
       const nextProject = p.projectPath || existing.projectPath;
       const nextBranch = p.branch === void 0 ? "" : str(p.branch, "branch").trim();
@@ -6355,7 +6703,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
         }
         const info = await getGitInfo(nextProject);
         if (!info.isRepo) throw new Error("\u76EE\u6A19\u8CC7\u6599\u593E\u4E0D\u662F git repository");
-        const projectName = path21.basename(nextProject);
+        const projectName = path22.basename(nextProject);
         const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
         await teardownTask(existing.id);
         await removeTaskWorktree(existing);
@@ -6449,7 +6797,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "claude:sessionExists": (taskId) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return false;
-      return fs17.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
+      return fs18.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
     },
     "sessions:list": async () => {
       const keys = await sessions.list();
@@ -6496,7 +6844,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       const task = requireTask(taskId);
       if (!task.worktreePath || !task.workspacePath) return "task has no worktree";
       const dir = agentArtifactsPath(task.workspacePath, task.worktreePath);
-      if (!fs17.existsSync(dir)) return "artifacts directory does not exist yet";
+      if (!fs18.existsSync(dir)) return "artifacts directory does not exist yet";
       return getPlatform().openPath(dir);
     },
     "task:getSpecs": async (taskId) => {
@@ -6630,7 +6978,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       }
       await removeTaskWorktree(task);
       if (task.workspacePath) {
-        fs17.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
+        fs18.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
       }
       clearConversation(task.id);
       removeTask(task.id);
@@ -6683,9 +7031,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     // Watch the containing directory, not the file: JsonStore renames a temp
     // file over the target and so replaces the inode on every save.
     watchStore() {
-      const file = path21.basename(getStorePath());
+      const file = path22.basename(getStorePath());
       let debounce = null;
-      storeWatcher = fs17.watch(path21.dirname(getStorePath()), (_event, filename) => {
+      storeWatcher = fs18.watch(path22.dirname(getStorePath()), (_event, filename) => {
         if (filename !== file) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -6697,6 +7045,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       });
       return () => storeWatcher?.close();
     },
+    warmModelCatalog() {
+      models.warm();
+    },
     shutdown() {
       sessions.shutdown();
       cancelAllChatSends();
@@ -6718,9 +7069,9 @@ function createSessionBackend(sink, choice) {
 }
 
 // packages/core/src/web-server.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import http from "http";
-import path22 from "path";
+import path23 from "path";
 import { timingSafeEqual } from "crypto";
 import { WebSocketServer } from "ws";
 var TOKEN_COOKIE = "vf_token";
@@ -6773,14 +7124,14 @@ function resolveStatic(root, urlPath) {
     return null;
   }
   if (decoded.includes("\0")) return null;
-  const rel = path22.posix.normalize(decoded).replace(/^\/+/, "");
-  const base2 = path22.resolve(root);
-  const candidates = [rel, path22.posix.join(rel, "index.html"), `${rel}.html`];
+  const rel = path23.posix.normalize(decoded).replace(/^\/+/, "");
+  const base2 = path23.resolve(root);
+  const candidates = [rel, path23.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path22.resolve(base2, c);
-    if (full !== base2 && !full.startsWith(base2 + path22.sep)) return null;
+    const full = path23.resolve(base2, c);
+    if (full !== base2 && !full.startsWith(base2 + path23.sep)) return null;
     try {
-      if (fs18.statSync(full).isFile()) return full;
+      if (fs19.statSync(full).isFile()) return full;
     } catch {
     }
   }
@@ -6841,7 +7192,7 @@ async function startWebServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const ext = path22.extname(file).toLowerCase();
+    const ext = path23.extname(file).toLowerCase();
     const immutable = url.pathname.startsWith("/_next/static/");
     res.writeHead(200, {
       "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream",
@@ -6854,7 +7205,7 @@ async function startWebServer(options) {
       res.end();
       return;
     }
-    fs18.createReadStream(file).pipe(res);
+    fs19.createReadStream(file).pipe(res);
   }
   const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
   function reject(socket, status, reason) {
@@ -7018,6 +7369,7 @@ async function startHost(options) {
     lock.port = server.port;
     updateLock(options.userDataDir, lock);
     const stopWatch = core.watchStore();
+    core.warmModelCatalog();
     const stop = () => stopping ??= (async () => {
       stopWatch();
       core.shutdown();
@@ -7034,7 +7386,7 @@ function loginUrl(lock, pathname = "/home/") {
   return `http://127.0.0.1:${lock.port}${pathname}?token=${encodeURIComponent(lock.token)}`;
 }
 function isWebDir(dir) {
-  return fs19.existsSync(path23.join(dir, "home", "index.html"));
+  return fs20.existsSync(path24.join(dir, "home", "index.html"));
 }
 
 // packages/cli/src/remote.ts
@@ -7151,14 +7503,14 @@ function connectToHost(lock) {
 }
 
 // packages/cli/src/doctor.ts
-import fs20 from "fs";
-import path24 from "path";
-import { execFile as execFile9 } from "child_process";
-import { promisify as promisify6 } from "util";
+import fs21 from "fs";
+import path25 from "path";
+import { execFile as execFile8 } from "child_process";
+import { promisify as promisify5 } from "util";
 init_env();
 init_git_bash();
 init_tmux_backend();
-var pexec6 = promisify6(execFile9);
+var pexec5 = promisify5(execFile8);
 function parseVersion(text) {
   const m = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(text);
   return m ? [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)] : [];
@@ -7172,7 +7524,7 @@ function versionAtLeast(have, want) {
 }
 async function run2(cmd, args) {
   try {
-    const { stdout } = await pexec6(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;
@@ -7292,10 +7644,10 @@ async function runDoctor(options) {
     });
   }
   try {
-    fs20.mkdirSync(options.userDataDir, { recursive: true });
-    const probe = path24.join(options.userDataDir, `.doctor-${process.pid}`);
-    fs20.writeFileSync(probe, "");
-    fs20.rmSync(probe);
+    fs21.mkdirSync(options.userDataDir, { recursive: true });
+    const probe = path25.join(options.userDataDir, `.doctor-${process.pid}`);
+    fs21.writeFileSync(probe, "");
+    fs21.rmSync(probe);
     checks.push({ id: "data", name: "\u8CC7\u6599\u76EE\u9304", level: "ok", detail: options.userDataDir });
   } catch (err) {
     checks.push({
@@ -7349,24 +7701,24 @@ Options:
 `.trim();
 function detectLayout() {
   const file = fileURLToPath(import.meta.url);
-  const here = path27.dirname(file);
-  const bundledWeb = path27.join(here, "web");
-  if (isWebDir(bundledWeb) || path27.basename(here) === "dist") {
+  const here = path28.dirname(file);
+  const bundledWeb = path28.join(here, "web");
+  if (isWebDir(bundledWeb) || path28.basename(here) === "dist") {
     return {
-      version: readVersion(path27.join(here, "..", "package.json")),
+      version: readVersion(path28.join(here, "..", "package.json")),
       webDir: isWebDir(bundledWeb) ? bundledWeb : null,
       sourceRoot: null,
       cliEntry: file
     };
   }
-  const root = path27.resolve(here, "..", "..", "..");
+  const root = path28.resolve(here, "..", "..", "..");
   const override = process.env.VIBEFLOW_WEB_DIR;
-  const webDir = override && isWebDir(override) ? override : isWebDir(path27.join(root, "app")) ? path27.join(root, "app") : null;
-  return { version: readVersion(path27.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
+  const webDir = override && isWebDir(override) ? override : isWebDir(path28.join(root, "app")) ? path28.join(root, "app") : null;
+  return { version: readVersion(path28.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
 }
 function readVersion(pkgPath) {
   try {
-    return JSON.parse(fs22.readFileSync(pkgPath, "utf8")).version;
+    return JSON.parse(fs23.readFileSync(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -7572,8 +7924,8 @@ async function cmdOpen(values, target, layout, userDataDir) {
     console.error("\u7528\u6CD5\uFF1Avibeflow open <path>");
     return 1;
   }
-  const dir = path27.resolve(target);
-  if (!fs22.existsSync(dir) || !fs22.statSync(dir).isDirectory()) {
+  const dir = path28.resolve(target);
+  if (!fs23.existsSync(dir) || !fs23.statSync(dir).isDirectory()) {
     console.error(`\u4E0D\u662F\u8CC7\u6599\u593E\uFF1A${dir}`);
     return 1;
   }