@kw-yeh/vibeflow 4.1.0 → 4.3.0

package/dist/vibeflow.mjs

@@ -555,14 +555,17 @@ ${entry}
   }
 }
 function writeAttachments(worktreePath, inputs) {
+  if (inputs.length === 0) return [];
+  ensureAttachmentExclude(worktreePath);
+  return writeAttachmentsTo(path10.join(worktreePath, ATTACHMENTS_DIR), inputs);
+}
+function writeAttachmentsTo(attachmentDir, inputs) {
   if (inputs.length === 0) return [];
   const decodedInputs = inputs.map((input) => ({
     input,
     name: safeAttachmentName(input.name),
     bytes: decodeAttachment(input)
   }));
-  ensureAttachmentExclude(worktreePath);
-  const attachmentDir = path10.join(worktreePath, ATTACHMENTS_DIR);
   fs6.mkdirSync(attachmentDir, { recursive: true });
   return decodedInputs.map(({ input, name, bytes }) => {
     const id = randomUUID().slice(0, 8);
@@ -598,16 +601,15 @@ var init_attachments = __esm({
 
 // packages/tui/src/task-form.ts
 import { spawnSync } from "child_process";
-import fs19 from "fs";
+import fs20 from "fs";
 import os6 from "os";
-import path23 from "path";
+import path24 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render, useApp, useInput } from "ink";
 function newFormState(defaultAutoMode, agents) {
   const agentCli = agents && agents.length > 0 && !agents.some((a) => a.id === "claude") ? agents[0].id : "claude";
   return {
     mode: "new",
-    launched: false,
     title: "",
     description: "",
     projectPath: null,
@@ -627,11 +629,11 @@ function editFormState(task, defaultAutoMode) {
   return {
     mode: "edit",
     taskId: task.id,
-    launched: Boolean(task.launchedAt),
     title: task.title,
     description: task.description ?? "",
     projectPath: task.projectPath ?? null,
     originalProjectPath: task.projectPath ?? null,
+    worktreePath: task.worktreePath,
     gitInfo: null,
     gitInfoPath: null,
     baseBranch: task.baseBranch ?? "",
@@ -662,8 +664,8 @@ function visibleFields(s, ctx) {
     return fields2;
   }
   const fields = ["title", "description", "effort", "autoMode", "project"];
-  if (projectChanged(s) && isRepo && hasRemote) fields.push("baseBranch");
-  fields.push("agent", "model", "submit");
+  if (isRepo && hasRemote) fields.push("baseBranch");
+  fields.push("branch", "agent", "model", "submit");
   return fields;
 }
 function modelOptions(ctx, agentCli, current) {
@@ -712,24 +714,25 @@ function updatePayload(s) {
     model: s.model || void 0,
     effort: s.effort,
     autoMode: s.autoMode,
-    ...!s.launched && s.projectPath ? { projectPath: s.projectPath, baseBranch: s.baseBranch || null } : {}
+    ...s.projectPath ? { projectPath: s.projectPath, baseBranch: s.baseBranch || null } : {},
+    branch: s.branch.trim()
   };
 }
 function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs19.mkdtempSync(path23.join(os6.tmpdir(), "vibeflow-"));
-  const file = path23.join(dir, "description.md");
+  const dir = fs20.mkdtempSync(path24.join(os6.tmpdir(), "vibeflow-"));
+  const file = path24.join(dir, "description.md");
   try {
-    fs19.writeFileSync(file, text);
+    fs20.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: fs19.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
+    return { text: fs20.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
   } finally {
-    fs19.rmSync(dir, { recursive: true, force: true });
+    fs20.rmSync(dir, { recursive: true, force: true });
   }
 }
 function cycle(list, current, step) {
@@ -754,16 +757,20 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
   const lookup = useRef(0);
   const fields = visibleFields(s, ctx);
   const field = fields[Math.min(focus, fields.length - 1)];
-  const projectLocked = s.mode === "edit" && s.launched;
   const missing = isProjectMissing(ctx.recent, s.projectPath);
   useEffect(() => {
-    if (!s.projectPath || missing || s.gitInfoPath === s.projectPath || s.mode === "edit" && !projectChanged(s)) return;
+    if (!s.projectPath || missing || s.gitInfoPath === s.projectPath) return;
     const target = s.projectPath;
     const id = ++lookup.current;
     setLoadingGit(true);
     void api.getGitInfo(target).then((info) => {
       if (id !== lookup.current) return;
-      setS((prev) => ({ ...prev, gitInfo: info, gitInfoPath: target, baseBranch: info.defaultBase ?? "" }));
+      setS((prev) => ({
+        ...prev,
+        gitInfo: info,
+        gitInfoPath: target,
+        baseBranch: prev.mode === "edit" && target === prev.originalProjectPath && prev.baseBranch ? prev.baseBranch : info.defaultBase ?? ""
+      }));
     }).catch((err) => id === lookup.current && setMessage(`\u5075\u6E2C Git \u5931\u6557\uFF1A${err.message}`)).finally(() => id === lookup.current && setLoadingGit(false));
   }, [s.projectPath]);
   const leave = (result) => {
@@ -771,7 +778,6 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
     exit();
   };
   const setProject = (projectPath) => {
-    if (projectLocked) return;
     setS((prev) => ({ ...prev, projectPath, gitInfo: null, gitInfoPath: null, baseBranch: "" }));
   };
   const submit = async () => {
@@ -797,10 +803,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(path23.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir())));
+      if (value2) setProject(path24.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path23.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir()));
-      if (!fs19.existsSync(file) || !fs19.statSync(file).isFile()) {
+      const file = path24.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir()));
+      if (!fs20.existsSync(file) || !fs20.statSync(file).isFile()) {
         setMessage(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
         return;
       }
@@ -833,7 +839,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
     if (key.downArrow || key.tab) return setFocus((f) => Math.min(fields.length - 1, f + 1));
     const step = key.leftArrow ? -1 : key.rightArrow ? 1 : 0;
     if (step) {
-      if (field === "project" && !projectLocked) {
+      if (field === "project") {
         const paths = ctx.recent.map((p) => p.path);
         if (paths.length) setProject(cycle(paths, s.projectPath ?? paths[paths.length - 1], step));
       } else if (field === "baseBranch") {
@@ -859,7 +865,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       void api.initRepository(s.projectPath).then((info) => setS((prev) => ({ ...prev, gitInfo: info, gitInfoPath: prev.projectPath, baseBranch: info.defaultBase ?? "" }))).catch((err) => setMessage(err.message)).finally(() => setBusy(null));
       return;
     }
-    if (TEXT_FIELDS.includes(field) && !(field === "project" && projectLocked)) {
+    if (TEXT_FIELDS.includes(field)) {
       setEditing(field);
       setDraft(field === "title" ? s.title : field === "branch" ? s.branch : field === "project" ? s.projectPath ?? "" : "");
     }
@@ -870,7 +876,6 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       case "title":
         return s.title || "\uFF08\u4F8B\u5982\uFF1A\u5BE6\u4F5C\u767B\u5165\u9801\u9762\uFF09";
       case "project": {
-        if (projectLocked) return `${s.projectPath ? path23.basename(s.projectPath) : "\u2014"}\uFF08\u4EFB\u52D9\u5DF2\u958B\u59CB\uFF0C\u9396\u5B9A\uFF09`;
         if (!s.projectPath) return ctx.recent.length ? "\u2190/\u2192 \u9078\u64C7\u4F7F\u7528\u904E\u7684\u5C08\u6848\uFF0C\u6216 Enter \u8F38\u5165\u8DEF\u5F91" : "Enter \u8F38\u5165\u5C08\u6848\u8CC7\u6599\u593E\u7684\u7D55\u5C0D\u8DEF\u5F91";
         return `${s.projectPath}${missing ? "\uFF08\u8DEF\u5F91\u907A\u5931\uFF09" : ""}`;
       }
@@ -881,7 +886,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       case "branch":
         return s.branch || "\uFF08\u7559\u7A7A\u5247\u81EA\u52D5\u547D\u540D\uFF0C\u4F8B\u5982 feature/login-fix\uFF09";
       case "attachments":
-        return s.attachments.length ? s.attachments.map((a) => path23.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
+        return s.attachments.length ? s.attachments.map((a) => path24.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");
@@ -906,15 +911,18 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
   };
   const note = () => {
     const info = s.gitInfo;
-    if (field === "project" && !projectLocked) {
+    if (field === "project") {
       if (loadingGit) return "\u5075\u6E2C Git \u72C0\u614B\u4E2D\u2026";
       if (missing) return `\u627E\u4E0D\u5230 ${s.projectPath}\uFF0C\u5C08\u6848\u53EF\u80FD\u5DF2\u88AB\u79FB\u52D5\u6216\u522A\u9664\u3002`;
       if (info && !info.isRepo) return "\u9019\u500B\u8CC7\u6599\u593E\u4E0D\u662F Git repository\u3002\u8ACB\u6539\u9078\u4E00\u500B Git \u5C08\u6848\uFF0C\u6216\u5728\u4E0B\u65B9\u521D\u59CB\u5316\u3002";
-      if (s.mode === "edit" && projectChanged(s)) return "\u66F4\u63DB\u5C08\u6848\u6703\u5728\u65B0\u5C08\u6848\u91CD\u5EFA worktree\uFF08\u6B64\u4EFB\u52D9\u5C1A\u672A\u958B\u59CB\uFF0C\u7121\u8B8A\u66F4\u6703\u907A\u5931\uFF09\u3002";
+      if (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"}/${path23.basename(s.projectPath)}`;
+      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path24.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 === "branch") return info?.hasRemote ? "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\uFF1B\u82E5 remote \u5DF2\u6709\u9019\u500B\u5206\u652F\uFF0C\u5247\u76F4\u63A5\u53D6\u56DE\u4E26\u63A5\u7E8C\u4E0A\u9762\u7684\u5DE5\u4F5C\u3002" : "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u3002";
     if (field === "effort") return `${EFFORTS.find((x) => x.value === s.effort).description} Claude Code \u8207 Codex \u6703\u5728\u555F\u52D5\u6B64\u4EFB\u52D9\u6642\u5957\u7528\uFF1B\u5BE6\u969B\u53EF\u7528\u7D1A\u8DDD\u4F9D model \u800C\u5B9A\u3002`;
     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);
@@ -1029,7 +1037,7 @@ __export(src_exports, {
   showDiff: () => showDiff
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import path24 from "path";
+import path25 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) {
@@ -1130,6 +1138,9 @@ function BoardView({ opts, initial, initialMessage, onAction }) {
         }
         setSel({ column: sel.column + direction, index: 0 });
         if (move.effect === "launch") {
+          if (!move.task.worktreePath) {
+            setMessage(`\u6B63\u5728\u70BA\u300C${move.task.title}\u300D\u5F9E\u6700\u65B0\u7684 ${move.task.baseBranch ?? "\u57FA\u6E96\u5206\u652F"} \u5EFA\u7ACB\u5206\u652F ${move.task.branch} \u8207 worktree\uFF0C\u9700\u8981\u5E7E\u79D2\u9418\u2026`);
+          }
           await api.term.start({ taskId: move.task.id, launch: {} });
           setMessage(`\u5DF2\u555F\u52D5\u300C${move.task.title}\u300D\u7684 agent\u3002Enter \u53EF\u9032\u5165\u7D42\u7AEF\u3002`);
         } else if (move.effect === "cleanup") {
@@ -1189,8 +1200,14 @@ function BoardView({ opts, initial, initialMessage, onAction }) {
       return;
     }
     if (!selected) return;
-    if (input === "e") return leave({ type: "edit", task: selected });
+    if (input === "e") {
+      if (COLUMNS2[sel.column] !== "backlog") return setMessage("\u57F7\u884C\u4E2D\u8207\u5DF2\u5B8C\u6210\u7684\u5361\u7247\u53EA\u80FD\u67E5\u770B\uFF0C\u7121\u6CD5\u7DE8\u8F2F");
+      return leave({ type: "edit", task: selected });
+    }
     if (key.return) {
+      if (!selected.worktreePath && COLUMNS2[sel.column] === "backlog") {
+        return setMessage("\u9019\u5F35\u5361\u5C1A\u672A\u958B\u59CB\u57F7\u884C\uFF0C\u5206\u652F\u8207 worktree \u6703\u5728\u958B\u59CB\u6642\u5EFA\u7ACB");
+      }
       if (!selected.worktreePath && !selected.projectPath) return setMessage("\u9019\u5F35\u5361\u6C92\u6709\u5DE5\u4F5C\u76EE\u9304");
       if (COLUMNS2[sel.column] === "done") return setMessage("\u5DF2\u5B8C\u6210\u7684\u5361\u7247\u6C92\u6709\u7D42\u7AEF");
       return leave({ type: "attach", task: selected });
@@ -1291,7 +1308,7 @@ function showDiff(task) {
   });
 }
 function tmuxAttach(opts, sessionName) {
-  const conf = path24.join(opts.userDataDir, "tmux.conf");
+  const conf = path25.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 : "" } });
@@ -1421,8 +1438,8 @@ var init_src = __esm({
 });
 
 // packages/cli/src/main.ts
-import fs20 from "fs";
-import path25 from "path";
+import fs21 from "fs";
+import path26 from "path";
 import { fileURLToPath } from "url";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -1814,8 +1831,8 @@ function createBridge(t) {
      * in-app preview will not inline. Resolves to '' on success, else a reason.
      */
     openArtifactsDir: (taskId) => t.invoke("task:openArtifactsDir", taskId),
-    /** The task's decision record; null when it has no workspace folder. */
-    getDecisions: (taskId) => t.invoke("task:getDecisions", taskId),
+    /** Every spec.md the task's branch added or changed; empty when there is none. */
+    getSpecs: (taskId) => t.invoke("task:getSpecs", taskId),
     /** Store dir + CLI paths for launch injection, so an agent can write cards. */
     getBoardCliLaunchInfo: () => t.invoke("board:getCliLaunchInfo"),
     /** VibeFlow's own skill / prompt / script store. */
@@ -3200,6 +3217,9 @@ import { join as join2 } from "path";
 function projectWorkstationPath(workstationRoot, projectName) {
   return join2(workstationRoot, projectName);
 }
+function taskAttachmentStagingPath(workspacePath, taskId) {
+  return join2(workspacePath, ".attachments", taskId);
+}
 
 // packages/core/src/agents.ts
 init_env();
@@ -3278,25 +3298,21 @@ async function createTaskFromInput(input) {
   if (explicitBranch) {
     await assertBranchAvailable(projectPath, workspacePath, explicitBranch);
   }
-  const preferredBranch = explicitBranch ?? await generateBranchName(input.title, input.description);
-  let provisionResult;
-  try {
-    provisionResult = await provisionWorktree(
-      projectPath,
-      workspacePath,
-      taskId,
-      input.baseBranch ?? null,
-      preferredBranch,
-      { explicitBranch: Boolean(explicitBranch) }
-    );
-  } catch (err) {
-    throw Object.assign(
-      new Error(`Worktree \u5EFA\u7ACB\u5931\u6557\uFF1A${err.message}`),
-      { code: "WORKTREE_CREATE_FAILED" }
-    );
-  }
-  const attachments = writeAttachments(
-    provisionResult.worktreePath,
+  const branch = explicitBranch ?? await generateBranchName(input.title, input.description);
+  const draft = {
+    id: taskId,
+    title: input.title.trim() || `Task ${taskId}`,
+    branch: branch ?? fallbackBranchName(taskId),
+    branchExplicit: explicitBranch ? true : void 0,
+    projectPath,
+    projectName,
+    workspacePath,
+    baseBranch: input.baseBranch || info.defaultBase || info.currentBranch || void 0
+  };
+  const col = input.status ?? "backlog";
+  const provisioned = col === "backlog" ? null : await provisionTaskWorktree(draft);
+  const attachments = provisioned?.worktreePath ? writeAttachments(provisioned.worktreePath, input.attachments ?? []) : writeAttachmentsTo(
+    taskAttachmentStagingPath(workspacePath, taskId),
     input.attachments ?? []
   );
   const attachmentLines = attachments.map(
@@ -3305,16 +3321,9 @@ async function createTaskFromInput(input) {
   const baseDescription = input.description?.trim();
   const description = attachmentLines.length ? [baseDescription, attachmentLines.join("\n")].filter(Boolean).join("\n\n") : baseDescription || void 0;
   const task = {
-    id: taskId,
-    title: input.title.trim() || `Task ${taskId}`,
+    ...draft,
+    ...provisioned,
     description,
-    branch: provisionResult.branch,
-    projectPath,
-    projectName,
-    worktreePath: provisionResult.worktreePath,
-    workspacePath,
-    baseBranch: provisionResult.baseBranch,
-    pushed: provisionResult.pushed,
     createdAt: Date.now(),
     agentCli: input.agentCli ?? "claude",
     model: input.model || void 0,
@@ -3323,7 +3332,6 @@ async function createTaskFromInput(input) {
   };
   try {
     const board = store.get("board");
-    const col = input.status ?? "backlog";
     board[col] = [task, ...board[col]];
     store.set("board", board);
     recordRecentProject(store, projectPath);
@@ -3335,6 +3343,38 @@ async function createTaskFromInput(input) {
   }
   return { task, storePath: store.path };
 }
+async function provisionTaskWorktree(task) {
+  if (!task.projectPath || !task.workspacePath) {
+    throw Object.assign(new Error("\u4EFB\u52D9\u6C92\u6709\u5C08\u6848\u8CC7\u6599\u593E\uFF0C\u7121\u6CD5\u5EFA\u7ACB worktree"), {
+      code: "WORKTREE_CREATE_FAILED"
+    });
+  }
+  await fs9.mkdir(task.workspacePath, { recursive: true });
+  if (task.branchExplicit) {
+    await assertBranchAvailable(task.projectPath, task.workspacePath, task.branch);
+  }
+  try {
+    const result = await provisionWorktree(
+      task.projectPath,
+      task.workspacePath,
+      task.id,
+      task.baseBranch ?? null,
+      task.branch,
+      { explicitBranch: task.branchExplicit === true }
+    );
+    return {
+      branch: result.branch,
+      worktreePath: result.worktreePath,
+      baseBranch: result.baseBranch,
+      pushed: result.pushed
+    };
+  } catch (err) {
+    throw Object.assign(
+      new Error(`Worktree \u5EFA\u7ACB\u5931\u6557\uFF1A${err.message}`),
+      { code: "WORKTREE_CREATE_FAILED" }
+    );
+  }
+}
 function updateTaskFromInput(input) {
   const store = input.storePath ? getStoreAtPath(input.storePath) : getStore();
   const board = store.get("board");
@@ -3521,7 +3561,7 @@ async function taskCommand(argv) {
         title: task2.title,
         description: task2.description,
         branch: task2.branch,
-        worktreePath: task2.worktreePath
+        worktreePath: task2.worktreePath ?? null
       }
     };
   }
@@ -3563,7 +3603,7 @@ async function taskCommand(argv) {
       title: task.title,
       projectPath: task.projectPath,
       branch: task.branch,
-      worktreePath: task.worktreePath,
+      worktreePath: task.worktreePath ?? null,
       baseBranch: task.baseBranch,
       agentCli: task.agentCli,
       model: task.model,
@@ -3574,8 +3614,8 @@ async function taskCommand(argv) {
 }
 
 // packages/cli/src/host.ts
-import fs17 from "fs";
-import path21 from "path";
+import fs18 from "fs";
+import path22 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // packages/core/src/events.ts
@@ -4113,9 +4153,9 @@ async function syncBuiltinsAtStartup() {
 }
 
 // packages/core/src/service.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import os5 from "os";
-import path19 from "path";
+import path20 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // packages/core/src/agent-models.ts
@@ -4364,34 +4404,81 @@ async function boardCliLaunchInfo() {
 import fs14 from "fs";
 import path18 from "path";
 var DECISIONS_FILE_SUFFIX = ".DECISIONS.md";
-var MAX_DECISION_BYTES = 256 * 1024;
 function decisionsKey(worktreePath, branch) {
   return worktreePath ? path18.basename(worktreePath) : branch.replace(/\//g, "-");
 }
 function decisionsPath(workspacePath, key) {
   return path18.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
 }
-function readDecisions(workspacePath, key) {
-  const target = decisionsPath(workspacePath, key);
+function deleteDecisions(workspacePath, key) {
   try {
-    const stat = fs14.statSync(target);
-    if (!stat.isFile()) return { path: target, markdown: null };
-    const buf = fs14.readFileSync(target);
-    return {
-      path: target,
-      markdown: buf.subarray(0, MAX_DECISION_BYTES).toString("utf8"),
-      updatedAt: stat.mtimeMs,
-      ...buf.byteLength > MAX_DECISION_BYTES ? { truncated: true } : {}
-    };
+    fs14.rmSync(decisionsPath(workspacePath, key), { force: true });
   } catch {
-    return { path: target, markdown: null };
   }
 }
-function deleteDecisions(workspacePath, key) {
+
+// packages/core/src/specs.ts
+import fs15 from "fs";
+import path19 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;
+}
+function clip2(buf) {
+  return {
+    markdown: buf.subarray(0, MAX_SPEC_BYTES).toString("utf8"),
+    ...buf.byteLength > MAX_SPEC_BYTES ? { truncated: true } : {}
+  };
+}
+async function readWorktreeSpecs(worktreePath, baseBranch) {
+  const baseRef = await resolveBaseRef(worktreePath, baseBranch);
+  const entries = await collectDiffEntries(worktreePath, baseRef);
+  const specs = [];
+  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);
+      if (!stat.isFile()) continue;
+      specs.push({ path: entry.path, ...clip2(fs15.readFileSync(full)), updatedAt: stat.mtimeMs });
+    } catch {
+    }
+  }
+  return specs.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function readBranchSpecs(projectPath, branch, baseBranch, changedPaths) {
+  const ref = `refs/heads/${branch}`;
   try {
-    fs14.rmSync(decisionsPath(workspacePath, key), { force: true });
+    await git(projectPath, ["rev-parse", "--verify", ref]);
   } catch {
+    return [];
+  }
+  let paths = changedPaths;
+  if (!paths) {
+    const baseRef = await resolveBaseRef(projectPath, baseBranch);
+    const names = await git(projectPath, [
+      "diff",
+      "--name-only",
+      "--diff-filter=d",
+      `${baseRef}...${ref}`
+    ]).catch(() => "");
+    paths = names.split("\n").map((l) => l.trim());
+  }
+  const specs = [];
+  for (const p of paths.filter(isSpecPath)) {
+    try {
+      const content = await git(projectPath, ["show", `${ref}:${p}`]);
+      const ct = await git(projectPath, ["log", "-1", "--format=%ct", ref, "--", p]);
+      specs.push({
+        path: p,
+        ...clip2(Buffer.from(content, "utf8")),
+        ...ct ? { updatedAt: Number(ct) * 1e3 } : {}
+      });
+    } catch {
+    }
   }
+  return specs.sort((a, b) => a.path.localeCompare(b.path));
 }
 
 // packages/core/src/chat-session.ts
@@ -4705,22 +4792,6 @@ function buildArtifactPrompt(artifactsDir = ARTIFACTS_FALLBACK_DIR2) {
     "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 DECISIONS_FILE_SUFFIX2 = ".DECISIONS.md";
-function taskDecisionsPath(worktreePath, workspacePath) {
-  if (!worktreePath || !workspacePath) return null;
-  return `${toShellPath(workspacePath)}/${pathBasename(worktreePath)}${DECISIONS_FILE_SUFFIX2}`;
-}
-function buildDecisionPrompt(decisionsPath2) {
-  return [
-    "\u6C7A\u7B56\u66F8\uFF08\u672C\u6B21 session \u5168\u7A0B\u9069\u7528\uFF09\uFF1A",
-    `1. \u672C\u4EFB\u52D9\u7684\u6C7A\u7B56\u66F8\u662F ${decisionsPath2}\uFF1B\u505A\u51FA\u65B0\u6C7A\u7B56\u3001\u6216\u8ABF\u6574\u65E2\u6709\u6C7A\u7B56\u6642\uFF0C\u7576\u4E0B\u5C31\u66F4\u65B0\u5B83\uFF08\u4E0D\u5B58\u5728\u8ACB\u5EFA\u7ACB\uFF09\u3002`,
-    "2. \u53EA\u5BEB\u300C\u9019\u6B21\u65B0\u589E\u4E86\u4EC0\u9EBC\u6C7A\u7B56\u3001\u8ABF\u6574\u4E86\u4EC0\u9EBC\u65E2\u6709\u6C7A\u7B56\u300D\u8207\u7406\u7531\u3002\u9700\u6C42\u8986\u8FF0\u3001\u9032\u5EA6\u56DE\u5831\u3001\u5BE6\u4F5C\u6D41\u6C34\u5E33\u3001\u672C\u4F86\u5C31\u6210\u7ACB\u7684\u6163\u4F8B\u90FD\u4E0D\u8981\u5BEB\u3002",
-    "3. \u6BCF\u5247\u6C7A\u7B56\u4E00\u500B `## <\u4E00\u53E5\u8A71\u8B1B\u5B8C\u7684\u6C7A\u7B56>` \u6BB5\u843D\uFF0C\u5E95\u4E0B 2-4 \u884C\u4EA4\u4EE3\uFF1A\u70BA\u4EC0\u9EBC\u9019\u6A23\u9078\u3001\u5426\u6C7A\u4E86\u4EC0\u9EBC\u66FF\u4EE3\u65B9\u6848\u3001\u8AB0\u4E4B\u5F8C\u6703\u88AB\u9019\u500B\u6C7A\u7B56\u7D81\u4F4F\u3002",
-    "4. \u8981\u8AAA\u660E\u6D41\u7A0B\u3001\u72C0\u614B\u8F49\u63DB\u6216\u6A21\u7D44\u95DC\u4FC2\u6642\uFF0C\u7528 mermaid fence \u756B\u5716\uFF0CVibeFlow \u6703\u76F4\u63A5\u6E32\u67D3\u3002",
-    "5. \u9019\u6B21\u6C92\u6709\u4EFB\u4F55\u6C7A\u7B56\u5C31\u4E0D\u8981\u5EFA\u7ACB\u9019\u500B\u6A94\u6848\uFF1B\u5BE7\u53EF\u7559\u767D\uFF0C\u4E0D\u8981\u6E4A\u5167\u5BB9\u3002",
-    "6. \u7528\u7E41\u9AD4\u4E2D\u6587\u66F8\u5BEB\uFF0C\u7A0B\u5F0F\u8B58\u5225\u5B57\u4FDD\u7559\u82F1\u6587\u3002"
-  ].join("\n");
-}
 var AUTO_PERMISSION_MODE = "auto";
 function claudePermissionFlag(autoMode) {
   return autoMode ? ` --permission-mode ${AUTO_PERMISSION_MODE}` : "";
@@ -4849,11 +4920,9 @@ function buildAgentCommand(task, systemPrompt, opts, workspacePath) {
   const model = taskModel(task);
   const artifactsDir = agentArtifactsDir(task.worktreePath, workspacePath) ?? ARTIFACTS_FALLBACK_DIR2;
   const builtInPrompt = buildArtifactPrompt(artifactsDir);
-  const decisionsPath2 = taskDecisionsPath(task.worktreePath, workspacePath);
-  const decisionPrompt = decisionsPath2 ? buildDecisionPrompt(decisionsPath2) : "";
   const libraryPrompt = opts?.library?.promptText?.trim();
   const customPrompt = resolveSystemPrompt(systemPrompt);
-  const sys = [builtInPrompt, decisionPrompt, libraryPrompt, customPrompt].filter(Boolean).join("\n\n");
+  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;
@@ -4962,15 +5031,54 @@ function createCore({ sessions, bus, version }) {
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path19.join(os5.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path20.join(os5.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
   }
   async function removeTaskWorktree(task) {
     if (!task.projectPath || !task.worktreePath) return;
     const branch = task.branch || fallbackBranchName(task.id);
     await removeWorktree(task.projectPath, task.worktreePath);
-    deleteArtifacts(task.workspacePath ?? path19.dirname(task.worktreePath), task.worktreePath);
+    deleteArtifacts(task.workspacePath ?? path20.dirname(task.worktreePath), task.worktreePath);
     await deleteBranch(task.projectPath, branch);
   }
+  function columnOf(taskId) {
+    const board = getState().board;
+    return COLUMNS.find((col) => board[col].some((t) => t.id === taskId)) ?? null;
+  }
+  const provisioning = /* @__PURE__ */ new Map();
+  function ensureProvisioned(task) {
+    if (task.worktreePath) return Promise.resolve(task);
+    const pending = provisioning.get(task.id);
+    if (pending) return pending;
+    const run2 = (async () => {
+      try {
+        updateTask(task.id, { ...await provisionTaskWorktree(task), launchError: void 0 });
+        bus.emit("state:changed", getState());
+      } catch (err) {
+        returnUnstarted(task.id, err.message);
+        throw err;
+      }
+      const provisioned = findTask(task.id);
+      if (!provisioned) throw new Error("\u627E\u4E0D\u5230\u8981\u57F7\u884C\u7684\u4EFB\u52D9");
+      return provisioned;
+    })().finally(() => provisioning.delete(task.id));
+    provisioning.set(task.id, run2);
+    return run2;
+  }
+  function returnUnstarted(taskId, launchError) {
+    const current = findTask(taskId);
+    if (!current) return;
+    const board = getState().board;
+    const next = {
+      backlog: [
+        { ...current, launchedAt: void 0, launchError },
+        ...board.backlog.filter((t) => t.id !== taskId)
+      ],
+      in_progress: board.in_progress.filter((t) => t.id !== taskId),
+      done: board.done.filter((t) => t.id !== taskId)
+    };
+    setBoard(next);
+    bus.emit("state:changed", getState());
+  }
   const handlers = {
     "vibeflow:getState": () => getState(),
     "app:getVersion": () => version,
@@ -5007,8 +5115,8 @@ function createCore({ sessions, bus, version }) {
     "projects:listRecent": () => listRecentProjects(getStore()),
     // `vibeflow open <path>` while a host runs: only the host writes the store.
     "projects:record": (projectPath) => {
-      const p = path19.resolve(str(projectPath, "projectPath"));
-      if (!fs15.existsSync(p) || !fs15.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
+      const p = path20.resolve(str(projectPath, "projectPath"));
+      if (!fs16.existsSync(p) || !fs16.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
       recordRecentProject(getStore(), p);
       return listRecentProjects(getStore());
     },
@@ -5040,15 +5148,21 @@ function createCore({ sessions, bus, version }) {
     },
     // Discard everything the last run left behind — the PTY session, the
     // sub-agent timeline, the conversation id, the code it changed, its artifacts
-    // and its decision record — so the next launch starts over as if the card
+    // and its legacy decision record — so the next launch starts over as if the card
     // were new. Launching again is the caller's decision.
     "vibeflow:resetTaskRun": async (taskId) => {
       const task = requireTask(taskId);
-      if (!task.worktreePath) throw new Error("\u4EFB\u52D9\u6C92\u6709\u53EF\u7528\u7684 worktree");
+      if (!task.worktreePath) {
+        await teardownTask(task.id);
+        updateTask(task.id, { launchedAt: Date.now(), runId: randomUUID4() });
+        const reset2 = findTask(task.id);
+        if (!reset2) throw new Error("\u627E\u4E0D\u5230\u8981\u91CD\u7F6E\u7684\u4EFB\u52D9");
+        return { state: getState(), task: reset2 };
+      }
       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 ?? path19.dirname(task.worktreePath);
+      const workspacePath = task.workspacePath ?? path20.dirname(task.worktreePath);
       deleteArtifacts(workspacePath, task.worktreePath);
       deleteDecisions(workspacePath, decisionsKey(task.worktreePath, task.branch));
       resetSubAgents(task.worktreePath);
@@ -5058,21 +5172,25 @@ function createCore({ sessions, bus, version }) {
       bus.emit("subagents:update", { taskId: task.id, subAgents: [] });
       return { state: getState(), task: reset };
     },
-    // Edit an existing card's fields. Most are plain metadata read at launch time
-    // (title / description / agent / model / workspace). The project folder
-    // and base branch are git-bound: re-selecting them rebuilds the worktree, which
-    // is only allowed for not-yet-launched tasks (no work to lose).
+    // Edit an existing card's fields. Only a Backlog card is editable: once it
+    // runs, what it was asked to do and where it does it are history. The
+    // git-bound fields (project, base, branch) are just stored — the worktree is
+    // built when the card starts. A Backlog card that already has one (made
+    // before provisioning moved to launch, or returned from a run) gives it up,
+    // but only while it holds no changes.
     "vibeflow:updateTask": async (payload) => {
       const p = obj(payload, "payload");
       const existing = requireTask(p.taskId);
+      if (columnOf(existing.id) !== "backlog") {
+        throw new Error("\u53EA\u6709 Backlog \u7684\u4EFB\u52D9\u53EF\u4EE5\u7DE8\u8F2F");
+      }
       let gitPatch = {};
       const nextProject = p.projectPath || existing.projectPath;
+      const nextBranch = p.branch === void 0 ? "" : str(p.branch, "branch").trim();
       const projectChanged2 = Boolean(p.projectPath && p.projectPath !== existing.projectPath);
       const baseChanged = p.baseBranch != null && p.baseBranch !== (existing.baseBranch ?? null);
-      if (nextProject && (projectChanged2 || baseChanged)) {
-        if (existing.launchedAt) {
-          throw new Error("\u4EFB\u52D9\u5DF2\u958B\u59CB\u57F7\u884C\uFF0C\u7121\u6CD5\u66F4\u63DB\u5C08\u6848\u8CC7\u6599\u593E\u6216\u57FA\u6E96\u5206\u652F");
-        }
+      const branchChanged = Boolean(nextBranch && nextBranch !== existing.branch);
+      if (nextProject && (projectChanged2 || baseChanged || branchChanged)) {
         if (existing.worktreePath) {
           const diff = await getWorktreeDiffEntries(
             existing.worktreePath,
@@ -5080,35 +5198,30 @@ function createCore({ sessions, bus, version }) {
             { fetch: false }
           );
           if (diff.length > 0) {
-            throw new Error("\u76EE\u524D worktree \u5DF2\u6709\u8B8A\u66F4\uFF0C\u7121\u6CD5\u66F4\u63DB\u5C08\u6848\u8CC7\u6599\u593E\u6216\u57FA\u6E96\u5206\u652F");
+            throw new Error("\u76EE\u524D worktree \u5DF2\u6709\u8B8A\u66F4\uFF0C\u7121\u6CD5\u66F4\u63DB\u5C08\u6848\u8CC7\u6599\u593E\u3001\u57FA\u6E96\u5206\u652F\u6216\u5206\u652F\u540D\u7A31");
           }
         }
         const info = await getGitInfo(nextProject);
         if (!info.isRepo) throw new Error("\u76EE\u6A19\u8CC7\u6599\u593E\u4E0D\u662F git repository");
+        const projectName = path20.basename(nextProject);
+        const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
         await teardownTask(existing.id);
         await removeTaskWorktree(existing);
-        const projectName = path19.basename(nextProject);
-        const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
-        await fs15.promises.mkdir(workspacePath, { recursive: true });
-        const result = await provisionWorktree(
-          nextProject,
-          workspacePath,
-          existing.id,
-          p.baseBranch ?? existing.baseBranch ?? null,
-          existing.branch
-        );
+        if (branchChanged) await assertBranchAvailable(nextProject, workspacePath, nextBranch);
         recordRecentProject(getStore(), nextProject);
         gitPatch = {
           projectPath: nextProject,
           projectName,
-          branch: result.branch,
-          worktreePath: result.worktreePath,
           workspacePath,
-          baseBranch: result.baseBranch,
-          pushed: result.pushed
+          baseBranch: (p.baseBranch ?? (projectChanged2 ? null : existing.baseBranch)) || info.defaultBase || info.currentBranch || void 0,
+          ...branchChanged ? { branch: nextBranch, branchExplicit: true } : {},
+          worktreePath: void 0,
+          pushed: void 0,
+          launchedAt: void 0
         };
       }
       updateTask(existing.id, {
+        launchError: void 0,
         title: (p.title ?? "").trim() || `Task ${existing.id}`,
         description: p.description?.trim() || void 0,
         agentCli: p.agentCli,
@@ -5124,10 +5237,12 @@ function createCore({ sessions, bus, version }) {
     // string or a cwd, so a connected client cannot run anything else.
     "pty:start": async (payload) => {
       const p = obj(payload, "payload");
-      const task = requireTask(p.taskId);
-      const key = sessionKeyFor(task.id, p.sessionKey);
-      const cwd = task.worktreePath ?? task.projectPath;
-      if (!cwd) throw new Error("\u4EFB\u52D9\u6C92\u6709\u53EF\u7528\u7684\u5DE5\u4F5C\u76EE\u9304");
+      const requested = requireTask(p.taskId);
+      const key = sessionKeyFor(requested.id, p.sessionKey);
+      const pending = provisioning.get(requested.id);
+      const task = p.launch ? await ensureProvisioned(requested) : pending ? await pending : requested;
+      const cwd = task.worktreePath;
+      if (!cwd) throw new Error("\u4EFB\u52D9\u5C1A\u672A\u958B\u59CB\u57F7\u884C\uFF0C\u9084\u6C92\u6709 worktree");
       let command;
       let fresh = p.fresh === true;
       if (p.launch) {
@@ -5177,7 +5292,7 @@ function createCore({ sessions, bus, version }) {
     "claude:sessionExists": (taskId) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return false;
-      return fs15.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
+      return fs16.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
     },
     "sessions:list": async () => {
       const keys = await sessions.list();
@@ -5224,13 +5339,16 @@ function createCore({ sessions, bus, version }) {
       const task = requireTask(taskId);
       if (!task.worktreePath || !task.workspacePath) return "task has no worktree";
       const dir = agentArtifactsPath(task.workspacePath, task.worktreePath);
-      if (!fs15.existsSync(dir)) return "artifacts directory does not exist yet";
+      if (!fs16.existsSync(dir)) return "artifacts directory does not exist yet";
       return getPlatform().openPath(dir);
     },
-    "task:getDecisions": (taskId) => {
+    "task:getSpecs": async (taskId) => {
       const task = requireTask(taskId);
-      if (!task.workspacePath) return null;
-      return readDecisions(task.workspacePath, decisionsKey(task.worktreePath, task.branch));
+      const base = task.baseBranch ?? "main";
+      if (task.worktreePath) return readWorktreeSpecs(task.worktreePath, base);
+      if (!task.projectPath || !task.launchedAt) return [];
+      const changed = task.outcome?.files.filter((f) => f.status !== "D").map((f) => f.path);
+      return readBranchSpecs(task.projectPath, task.branch, base, changed);
     },
     "board:getCliLaunchInfo": () => boardCliLaunchInfo(),
     "library:list": async () => listLibrary(await libraryRoot(), builtinSkillsDir()),
@@ -5333,6 +5451,9 @@ function createCore({ sessions, bus, version }) {
         deleteDecisions(task.workspacePath, decisionsKey(task.worktreePath, task.branch));
       }
       await removeTaskWorktree(task);
+      if (task.workspacePath) {
+        fs16.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
+      }
       clearConversation(task.id);
       removeTask(task.id);
       return getState();
@@ -5340,9 +5461,11 @@ function createCore({ sessions, bus, version }) {
     "attachments:write": (payload) => {
       const p = obj(payload, "payload");
       const task = requireTask(p.taskId);
-      if (!task.worktreePath) throw new Error("\u627E\u4E0D\u5230\u4EFB\u52D9 worktree");
       if (!Array.isArray(p.attachments)) invalid("attachments must be an array");
-      return writeAttachments(task.worktreePath, p.attachments);
+      const inputs = p.attachments;
+      if (task.worktreePath) return writeAttachments(task.worktreePath, inputs);
+      if (!task.workspacePath) throw new Error("\u627E\u4E0D\u5230\u4EFB\u52D9 worktree");
+      return writeAttachmentsTo(taskAttachmentStagingPath(task.workspacePath, task.id), inputs);
     },
     "chat:load": (taskId) => loadConversation(requireTask(taskId).id),
     "chat:cancel": (taskId) => {
@@ -5382,9 +5505,9 @@ function createCore({ sessions, bus, version }) {
     // Watch the containing directory, not the file: JsonStore renames a temp
     // file over the target and so replaces the inode on every save.
     watchStore() {
-      const file = path19.basename(getStorePath());
+      const file = path20.basename(getStorePath());
       let debounce = null;
-      storeWatcher = fs15.watch(path19.dirname(getStorePath()), (_event, filename) => {
+      storeWatcher = fs16.watch(path20.dirname(getStorePath()), (_event, filename) => {
         if (filename !== file) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -5416,9 +5539,9 @@ function createSessionBackend(sink, choice) {
 }
 
 // packages/core/src/web-server.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import http from "http";
-import path20 from "path";
+import path21 from "path";
 import { timingSafeEqual } from "crypto";
 import { WebSocketServer } from "ws";
 var TOKEN_COOKIE = "vf_token";
@@ -5471,14 +5594,14 @@ function resolveStatic(root, urlPath) {
     return null;
   }
   if (decoded.includes("\0")) return null;
-  const rel = path20.posix.normalize(decoded).replace(/^\/+/, "");
-  const base = path20.resolve(root);
-  const candidates = [rel, path20.posix.join(rel, "index.html"), `${rel}.html`];
+  const rel = path21.posix.normalize(decoded).replace(/^\/+/, "");
+  const base = path21.resolve(root);
+  const candidates = [rel, path21.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path20.resolve(base, c);
-    if (full !== base && !full.startsWith(base + path20.sep)) return null;
+    const full = path21.resolve(base, c);
+    if (full !== base && !full.startsWith(base + path21.sep)) return null;
     try {
-      if (fs16.statSync(full).isFile()) return full;
+      if (fs17.statSync(full).isFile()) return full;
     } catch {
     }
   }
@@ -5539,7 +5662,7 @@ async function startWebServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const ext = path20.extname(file).toLowerCase();
+    const ext = path21.extname(file).toLowerCase();
     const immutable = url.pathname.startsWith("/_next/static/");
     res.writeHead(200, {
       "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream",
@@ -5552,7 +5675,7 @@ async function startWebServer(options) {
       res.end();
       return;
     }
-    fs16.createReadStream(file).pipe(res);
+    fs17.createReadStream(file).pipe(res);
   }
   const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
   function reject(socket, status, reason) {
@@ -5724,7 +5847,7 @@ function loginUrl(lock, pathname = "/home/") {
   return `http://127.0.0.1:${lock.port}${pathname}?token=${encodeURIComponent(lock.token)}`;
 }
 function isWebDir(dir) {
-  return fs17.existsSync(path21.join(dir, "home", "index.html"));
+  return fs18.existsSync(path22.join(dir, "home", "index.html"));
 }
 
 // packages/cli/src/remote.ts
@@ -5841,8 +5964,8 @@ function connectToHost(lock) {
 }
 
 // packages/cli/src/doctor.ts
-import fs18 from "fs";
-import path22 from "path";
+import fs19 from "fs";
+import path23 from "path";
 import { execFile as execFile7 } from "child_process";
 import { promisify as promisify5 } from "util";
 init_env();
@@ -5982,10 +6105,10 @@ async function runDoctor(options) {
     });
   }
   try {
-    fs18.mkdirSync(options.userDataDir, { recursive: true });
-    const probe = path22.join(options.userDataDir, `.doctor-${process.pid}`);
-    fs18.writeFileSync(probe, "");
-    fs18.rmSync(probe);
+    fs19.mkdirSync(options.userDataDir, { recursive: true });
+    const probe = path23.join(options.userDataDir, `.doctor-${process.pid}`);
+    fs19.writeFileSync(probe, "");
+    fs19.rmSync(probe);
     checks.push({ id: "data", name: "\u8CC7\u6599\u76EE\u9304", level: "ok", detail: options.userDataDir });
   } catch (err) {
     checks.push({
@@ -6039,24 +6162,24 @@ Options:
 `.trim();
 function detectLayout() {
   const file = fileURLToPath(import.meta.url);
-  const here = path25.dirname(file);
-  const bundledWeb = path25.join(here, "web");
-  if (isWebDir(bundledWeb) || path25.basename(here) === "dist") {
+  const here = path26.dirname(file);
+  const bundledWeb = path26.join(here, "web");
+  if (isWebDir(bundledWeb) || path26.basename(here) === "dist") {
     return {
-      version: readVersion(path25.join(here, "..", "package.json")),
+      version: readVersion(path26.join(here, "..", "package.json")),
       webDir: isWebDir(bundledWeb) ? bundledWeb : null,
       sourceRoot: null,
       cliEntry: file
     };
   }
-  const root = path25.resolve(here, "..", "..", "..");
+  const root = path26.resolve(here, "..", "..", "..");
   const override = process.env.VIBEFLOW_WEB_DIR;
-  const webDir = override && isWebDir(override) ? override : isWebDir(path25.join(root, "app")) ? path25.join(root, "app") : null;
-  return { version: readVersion(path25.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
+  const webDir = override && isWebDir(override) ? override : isWebDir(path26.join(root, "app")) ? path26.join(root, "app") : null;
+  return { version: readVersion(path26.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
 }
 function readVersion(pkgPath) {
   try {
-    return JSON.parse(fs20.readFileSync(pkgPath, "utf8")).version;
+    return JSON.parse(fs21.readFileSync(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -6262,8 +6385,8 @@ async function cmdOpen(values, target, layout, userDataDir) {
     console.error("\u7528\u6CD5\uFF1Avibeflow open <path>");
     return 1;
   }
-  const dir = path25.resolve(target);
-  if (!fs20.existsSync(dir) || !fs20.statSync(dir).isDirectory()) {
+  const dir = path26.resolve(target);
+  if (!fs21.existsSync(dir) || !fs21.statSync(dir).isDirectory()) {
     console.error(`\u4E0D\u662F\u8CC7\u6599\u593E\uFF1A${dir}`);
     return 1;
   }