@kw-yeh/vibeflow 4.2.0 → 4.4.0

package/dist/vibeflow.mjs

@@ -280,7 +280,7 @@ var init_session_backend = __esm({
 });
 
 // packages/core/src/tmux-backend.ts
-import { execFile as execFile2, execFileSync as execFileSync2 } from "child_process";
+import { execFile as execFile3, execFileSync as execFileSync2 } from "child_process";
 import fs3 from "fs";
 import path7 from "path";
 import * as nodePty2 from "node-pty";
@@ -289,7 +289,7 @@ function q(value) {
 }
 function defaultRun(env) {
   return (args) => new Promise((resolve) => {
-    execFile2("tmux", args, { env }, (err, stdout) => {
+    execFile3("tmux", args, { env }, (err, stdout) => {
       const code2 = err ? typeof err.code === "number" ? err.code : 1 : 0;
       resolve({ code: code2, stdout: String(stdout ?? "") });
     });
@@ -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);
@@ -607,7 +610,6 @@ 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,7 +714,8 @@ 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) {
@@ -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 () => {
@@ -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 ? path24.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" : ""}`;
       }
@@ -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"}/${path24.basename(s.projectPath)}`;
     }
-    if (field === "branch") return info?.hasRemote ? "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\uFF1B\u82E5 remote \u5DF2\u6709\u9019\u500B\u5206\u652F\uFF0C\u5247\u76F4\u63A5\u53D6\u56DE\u4E26\u63A5\u7E8C\u4E0A\u9762\u7684\u5DE5\u4F5C\u3002" : "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u3002";
+    if (field === "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 === "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);
@@ -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 });
@@ -1486,7 +1503,103 @@ function releaseLock(userDataDir) {
 }
 
 // packages/core/src/platform.ts
+import { execFile as execFile2 } from "child_process";
+
+// packages/core/src/folder-dialog.ts
 import { execFile } from "child_process";
+var MAC_SCRIPT = [
+  "on run argv",
+  "activate",
+  "if (count of argv) > 1 then",
+  "return POSIX path of (choose folder with prompt (item 1 of argv) default location (POSIX file (item 2 of argv)))",
+  "end if",
+  "return POSIX path of (choose folder with prompt (item 1 of argv))",
+  "end run"
+];
+var WINDOWS_SCRIPT = [
+  "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
+  "Add-Type -AssemblyName System.Windows.Forms",
+  "$owner = New-Object System.Windows.Forms.Form -Property @{ TopMost = $true }",
+  "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog",
+  "$dialog.Description = $env:VIBEFLOW_DIALOG_TITLE",
+  "$dialog.ShowNewFolderButton = $true",
+  "if ($env:VIBEFLOW_DIALOG_PATH) { $dialog.SelectedPath = $env:VIBEFLOW_DIALOG_PATH }",
+  "if ($dialog.ShowDialog($owner) -eq [System.Windows.Forms.DialogResult]::OK) { $dialog.SelectedPath }"
+].join("; ");
+function folderDialogCommands(platform, { title = "\u9078\u64C7\u8CC7\u6599\u593E", defaultPath } = {}) {
+  if (platform === "darwin") {
+    return [
+      {
+        cmd: "osascript",
+        args: [...MAC_SCRIPT.flatMap((line) => ["-e", line]), title, ...defaultPath ? [defaultPath] : []],
+        // osascript exits 1 on any script error; only -128 is "User canceled".
+        cancelCodes: [1],
+        cancelStderr: /-128/
+      }
+    ];
+  }
+  if (platform === "win32") {
+    return [
+      {
+        cmd: "powershell.exe",
+        args: ["-NoProfile", "-NonInteractive", "-STA", "-Command", WINDOWS_SCRIPT],
+        env: { VIBEFLOW_DIALOG_TITLE: title, VIBEFLOW_DIALOG_PATH: defaultPath ?? "" },
+        cancelCodes: []
+      }
+    ];
+  }
+  const start = defaultPath ? `${defaultPath.replace(/\/+$/, "")}/` : void 0;
+  return [
+    {
+      cmd: "zenity",
+      args: ["--file-selection", "--directory", `--title=${title}`, ...start ? [`--filename=${start}`] : []],
+      cancelCodes: [1]
+    },
+    {
+      cmd: "kdialog",
+      args: ["--getexistingdirectory", defaultPath ?? ".", "--title", title],
+      cancelCodes: [1]
+    }
+  ];
+}
+function parseFolderDialogOutput(stdout) {
+  const line = stdout.trim();
+  if (!line) return null;
+  if (line === "/" || /^[A-Za-z]:[\\/]$/.test(line)) return line;
+  return line.replace(/[\\/]+$/, "");
+}
+function run(command) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      command.cmd,
+      command.args,
+      { windowsHide: false, encoding: "utf8", env: { ...process.env, ...command.env } },
+      (err, stdout, stderr) => {
+        if (err) {
+          const code2 = err.code;
+          if (code2 === "ENOENT") return resolve("missing");
+          const canceled = typeof code2 === "number" && command.cancelCodes.includes(code2) && (!command.cancelStderr || command.cancelStderr.test(stderr));
+          if (canceled) return resolve({ canceled: true });
+          return reject(new Error(`\u7121\u6CD5\u958B\u555F\u8CC7\u6599\u593E\u9078\u64C7\u8996\u7A97\uFF1A${stderr.trim() || err.message}`));
+        }
+        const picked = parseFolderDialogOutput(stdout);
+        resolve(picked ? { path: picked } : { canceled: true });
+      }
+    );
+  });
+}
+async function pickFolderWithOs(options = {}) {
+  if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+    return { unsupported: true };
+  }
+  for (const command of folderDialogCommands(process.platform, options)) {
+    const result = await run(command);
+    if (result !== "missing") return result;
+  }
+  return { unsupported: true };
+}
+
+// packages/core/src/platform.ts
 import { homedir } from "os";
 import path2 from "path";
 var _platform = null;
@@ -1516,7 +1629,7 @@ function openCommand(target) {
 function openWithOs(target) {
   const [cmd, args] = openCommand(target);
   return new Promise((resolve) => {
-    execFile(cmd, args, { windowsHide: true }, (err) => resolve(err ? err.message : ""));
+    execFile2(cmd, args, { windowsHide: true }, (err) => resolve(err ? err.message : ""));
   });
 }
 function createNodePlatform(options = {}) {
@@ -1536,7 +1649,8 @@ function createNodePlatform(options = {}) {
       const err = await openWithOs(url);
       if (err) throw new Error(err);
     },
-    openPath: (target) => openWithOs(target)
+    openPath: (target) => openWithOs(target),
+    pickFolder: (opts) => pickFolderWithOs(opts)
   };
 }
 
@@ -1840,6 +1954,8 @@ function createBridge(t) {
     getGithubCompareUrl: (taskId) => t.invoke("git:getGithubCompareUrl", taskId),
     /** Open a URL in the system default browser. */
     openExternal: (url) => t.invoke("shell:openExternal", url),
+    /** The OS folder dialog, shown on the machine core runs on. */
+    pickFolder: (options) => t.invoke("dialog:pickFolder", options),
     cleanupTask: (taskId) => t.invoke("vibeflow:cleanupTask", taskId),
     /** Live sub-agent updates pushed from main while a session runs. */
     onSubAgentsUpdate: (callback) => {
@@ -2079,7 +2195,7 @@ async function generateBranchName(title, description) {
 }
 
 // packages/core/src/git.ts
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { promisify } from "util";
 import path12 from "path";
 import fs8 from "fs/promises";
@@ -2400,7 +2516,7 @@ function deleteArtifacts(baseDir, worktreePath) {
 }
 
 // packages/core/src/git.ts
-var pexec = promisify(execFile3);
+var pexec = promisify(execFile4);
 async function git(cwd, args) {
   const { stdout } = await pexec("git", args, {
     cwd,
@@ -3200,12 +3316,15 @@ 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();
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile5 } from "child_process";
 import { promisify as promisify2 } from "util";
-var pexec2 = promisify2(execFile4);
+var pexec2 = promisify2(execFile5);
 var AGENT_EFFORTS = ["low", "medium", "high", "xhigh"];
 var DEFAULT_TASK_EFFORT = "medium";
 var AGENT_CLIS = [
@@ -3278,25 +3397,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 +3420,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 +3431,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 +3442,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 +3660,7 @@ async function taskCommand(argv) {
         title: task2.title,
         description: task2.description,
         branch: task2.branch,
-        worktreePath: task2.worktreePath
+        worktreePath: task2.worktreePath ?? null
       }
     };
   }
@@ -3563,7 +3702,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,
@@ -4119,13 +4258,13 @@ import path20 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // packages/core/src/agent-models.ts
-import { execFile as execFile5 } from "child_process";
+import { execFile as execFile6 } from "child_process";
 import fs12 from "fs";
 import os4 from "os";
 import path16 from "path";
 import { promisify as promisify3 } from "util";
 init_env();
-var pexec3 = promisify3(execFile5);
+var pexec3 = promisify3(execFile6);
 var CODEX_MODELS_TIMEOUT_MS = 2e4;
 function builtinModels(id) {
   return (AGENT_CLIS.find((a) => a.id === id) ?? AGENT_CLIS[0]).models;
@@ -4192,10 +4331,10 @@ async function listAgentModels(id, opts = {}) {
 
 // packages/core/src/github-auth.ts
 init_env();
-import { execFile as execFile6 } from "child_process";
+import { execFile as execFile7 } from "child_process";
 import { promisify as promisify4 } from "util";
 import * as nodePty3 from "node-pty";
-var pexec4 = promisify4(execFile6);
+var pexec4 = promisify4(execFile7);
 var GITHUB_HOST = "github.com";
 var DEVICE_URL = "https://github.com/login/device";
 var activeLogin = null;
@@ -5000,6 +5139,46 @@ function createCore({ sessions, bus, version }) {
     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 run3 = (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, run3);
+    return run3;
+  }
+  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());
+  }
+  let folderDialog = null;
   const handlers = {
     "vibeflow:getState": () => getState(),
     "app:getVersion": () => version,
@@ -5073,7 +5252,13 @@ function createCore({ sessions, bus, version }) {
     // 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);
@@ -5087,21 +5272,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,
@@ -5109,35 +5298,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");
-        await teardownTask(existing.id);
-        await removeTaskWorktree(existing);
         const projectName = path20.basename(nextProject);
         const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
-        await fs16.promises.mkdir(workspacePath, { recursive: true });
-        const result = await provisionWorktree(
-          nextProject,
-          workspacePath,
-          existing.id,
-          p.baseBranch ?? existing.baseBranch ?? null,
-          existing.branch
-        );
+        await teardownTask(existing.id);
+        await removeTaskWorktree(existing);
+        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,
@@ -5153,10 +5337,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) {
@@ -5260,7 +5446,7 @@ function createCore({ sessions, bus, version }) {
       const task = requireTask(taskId);
       const base = task.baseBranch ?? "main";
       if (task.worktreePath) return readWorktreeSpecs(task.worktreePath, base);
-      if (!task.projectPath) return [];
+      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);
     },
@@ -5333,6 +5519,19 @@ function createCore({ sessions, bus, version }) {
       if (!task.worktreePath) return null;
       return getGithubCompareUrl(task.worktreePath, task.baseBranch ?? "main");
     },
+    // One dialog at a time: a second click while it is open joins it instead
+    // of stacking another window on the host.
+    "dialog:pickFolder": (options) => {
+      const o = options === void 0 || options === null ? {} : obj(options, "options");
+      const title = o.title === void 0 ? void 0 : str(o.title, "title");
+      const defaultPath = o.defaultPath === void 0 ? void 0 : str(o.defaultPath, "defaultPath");
+      const pick = getPlatform().pickFolder;
+      if (!pick) return { unsupported: true };
+      folderDialog ??= pick({ title, defaultPath: defaultPath || void 0 }).finally(() => {
+        folderDialog = null;
+      });
+      return folderDialog;
+    },
     "shell:openExternal": (url) => {
       const u = str(url, "url");
       if (!/^https?:\/\//i.test(u)) invalid("only http(s) URLs can be opened");
@@ -5365,6 +5564,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();
@@ -5372,9 +5574,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) => {
@@ -5875,12 +6079,12 @@ function connectToHost(lock) {
 // packages/cli/src/doctor.ts
 import fs19 from "fs";
 import path23 from "path";
-import { execFile as execFile7 } from "child_process";
+import { execFile as execFile8 } from "child_process";
 import { promisify as promisify5 } from "util";
 init_env();
 init_git_bash();
 init_tmux_backend();
-var pexec5 = promisify5(execFile7);
+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)] : [];
@@ -5892,7 +6096,7 @@ function versionAtLeast(have, want) {
   }
   return true;
 }
-async function run(cmd, args) {
+async function run2(cmd, args) {
   try {
     const { stdout } = await pexec5(cmd, args, { env: execEnv(), timeout: 1e4, windowsHide: true });
     return String(stdout).trim();
@@ -5952,7 +6156,7 @@ async function runDoctor(options) {
   checks.push(
     versionAtLeast(nodeVersion, [22, 0]) ? { id: "node", name: "Node.js", level: "ok", detail: `v${process.versions.node}` } : { id: "node", name: "Node.js", level: "fail", detail: `v${process.versions.node}\uFF0C\u9700\u8981 22 \u4EE5\u4E0A`, fix: installHint("node") }
   );
-  const git2 = await run("git", ["--version"]);
+  const git2 = await run2("git", ["--version"]);
   if (!git2) {
     checks.push({ id: "git", name: "Git", level: "fail", detail: "PATH \u4E2D\u627E\u4E0D\u5230 git", fix: installHint("git") });
   } else {
@@ -5980,7 +6184,7 @@ async function runDoctor(options) {
       fix: "\u8981\u8B93\u4EFB\u52D9\u5728\u80CC\u666F\u6301\u7E8C\u57F7\u884C\uFF0C\u8ACB\u5728 WSL \u5167\u4F7F\u7528 vibeflow"
     });
   } else {
-    const tmux = await run("tmux", ["-V"]);
+    const tmux = await run2("tmux", ["-V"]);
     checks.push(
       tmux && hasTmux() ? { id: "tmux", name: "tmux", level: "ok", detail: `${tmux}\uFF08\u4EFB\u52D9\u53EF\u5728\u80CC\u666F\u6301\u7E8C\u57F7\u884C\uFF09` } : {
         id: "tmux",