@kw-yeh/vibeflow 4.11.30 → 4.11.33

package/dist/vibeflow.mjs

@@ -594,6 +594,38 @@ function buildClaudeSettings(worktreePath) {
 function resolveSystemPrompt(custom) {
   return custom && custom.trim() ? custom : "";
 }
+function masterSystemPrompt(opts) {
+  const lines = [
+    "\u4F60\u662F VibeFlow \u7684 Master agent\uFF0C\u4E0D\u5C6C\u65BC\u4EFB\u4F55 repo\uFF0C\u5DE5\u4F5C\u76EE\u9304\u53EA\u662F\u4F60\u7684\u7B46\u8A18\u5340\u3002",
+    "\u4F60\u7684\u5DE5\u4F5C\u662F\u628A\u4F7F\u7528\u8005\u7684\u4EFB\u52D9\u62C6\u89E3\u3001\u6D3E\u7D66 slave \u5361\u7247\u57F7\u884C\u3001\u8FFD\u8E64\u5230\u5B8C\u6210\uFF0C\u800C\u4E0D\u662F\u81EA\u5DF1\u6539\u7A0B\u5F0F\u78BC\u3002",
+    ""
+  ];
+  if (!opts.canWrite) {
+    lines.push(
+      "\u9019\u6B21\u555F\u52D5\u7121\u6CD5\u4F7F\u7528 board CLI\uFF08\u627E\u4E0D\u5230 VIBEFLOW_CLI\uFF09\uFF0C\u4F60\u4E0D\u80FD\u5EFA\u7ACB\u6216\u555F\u52D5\u5361\u7247\u3002",
+      "\u8ACB\u628A\u62C6\u89E3\u7D50\u679C\u6574\u7406\u6210\u5361\u7247\u6E05\u55AE\uFF08\u6A19\u984C\u3001\u5C08\u6848\u8DEF\u5F91\u3001prompt\u3001\u5148\u5F8C\u9806\u5E8F\uFF09\u4EA4\u7D66\u4F7F\u7528\u8005\u624B\u52D5\u5EFA\u7ACB\u3002"
+    );
+    return lines.join("\n");
+  }
+  lines.push(
+    '\u5148\u5B9A\u7FA9\u9019\u500B shell \u51FD\u5F0F\uFF0C\u4E4B\u5F8C\u6240\u6709\u6307\u4EE4\u90FD\u7528\u5B83\uFF0C\u4E26\u4E14\u4E00\u5F8B\u5E36\u4E0A --store-path "$VIBEFLOW_STORE_DIR"\uFF1A',
+    '  VF() { if [ -n "$VIBEFLOW_CLI_LOADER" ]; then node --experimental-strip-types --import "$VIBEFLOW_CLI_LOADER" "$VIBEFLOW_CLI" "$@"; else node "$VIBEFLOW_CLI" "$@"; fi; }',
+    "",
+    "1. \u5224\u65B7\uFF1A\u4E00\u5F35\u5361\u505A\u5F97\u5B8C\u5C31\u53EA\u5EFA\u4E00\u5F35\uFF1B\u6D89\u53CA\u591A\u500B repo \u6216\u53EF\u5E73\u884C\u7684\u7368\u7ACB\u5DE5\u4F5C\u624D\u62C6\u6210\u591A\u5F35\u3002\u6BCF\u5F35\u53EA\u52D5\u4E00\u500B repo\uFF0C\u5404\u81EA\u80FD\u7368\u7ACB\u9A57\u6536\u3002",
+    '2. \u6D3E\u5DE5\uFF1AVF task create --store-path "$VIBEFLOW_STORE_DIR" --master "$VIBEFLOW_TASK_ID" --project <repo \u7D55\u5C0D\u8DEF\u5F91> --title <\u6A19\u984C> --prompt <\u5167\u5BB9>',
+    "   prompt \u5FC5\u9808\u81EA\u5305\u542B\uFF1A\u80CC\u666F\u3001\u7BC4\u570D\u3001\u9A57\u6536\u689D\u4EF6\u3001\u8207\u5176\u4ED6\u5361\u7684\u4ECB\u9762\u7D04\u5B9A\u2014\u2014slave \u770B\u4E0D\u5230\u4F60\u7684\u5C0D\u8A71\u3002",
+    "   \u9700\u8981\u6642\u53EF\u52A0 --agent / --model / --effort / --base-branch\u3002"
+  );
+  lines.push(
+    opts.autoMode ? '3. \u555F\u52D5\uFF1A\u6C92\u6709\u524D\u7F6E\u4F9D\u8CF4\u7684\u5361\u76F4\u63A5 VF task start --store-path "$VIBEFLOW_STORE_DIR" --task <id>\uFF1B\u6709\u4F9D\u8CF4\u7684\u5148\u7559\u5728 Backlog\uFF0C\u524D\u7F6E\u5361\u5B8C\u6210\u5F8C\u518D\u555F\u52D5\u3002' : "3. \u555F\u52D5\uFF1A\u4E0D\u8981\u81EA\u5DF1\u555F\u52D5\u5361\u7247\u3002\u5217\u51FA\u4F60\u5EFA\u4E86\u54EA\u4E9B\u5361\u3001\u5EFA\u8B70\u7684\u555F\u52D5\u9806\u5E8F\uFF0C\u7B49\u4F7F\u7528\u8005\u5728 VibeFlow \u6309\u958B\u59CB\u3002"
+  );
+  lines.push(
+    '4. \u76E3\u807D\uFF1AVF task list --store-path "$VIBEFLOW_STORE_DIR" --master "$VIBEFLOW_TASK_ID" \u6703\u56DE\u50B3\u6BCF\u5F35\u5361\u7684\u6B04\u4F4D\u3001\u662F\u5426\u5728\u8DD1\u3001todo \u9032\u5EA6\u3001\u6D3B\u52D5\u72C0\u614B\u8207 PR\u3002',
+    "   \u5B9A\u671F\u67E5\u770B\uFF1B\u5361\u5728\u7B49\u5F85\u6B0A\u9650\u3001\u6709 launchError\u3001\u6216\u9577\u6642\u9593\u6C92\u6709\u6D3B\u52D5\u6642\uFF0C\u544A\u8A34\u4F7F\u7528\u8005\u4E26\u63D0\u51FA\u8655\u7406\u65B9\u5F0F\u3002",
+    "5. \u4F60\u4E0D\u6703\u628A\u5361\u7247\u79FB\u5230 Done\u3001\u4E0D\u6703\u5408\u4F75 PR\u3002\u5168\u90E8 slave \u5B8C\u6210\u5F8C\uFF0C\u6574\u7406\u6BCF\u5F35\u7684\u7D50\u679C\u8207 PR \u9023\u7D50\uFF0C\u4EA4\u7D66\u4F7F\u7528\u8005\u505A\u6700\u5F8C\u78BA\u8A8D\u3002"
+  );
+  return lines.join("\n");
+}
 function buildPrompt(task) {
   const lines = [`\u4EFB\u52D9\u6A19\u984C\uFF1A${task.title}`];
   const description = task.description?.trim();
@@ -654,7 +686,8 @@ function taskModel(task) {
 function buildAgentCommand(task, systemPrompt, opts, workspacePath) {
   const agent = taskAgent(task);
   const model = taskModel(task);
-  const sys = resolveSystemPrompt(systemPrompt);
+  const custom = resolveSystemPrompt(systemPrompt);
+  const sys = task.role === "master" ? [custom, masterSystemPrompt({ canWrite: Boolean(opts?.boardCli?.cliPath), autoMode: opts?.autoMode === true })].filter(Boolean).join("\n\n") : custom;
   const includeTaskPrompt = opts?.includeTaskPrompt !== false;
   const prompt = includeTaskPrompt && !opts?.resume ? buildPrompt(task) : "";
   const sessionId = agent === "claude" && includeTaskPrompt ? executorSessionId(task.id, task.runId) : void 0;
@@ -1116,6 +1149,7 @@ function newFormState(defaultAutoMode, agents) {
   const agentCli = agents && agents.length > 0 && !agents.some((a) => a.id === "claude") ? agents[0].id : "claude";
   return {
     mode: "new",
+    role: "slave",
     title: "",
     description: "",
     projectPath: null,
@@ -1135,6 +1169,7 @@ function editFormState(task, defaultAutoMode) {
   return {
     mode: "edit",
     taskId: task.id,
+    role: task.role === "master" ? "master" : "slave",
     title: task.title,
     description: task.description ?? "",
     projectPath: task.projectPath ?? null,
@@ -1161,8 +1196,11 @@ function visibleFields(s, ctx) {
   const missing = isProjectMissing(ctx.recent, s.projectPath);
   const isRepo = s.gitInfo?.isRepo ?? false;
   const hasRemote = s.gitInfo?.hasRemote ?? false;
+  if (s.role === "master") {
+    return s.mode === "new" ? ["role", "title", "attachments", "description", "effort", "autoMode", "agent", "model", "submit"] : ["title", "description", "effort", "autoMode", "agent", "model", "submit"];
+  }
   if (s.mode === "new") {
-    const fields2 = ["title", "project"];
+    const fields2 = ["role", "title", "project"];
     if (s.gitInfo && !missing && !isRepo) fields2.push("gitInit");
     if (isRepo && hasRemote) fields2.push("baseBranch");
     if (isRepo) fields2.push("branch");
@@ -1189,6 +1227,7 @@ function fitEffort(ctx, s) {
 }
 function blockReason(s, ctx, loadingGit) {
   if (!s.title.trim()) return "\u8ACB\u8F38\u5165\u4EFB\u52D9\u6A19\u984C";
+  if (s.role === "master") return null;
   if (loadingGit) return "\u5075\u6E2C Git \u72C0\u614B\u4E2D\u2026";
   const missing = isProjectMissing(ctx.recent, s.projectPath);
   if (s.mode === "new") {
@@ -1205,12 +1244,15 @@ function blockReason(s, ctx, loadingGit) {
 }
 function createPayload(s) {
   const hasRemote = s.gitInfo?.hasRemote ?? false;
+  const target = s.role === "master" ? { role: "master" } : {
+    projectPath: s.projectPath,
+    baseBranch: hasRemote ? s.baseBranch || null : null,
+    branch: s.branch.trim() || void 0
+  };
   return {
     title: s.title.trim(),
     description: s.description.trim(),
-    projectPath: s.projectPath,
-    baseBranch: hasRemote ? s.baseBranch || null : null,
-    branch: s.branch.trim() || void 0,
+    ...target,
     agentCli: s.agentCli,
     model: s.model || void 0,
     effort: s.effort,
@@ -1227,8 +1269,10 @@ function updatePayload(s) {
     model: s.model || void 0,
     effort: s.effort,
     autoMode: s.autoMode,
-    ...s.projectPath ? { projectPath: s.projectPath, baseBranch: s.baseBranch || null } : {},
-    branch: s.branch.trim()
+    ...s.role === "master" ? {} : {
+      ...s.projectPath ? { projectPath: s.projectPath, baseBranch: s.baseBranch || null } : {},
+      branch: s.branch.trim()
+    }
   };
 }
 function editorCommand(env, platform) {
@@ -1254,7 +1298,7 @@ function cycle(list, current, step) {
   return list[((i < 0 ? 0 : i + step) % list.length + list.length) % list.length];
 }
 function sameForm(a, b) {
-  const pick = (s) => [s.title, s.description, s.projectPath, s.baseBranch, s.branch, s.attachments.join("\n"), s.effort, s.autoMode, s.agentCli, s.model];
+  const pick = (s) => [s.role, s.title, s.description, s.projectPath, s.baseBranch, s.branch, s.attachments.join("\n"), s.effort, s.autoMode, s.agentCli, s.model];
   return JSON.stringify(pick(a)) === JSON.stringify(pick(b));
 }
 function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, onResult }) {
@@ -1352,7 +1396,9 @@ 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") {
+      if (field === "role") {
+        setS((prev) => ({ ...prev, role: prev.role === "master" ? "slave" : "master" }));
+      } else 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") {
@@ -1389,6 +1435,8 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
   const value = (f) => {
     if (editing === f) return `${draft}\u258F`;
     switch (f) {
+      case "role":
+        return s.role === "master" ? "\u2039 Master\uFF1A\u4E0D\u7D81 repo\uFF0C\u62C6\u89E3\u4E26\u6D3E\u5DE5\u7D66\u5176\u4ED6\u5361\u7247 \u203A" : "\u2039 Slave\uFF1A\u5728\u4E00\u500B Git \u5C08\u6848\u88E1\u57F7\u884C \u203A";
       case "title":
         return s.title || "\uFF08\u4F8B\u5982\uFF1A\u5BE6\u4F5C\u767B\u5165\u9801\u9762\uFF09";
       case "project": {
@@ -1534,6 +1582,7 @@ var init_task_form = __esm({
     ];
     DEFAULT_EFFORT = "auto";
     LABELS = {
+      role: "\u89D2\u8272",
       title: "\u4EFB\u52D9\u6A19\u984C",
       project: "\u5C08\u6848\u8CC7\u6599\u593E",
       gitInit: "\u521D\u59CB\u5316 Git",
@@ -1811,13 +1860,16 @@ function BoardView({ opts, initial, initialMessage, onAction }) {
       ...tasks.length === 0 ? [h2(Text2, { key: "empty", dimColor: true }, "\u2014")] : tasks.map((t, ti) => {
         const isSel = active && ti === sel.index;
         const mark = running.has(t.id) ? "\u25CF " : "  ";
+        const role = t.role === "master" ? "\u25C6 " : t.masterId ? "\u21B3 " : "";
+        const masterTitle = t.masterId ? COLUMNS2.flatMap((c) => board[c]).find((m) => m.id === t.masterId)?.title : void 0;
+        const detail = t.role === "master" ? `Master \xB7 ${COLUMNS2.flatMap((c) => board[c]).filter((x) => x.masterId === t.id).length} \u500B slave` : `${t.projectName ?? ""} \xB7 ${t.branch}${masterTitle ? ` \xB7 \u25C6 ${masterTitle}` : ""}`;
         const summary = col === "backlog" ? "" : progressSummary(col === "in_progress" ? progress[t.id] : null, t.usage);
         return h2(
           Box2,
           { key: t.id, flexDirection: "column" },
-          h2(Text2, { inverse: isSel, color: running.has(t.id) ? "green" : void 0 }, truncate2(`${mark}${t.title}`, colWidth - 4)),
+          h2(Text2, { inverse: isSel, color: running.has(t.id) ? "green" : t.role === "master" ? "magenta" : void 0 }, truncate2(`${mark}${role}${t.title}`, colWidth - 4)),
           summary ? h2(Text2, { dimColor: !isSel, color: isSel ? "cyan" : void 0 }, truncate2(`  ${summary}`, colWidth - 4)) : null,
-          isSel ? h2(Text2, { dimColor: true }, truncate2(`  ${t.projectName ?? ""} \xB7 ${t.branch}`, colWidth - 4)) : null
+          isSel ? h2(Text2, { dimColor: true }, truncate2(`  ${detail}`, colWidth - 4)) : null
         );
       })
     );
@@ -2331,6 +2383,9 @@ function recordRecentProject(store, projectPath) {
 }
 
 // packages/core/src/store.ts
+function isMasterTask(task) {
+  return task.role === "master";
+}
 var DEFAULT_NOTIFICATION_SETTINGS = {
   enabled: true,
   stepCompleted: false,
@@ -2454,7 +2509,7 @@ function updateTask(taskId, patch) {
 function removeTask(taskId) {
   const board = getStore().get("board");
   Object.keys(board).forEach((col) => {
-    board[col] = board[col].filter((t) => t.id !== taskId);
+    board[col] = board[col].filter((t) => t.id !== taskId).map((t) => t.masterId === taskId ? { ...t, masterId: void 0 } : t);
   });
   getStore().set("board", board);
 }
@@ -2520,6 +2575,10 @@ function createBridge(t) {
     listAgentModels: (agentId2, refresh = false) => t.invoke("agents:listModels", { agentId: agentId2, refresh }),
     createTask: (payload) => t.invoke("vibeflow:createTask", payload),
     updateTask: (payload) => t.invoke("vibeflow:updateTask", payload),
+    /** Move a Backlog card to In Progress and start its agent on the host. */
+    startTask: (taskId) => t.invoke("vibeflow:startTask", taskId),
+    /** Cards as a master sees them; filter by master or a single card. */
+    taskSummaries: (filter) => t.invoke("task:summaries", filter),
     /** Clear prior execution state and prepare a fresh run of this task. */
     resetTaskRun: (taskId) => t.invoke("vibeflow:resetTaskRun", taskId),
     removeTask: (taskId) => t.invoke("vibeflow:removeTask", taskId),
@@ -2602,6 +2661,7 @@ function createBridge(t) {
     // Interactive terminal bridge (Phase 3).
     term: {
       readFile: (sessionKey, path33) => t.invoke("terminal:readFile", { sessionKey, path: path33 }),
+      existingFiles: (sessionKey, paths) => t.invoke("terminal:existingFiles", { sessionKey, paths }),
       openFile: (sessionKey, path33) => t.invoke("terminal:openFile", { sessionKey, path: path33 }),
       /**
        * Start a terminal for a task: its agent when `launch` is given, else an
@@ -3181,6 +3241,7 @@ function linkFromRef(ref, state) {
   return { kind: ref.kind, number: ref.number, url: ref.url, state };
 }
 function hasRealBranch(task) {
+  if (task.role === "master") return false;
   return Boolean(task.provisionedAt || task.worktreePath || task.outcome);
 }
 function resolveTaskLinks(tasks, repoOfProject, prIndex) {
@@ -4352,8 +4413,28 @@ async function detectAgents() {
 
 // packages/core/src/tasks.ts
 init_attachments();
+function mastersRoot(storeFile) {
+  return path13.join(path13.dirname(storeFile), "masters");
+}
+function taskError(message, code2) {
+  return Object.assign(new Error(message), { code: code2 });
+}
+function assertMasterRef(board, masterId, taskId) {
+  const master = Object.values(board).flat().find((t) => t.id === masterId);
+  if (!master) throw taskError(`\u627E\u4E0D\u5230 master \u5361\u7247\uFF1A${masterId}`, "MASTER_NOT_FOUND");
+  if (!isMasterTask(master)) throw taskError(`\u5361\u7247 ${masterId} \u4E0D\u662F master`, "NOT_A_MASTER");
+  if (taskId && masterId === taskId) throw taskError("\u5361\u7247\u4E0D\u80FD\u6307\u5B9A\u81EA\u5DF1\u70BA master", "NOT_A_MASTER");
+}
+async function assertDirectory(dir) {
+  const stat = await fs10.stat(dir).catch(() => null);
+  if (!path13.isAbsolute(dir) || !stat?.isDirectory()) {
+    throw taskError(`\u627E\u4E0D\u5230\u8CC7\u6599\u593E\uFF1A${dir}`, "WORK_DIR_NOT_FOUND");
+  }
+}
 async function createTaskFromInput(input) {
-  const { projectPath } = input;
+  if (input.role === "master") return createMasterTask(input);
+  const projectPath = input.projectPath;
+  if (!projectPath) throw taskError("\u5C1A\u672A\u9078\u64C7\u5C08\u6848\u8CC7\u6599\u593E", "PROJECT_NOT_FOUND");
   try {
     await fs10.access(projectPath);
   } catch {
@@ -4369,6 +4450,7 @@ async function createTaskFromInput(input) {
   const taskId = randomUUID2().slice(0, 8);
   const explicitBranch = input.branch?.trim() || null;
   const store = input.storePath ? getStoreAtPath(input.storePath) : getStore();
+  if (input.masterId) assertMasterRef(store.get("board"), input.masterId);
   const projectName = path13.basename(projectPath);
   const workspacePath = projectWorkstationPath(
     resolveWorkstationPath(store.get("settings")),
@@ -4409,6 +4491,7 @@ async function createTaskFromInput(input) {
     model: input.model || void 0,
     effort: input.effort ?? DEFAULT_TASK_EFFORT,
     autoMode: input.autoMode,
+    ...input.masterId ? { masterId: input.masterId } : {},
     ...input.github ? { github: input.github } : {},
     ...input.jira ? { jira: input.jira } : {}
   };
@@ -4425,7 +4508,54 @@ async function createTaskFromInput(input) {
   }
   return { task, storePath: store.path };
 }
+async function createMasterTask(input) {
+  if (input.masterId) throw taskError("master \u5361\u7247\u4E0D\u80FD\u518D\u96B8\u5C6C\u5176\u4ED6 master", "NOT_A_MASTER");
+  const workDir = input.workDir?.trim() || void 0;
+  if (workDir) await assertDirectory(workDir);
+  const store = input.storePath ? getStoreAtPath(input.storePath) : getStore();
+  const taskId = randomUUID2().slice(0, 8);
+  const workspacePath = path13.join(mastersRoot(store.path), taskId);
+  const draft = {
+    id: taskId,
+    title: input.title.trim() || `Master ${taskId}`,
+    branch: "",
+    role: "master",
+    workspacePath,
+    ...workDir ? { workDir } : {}
+  };
+  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((attachment) => `[\u9644\u4EF6: ${attachment.path}]`);
+  const baseDescription = input.description?.trim();
+  const description = attachmentLines.length ? [baseDescription, attachmentLines.join("\n")].filter(Boolean).join("\n\n") : baseDescription || void 0;
+  const task = {
+    ...draft,
+    ...provisioned,
+    description,
+    createdAt: Date.now(),
+    agentCli: input.agentCli ?? "claude",
+    model: input.model || void 0,
+    effort: input.effort ?? DEFAULT_TASK_EFFORT,
+    autoMode: input.autoMode
+  };
+  try {
+    const board = store.get("board");
+    board[col] = [task, ...board[col]];
+    store.set("board", board);
+  } catch (err) {
+    throw taskError(`Store \u5BEB\u5165\u5931\u6557\uFF1A${err.message}`, "STORE_WRITE_FAILED");
+  }
+  return { task, storePath: store.path };
+}
 async function provisionTaskWorktree(task) {
+  if (isMasterTask(task)) {
+    if (!task.workspacePath) throw taskError("master \u5361\u7247\u6C92\u6709\u5DE5\u4F5C\u8CC7\u6599\u593E", "WORKTREE_CREATE_FAILED");
+    const worktreePath = task.workDir ?? path13.join(task.workspacePath, "work");
+    await fs10.mkdir(worktreePath, { recursive: true });
+    await fs10.mkdir(task.workspacePath, { recursive: true });
+    return { branch: "", worktreePath, provisionedAt: Date.now() };
+  }
   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"
@@ -4469,12 +4599,17 @@ function updateTaskFromInput(input) {
     });
   }
   const current = board[from].find((t) => t.id === input.taskId);
+  if (input.masterId) {
+    if (isMasterTask(current)) throw taskError("master \u5361\u7247\u4E0D\u80FD\u518D\u96B8\u5C6C\u5176\u4ED6 master", "NOT_A_MASTER");
+    assertMasterRef(board, input.masterId, current.id);
+  }
   const title = input.title?.trim();
   const description = input.description?.trim();
   const task = {
     ...current,
     ...title ? { title } : {},
-    ...input.description !== void 0 ? { description: description || void 0 } : {}
+    ...input.description !== void 0 ? { description: description || void 0 } : {},
+    ...input.masterId !== void 0 ? { masterId: input.masterId || void 0 } : {}
   };
   const to = input.status ?? from;
   if (to === from) {
@@ -4496,9 +4631,125 @@ function updateTaskFromInput(input) {
 
 // packages/cli/src/task-command.ts
 init_attachments();
+
+// packages/cli/src/remote.ts
+import WebSocket from "ws";
+
+// packages/core/src/ws-transport.ts
+var OPEN = 1;
+var MAX_BACKOFF_MS = 5e3;
+function createWsTransport(options) {
+  let socket = null;
+  let nextId = 1;
+  let connectedOnce = false;
+  let closed = false;
+  let backoff = 250;
+  const queue = [];
+  const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  function flush() {
+    while (socket && socket.readyState === OPEN && queue.length > 0) socket.send(queue.shift());
+  }
+  function open() {
+    if (closed) return;
+    const ws = options.connect();
+    socket = ws;
+    ws.onopen = () => {
+      backoff = 250;
+      options.onStatus?.(true);
+      flush();
+      if (connectedOnce) options.onReconnect?.();
+      connectedOnce = true;
+    };
+    ws.onmessage = (ev) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(ev.data));
+      } catch {
+        return;
+      }
+      if (typeof msg.event === "string") {
+        dispatch(msg.event, msg.payload);
+        return;
+      }
+      const entry = typeof msg.id === "number" ? pending.get(msg.id) : void 0;
+      if (!entry) return;
+      pending.delete(msg.id);
+      if (msg.error) entry.reject(Object.assign(new Error(msg.error.message), { code: msg.error.code }));
+      else entry.resolve(msg.result === null ? void 0 : msg.result);
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = () => {
+      if (socket !== ws) return;
+      socket = null;
+      options.onStatus?.(false);
+      for (const [id, entry] of Array.from(pending)) {
+        pending.delete(id);
+        entry.reject(new Error("\u8207 VibeFlow core \u7684\u9023\u7DDA\u4E2D\u65B7"));
+      }
+      if (closed) return;
+      setTimeout(open, backoff);
+      backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+    };
+  }
+  function dispatch(channel, payload) {
+    for (const cb of Array.from(listeners.get(channel) ?? [])) cb(payload);
+  }
+  function post(message) {
+    const data = JSON.stringify(message);
+    if (socket && socket.readyState === OPEN) socket.send(data);
+    else queue.push(data);
+  }
+  open();
+  return {
+    kind: "ws",
+    invoke(method, ...params) {
+      const id = nextId++;
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        post({ id, method, params });
+      });
+    },
+    send(method, ...params) {
+      post({ method, params });
+    },
+    on(channel, callback) {
+      let set = listeners.get(channel);
+      if (!set) listeners.set(channel, set = /* @__PURE__ */ new Set());
+      set.add(callback);
+      return () => {
+        set.delete(callback);
+      };
+    },
+    close() {
+      closed = true;
+      socket?.close();
+    },
+    dispatch
+  };
+}
+
+// packages/cli/src/remote.ts
+function connectToHost(lock) {
+  const url = `ws://127.0.0.1:${lock.port}/ws`;
+  const transport = createWsTransport({
+    connect: () => new WebSocket(url, {
+      headers: { Authorization: `Bearer ${lock.token}`, Host: `127.0.0.1:${lock.port}` }
+    })
+  });
+  return {
+    api: createBridge(transport),
+    invoke: (method, ...params) => transport.invoke(method, ...params),
+    close: () => transport.close()
+  };
+}
+
+// packages/cli/src/task-command.ts
 var AGENT_IDS = AGENT_CLIS.map((agent) => agent.id);
 var STATUSES = ["backlog", "in_progress", "done"];
-var SUBCOMMANDS = ["create", "update", "artifact"];
+var SUBCOMMANDS = ["create", "update", "start", "list", "show", "artifact"];
+var ROLES = ["slave", "master"];
 var MODES = ["existing", "new"];
 var AUTO_MODES = ["on", "off"];
 var TASK_USAGE = `
@@ -4507,10 +4758,18 @@ VibeFlow task commands
 Usage:
   vibeflow task create [options]
   vibeflow task update [options]
+  vibeflow task start --task <id> [options]
+  vibeflow task list [--master <id>] [options]
+  vibeflow task show --task <id> [options]
   vibeflow task artifact add --file <path> [options]
 
 task create options:
-  --project <path>       Target project directory (required)
+  --role <role>          ${ROLES.join(" | ")}  (default: slave). A master has no project:
+                         it runs in its own folder and dispatches other cards.
+  --project <path>       Target project directory (required for a slave)
+  --work-dir <path>      Master only: run in this existing folder (git or not)
+                         instead of one VibeFlow creates
+  --master <id>          Dispatch the new card under this master card
   --title <text>         Task title (required)
   --prompt <text>        Task prompt / description (required)
   --status <column>      ${STATUSES.join(" | ")}  (default: backlog)
@@ -4534,11 +4793,19 @@ task update options:
   --title <text>         New card title
   --prompt <text>        New card description (empty string clears it)
   --status <column>      ${STATUSES.join(" | ")}  \u2014 moves the card between columns
+  --master <id|none>     Put the card under a master, or "none" to take it out
   --store-path <dir>     Explicit store directory
   --profile <name>       dev | prod \u2014 shorthand for common store paths
 
-  At least one of --title / --prompt / --status is required. Branch, worktree
-  and project path are provisioned on disk and cannot be changed here.
+  At least one of --title / --prompt / --status / --master is required. Branch,
+  worktree and project path are provisioned on disk and cannot be changed here.
+
+task start / list / show (need the running VibeFlow host):
+  start --task <id>      Move a Backlog card to In Progress and start its agent,
+                         the same as dragging it in the app
+  list [--master <id>]   Every card, or one master's cards, with column, whether
+                         its agent is running, todo progress, activity and PR
+  show --task <id>       The same summary for one card
 
 task artifact add options:
   --file <path>         Copy a file into the card's user-facing Artifacts folder
@@ -4548,7 +4815,7 @@ task artifact add options:
 
 Notes:
   A card created with --status in_progress does NOT start running by itself.
-  Every launch is started by hand from the app.
+  Use "task start" on a Backlog card, or start it from the app.
 
 Examples:
   vibeflow task create \\
@@ -4601,6 +4868,9 @@ async function taskCommand(argv) {
       args: argv,
       options: {
         project: { type: "string" },
+        role: { type: "string" },
+        "work-dir": { type: "string" },
+        master: { type: "string" },
         title: { type: "string" },
         prompt: { type: "string" },
         task: { type: "string" },
@@ -4628,7 +4898,7 @@ async function taskCommand(argv) {
   const [sub, action] = positionals;
   if (values.help || !sub) return null;
   const storePath = resolveStorePath(
-    values["store-path"] ?? (sub === "artifact" ? process.env.VIBEFLOW_STORE_DIR : void 0),
+    values["store-path"] ?? (sub === "artifact" || HOST_COMMANDS.includes(sub) ? process.env.VIBEFLOW_STORE_DIR : void 0),
     values.profile
   );
   setPlatform(createNodePlatform({ userDataDir: storePath }));
@@ -4643,17 +4913,19 @@ async function taskCommand(argv) {
     if (!task2) fail("TASK_NOT_FOUND", `Task not found: ${taskId}`);
     return { taskId, path: addTaskArtifact(task2, values.file) };
   }
+  if (HOST_COMMANDS.includes(sub)) return hostCommand(sub, values, storePath);
   if (sub === "update") {
     if (!values.task) fail("MISSING_ARGUMENT", "Missing required arguments: --task");
     requireOneOf("--status", values.status, STATUSES);
-    if (values.title === void 0 && values.prompt === void 0 && values.status === void 0) {
-      fail("MISSING_ARGUMENT", "task update needs at least one of: --title, --prompt, --status");
+    if (values.title === void 0 && values.prompt === void 0 && values.status === void 0 && values.master === void 0) {
+      fail("MISSING_ARGUMENT", "task update needs at least one of: --title, --prompt, --status, --master");
     }
     const { task: task2, storePath: resolvedPath2 } = updateTaskFromInput({
       taskId: values.task,
       title: values.title,
       description: values.prompt,
       status: values.status,
+      masterId: values.master === void 0 ? void 0 : values.master === "none" ? null : values.master,
       storePath
     });
     return {
@@ -4663,12 +4935,19 @@ async function taskCommand(argv) {
         title: task2.title,
         description: task2.description,
         branch: task2.branch,
-        worktreePath: task2.worktreePath ?? null
+        worktreePath: task2.worktreePath ?? null,
+        masterId: task2.masterId ?? null
       }
     };
   }
+  requireOneOf("--role", values.role, ROLES);
+  const master = values.role === "master";
+  if (!master && values["work-dir"] !== void 0) fail("INVALID_ARGUMENT", "--work-dir is only for --role master");
+  if (master && (values.project || values["base-branch"] || values.branch || values.mode)) {
+    fail("INVALID_ARGUMENT", "A master card has no project: drop --project / --base-branch / --branch / --mode");
+  }
   const missing = [];
-  if (!values.project) missing.push("--project");
+  if (!master && !values.project) missing.push("--project");
   if (!values.title) missing.push("--title");
   if (!values.prompt) missing.push("--prompt");
   if (missing.length) fail("MISSING_ARGUMENT", `Missing required arguments: ${missing.join(", ")}`);
@@ -4685,6 +4964,9 @@ async function taskCommand(argv) {
   }
   const { task, storePath: resolvedPath } = await createTaskFromInput({
     projectPath: values.project,
+    role: master ? "master" : void 0,
+    workDir: values["work-dir"],
+    masterId: values.master,
     title: values.title,
     description: values.prompt,
     status: values.status ?? "backlog",
@@ -4703,7 +4985,9 @@ async function taskCommand(argv) {
     task: {
       id: task.id,
       title: task.title,
-      projectPath: task.projectPath,
+      role: task.role ?? "slave",
+      masterId: task.masterId ?? null,
+      projectPath: task.projectPath ?? null,
       branch: task.branch,
       worktreePath: task.worktreePath ?? null,
       baseBranch: task.baseBranch,
@@ -4714,6 +4998,28 @@ async function taskCommand(argv) {
     }
   };
 }
+var HOST_COMMANDS = ["start", "list", "show"];
+async function hostCommand(sub, values, storePath) {
+  if (sub !== "list" && !values.task) fail("MISSING_ARGUMENT", "Missing required arguments: --task");
+  const lock = liveHost(storePath);
+  if (!lock) fail("HOST_NOT_RUNNING", `No VibeFlow host is running for ${storePath}. Start it with \`vibeflow\` first.`);
+  const remote = connectToHost(lock);
+  try {
+    if (sub === "start") {
+      const { task } = await remote.api.startTask(values.task);
+      return { task: { id: task.id, title: task.title, worktreePath: task.worktreePath ?? null } };
+    }
+    if (sub === "show") {
+      const [task] = await remote.api.taskSummaries({ taskId: values.task });
+      return { task };
+    }
+    return { tasks: await remote.api.taskSummaries(values.master ? { masterId: values.master } : void 0) };
+  } catch (err) {
+    fail("HOST_ERROR", err.message);
+  } finally {
+    remote.close();
+  }
+}
 
 // packages/cli/src/host.ts
 import fs25 from "fs";
@@ -5158,6 +5464,17 @@ function resolveTerminalFile(cwd, input) {
   if (target.includes("\0")) throw new Error("\u6A94\u6848\u8DEF\u5F91\u7121\u6548\u3002");
   return path16.resolve(cwd, target);
 }
+var MAX_FILE_CANDIDATES = 128;
+async function existingTerminalFiles(cwd, inputs) {
+  const found2 = await Promise.all(inputs.slice(0, MAX_FILE_CANDIDATES).map(async (input) => {
+    try {
+      return (await fs13.stat(resolveTerminalFile(cwd, input))).isFile();
+    } catch {
+      return false;
+    }
+  }));
+  return inputs.filter((_, i) => found2[i]);
+}
 async function readTerminalFile(cwd, input, metadataOnly = false) {
   let target;
   try {
@@ -6966,6 +7283,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       bus.emit("progress:notify", { taskId, title: task.title, notifications });
     }
   });
+  function gitWorktree(task) {
+    return isMasterTask(task) ? void 0 : task.worktreePath;
+  }
   function progressTarget(task) {
     if (!task.worktreePath) return null;
     const agent = taskAgent(task);
@@ -7143,6 +7463,87 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     authStatus: jiraAuthStatus ?? (() => getJiraAuthStatus(acliRunner)),
     pointFields: () => getSettings().jira?.storyPointsFields?.length ? getSettings().jira.storyPointsFields : DEFAULT_POINT_FIELDS
   });
+  async function startTaskSession(requested, key, p) {
+    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) {
+      const intent = obj(p.launch, "launch");
+      if (intent.resume && await sessions.isAlive(key)) {
+        fresh = false;
+      } else {
+        command = (await launchCommand(task, intent)).replace(/\r$/, "");
+      }
+    }
+    if (p.launch) ensureTaskArtifactDirs(task);
+    const result = await sessions.start(key, {
+      cwd,
+      command,
+      fresh,
+      cols: typeof p.cols === "number" ? p.cols : void 0,
+      rows: typeof p.rows === "number" ? p.rows : void 0,
+      // Session ended (natural exit included), so stop its watcher.
+      onExit: () => unwatchSubAgents(key)
+    });
+    terminalDirectories.set(key, cwd);
+    watchSubAgents(key, cwd, (subAgents) => {
+      bus.emit("subagents:update", { taskId: task.id, subAgents });
+    });
+    if (p.launch) {
+      const current = findTask(task.id);
+      if (current) trackProgress(current);
+    }
+    return result;
+  }
+  async function summarizeTasks(filter) {
+    const board = getState().board;
+    const alive = new Set(await sessions.list());
+    const summaries = [];
+    for (const column of COLUMNS) {
+      for (const task of board[column]) {
+        if (filter.taskId && task.id !== filter.taskId) continue;
+        if (filter.masterId && task.masterId !== filter.masterId) continue;
+        if (column === "in_progress" && !progress.isTracking(task.id)) trackProgress(task);
+        const snapshot = progress.isTracking(task.id) ? progress.snapshot(task.id) : null;
+        const todos = snapshot?.todos;
+        const current = todos?.find((t) => t.status === "in_progress");
+        const pr = task.outcome?.pr;
+        summaries.push({
+          id: task.id,
+          title: task.title,
+          column,
+          ...task.role ? { role: task.role } : {},
+          ...task.masterId ? { masterId: task.masterId } : {},
+          ...task.projectName ? { projectName: task.projectName } : {},
+          ...task.branch ? { branch: task.branch } : {},
+          running: alive.has(task.id),
+          ...task.launchedAt ? { launchedAt: task.launchedAt } : {},
+          ...task.launchError ? { launchError: task.launchError } : {},
+          ...todos ? {
+            todos: {
+              done: todos.filter((t) => t.status === "completed").length,
+              total: todos.length,
+              ...current ? { current: current.activeForm ?? current.content } : {}
+            }
+          } : {},
+          ...snapshot ? { activity: snapshot.activity } : {},
+          ...pr ? { pr: { number: pr.number, url: pr.url, state: pr.state } } : {},
+          ...task.outcome ? {
+            outcome: {
+              commits: task.outcome.commits.length,
+              files: task.outcome.files.length,
+              additions: task.outcome.additions,
+              deletions: task.outcome.deletions
+            }
+          } : {}
+        });
+      }
+    }
+    return summaries;
+  }
   const handlers = {
     "vibeflow:getState": () => getState(),
     // A card's progress right now (todo list, usage, activity), for a frontend
@@ -7242,8 +7643,13 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     },
     "vibeflow:createTask": async (payload) => {
       const p = obj(payload, "payload");
-      if (!p.projectPath) throw new Error("\u5C1A\u672A\u9078\u64C7\u5C08\u6848\u8CC7\u6599\u593E");
-      str(p.projectPath, "projectPath");
+      if (p.role !== void 0 && p.role !== "master") invalid("unknown role");
+      if (p.role !== "master") {
+        if (!p.projectPath) throw new Error("\u5C1A\u672A\u9078\u64C7\u5C08\u6848\u8CC7\u6599\u593E");
+        str(p.projectPath, "projectPath");
+      }
+      if (p.workDir !== void 0) str(p.workDir, "workDir");
+      if (p.masterId !== void 0) str(p.masterId, "masterId");
       str(p.title ?? "", "title");
       if (p.effort !== void 0 && !AGENT_EFFORTS.includes(p.effort)) invalid("unknown effort");
       if (p.agentCli !== void 0 && !AGENT_IDS2.includes(p.agentCli)) invalid("unknown agent");
@@ -7251,6 +7657,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       if (p.jira !== void 0 && !isJiraRef(p.jira)) invalid("jira must be a Jira ticket ref");
       const { task } = await createTaskFromInput({
         projectPath: p.projectPath,
+        role: p.role,
+        workDir: p.workDir,
+        masterId: p.masterId,
         title: p.title,
         description: p.description,
         baseBranch: p.baseBranch,
@@ -7278,6 +7687,18 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     // were new. Launching again is the caller's decision.
     "vibeflow:resetTaskRun": async (taskId) => {
       const task = requireTask(taskId);
+      if (isMasterTask(task) && task.worktreePath) {
+        await teardownTask(task.id);
+        if (task.workspacePath) deleteArtifacts(task.workspacePath, task.worktreePath);
+        resetSubAgents(task.worktreePath);
+        const usage2 = usageThroughCurrentRun(task);
+        progress.untrack(task.id);
+        updateTask(task.id, { launchedAt: Date.now(), runId: randomUUID5(), jevRoute: void 0, ...usage2 ? { usage: usage2 } : {} });
+        const reset2 = findTask(task.id);
+        if (!reset2) throw new Error("\u627E\u4E0D\u5230\u8981\u91CD\u7F6E\u7684\u4EFB\u52D9");
+        bus.emit("subagents:update", { taskId: task.id, subAgents: [] });
+        return { state: getState(), task: reset2 };
+      }
       if (!task.worktreePath) {
         await teardownTask(task.id);
         progress.untrack(task.id);
@@ -7314,8 +7735,16 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
         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 masterPatch = {};
+      if (p.masterId !== void 0) {
+        if (p.masterId !== null) {
+          if (isMasterTask(existing)) invalid("a master cannot belong to another master");
+          assertMasterRef(getState().board, str(p.masterId, "masterId"), existing.id);
+        }
+        masterPatch = { masterId: p.masterId || void 0 };
+      }
       let gitPatch = {};
-      const nextProject = p.projectPath || existing.projectPath;
+      const nextProject = isMasterTask(existing) ? void 0 : 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);
@@ -7360,6 +7789,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
         jevRoute: void 0,
         effort: p.effort,
         autoMode: p.autoMode,
+        ...masterPatch,
         ...gitPatch
       });
       return getState();
@@ -7370,40 +7800,35 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "pty:start": async (payload) => {
       const p = obj(payload, "payload");
       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) {
-        const intent = obj(p.launch, "launch");
-        if (intent.resume && await sessions.isAlive(key)) {
-          fresh = false;
-        } else {
-          command = (await launchCommand(task, intent)).replace(/\r$/, "");
-        }
-      }
-      if (p.launch) ensureTaskArtifactDirs(task);
-      const result = await sessions.start(key, {
-        cwd,
-        command,
-        fresh,
-        cols: typeof p.cols === "number" ? p.cols : void 0,
-        rows: typeof p.rows === "number" ? p.rows : void 0,
-        // Session ended (natural exit included), so stop its watcher.
-        onExit: () => unwatchSubAgents(key)
+      return startTaskSession(requested, sessionKeyFor(requested.id, p.sessionKey), p);
+    },
+    // What dragging a card into In Progress does, without a frontend: the card
+    // moves, provisions and starts its agent here, so whoever opens it later
+    // attaches to a run that is already going. This is how a master starts the
+    // cards it dispatched.
+    "vibeflow:startTask": async (taskId) => {
+      const task = requireTask(taskId);
+      const column = columnOf(task.id);
+      if (column !== "backlog") throw new Error(`\u53EA\u6709 Backlog \u7684\u5361\u7247\u53EF\u4EE5\u555F\u52D5\uFF08\u76EE\u524D\u5728 ${column}\uFF09`);
+      const board = getState().board;
+      const started = { ...task, launchedAt: Date.now(), launchError: void 0 };
+      setBoard({
+        backlog: board.backlog.filter((t) => t.id !== task.id),
+        in_progress: [started, ...board.in_progress],
+        done: board.done
       });
-      terminalDirectories.set(key, cwd);
-      watchSubAgents(key, cwd, (subAgents) => {
-        bus.emit("subagents:update", { taskId: task.id, subAgents });
+      bus.emit("state:changed", getState());
+      await startTaskSession(started, task.id, { taskId: task.id, launch: {} });
+      return { state: getState(), task: findTask(task.id) ?? started };
+    },
+    // Every card on the board, or one master's cards, as the CLI and a master's
+    // agent read them.
+    "task:summaries": (payload) => {
+      const p = payload === void 0 ? {} : obj(payload, "payload");
+      return summarizeTasks({
+        masterId: p.masterId === void 0 ? void 0 : requireTask(p.masterId).id,
+        taskId: p.taskId === void 0 ? void 0 : requireTask(p.taskId).id
       });
-      if (p.launch) {
-        const current = findTask(task.id);
-        if (current) trackProgress(current);
-      }
-      return result;
     },
     "terminal:start": async (payload) => {
       const p = obj(payload, "payload");
@@ -7419,8 +7844,11 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       if (p.taskId) {
         const requested = requireTask(p.taskId);
         const column = columnOf(requested.id);
-        const task = column === "in_progress" && !requested.worktreePath ? await ensureProvisioned(requested) : requested;
-        cwd = str(column === "backlog" ? task.projectPath : task.worktreePath ?? task.projectPath, "directory");
+        const task = !requested.worktreePath && (column === "in_progress" || isMasterTask(requested)) ? await ensureProvisioned(requested) : requested;
+        cwd = str(
+          isMasterTask(task) ? task.worktreePath : column === "backlog" ? task.projectPath : task.worktreePath ?? task.projectPath,
+          "directory"
+        );
         projectPath = task.projectPath ?? cwd;
       } else if (p.projectPath) {
         cwd = str(p.projectPath, "projectPath");
@@ -7452,6 +7880,11 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       const p = obj(payload, "payload");
       return readTerminalFile(terminalDirectory(p.sessionKey), str(p.path, "path"));
     },
+    "terminal:existingFiles": async (payload) => {
+      const p = obj(payload, "payload");
+      if (!Array.isArray(p.paths)) invalid("paths must be an array");
+      return existingTerminalFiles(terminalDirectory(p.sessionKey), p.paths.map((value) => str(value, "path")));
+    },
     "terminal:openFile": async (payload) => {
       const p = obj(payload, "payload");
       const file = await readTerminalFile(terminalDirectory(p.sessionKey), str(p.path, "path"), true);
@@ -7509,8 +7942,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     },
     "git:getDiff": (taskId) => {
       const task = requireTask(taskId);
-      if (!task.worktreePath) return [];
-      return getWorktreeDiff(task.worktreePath, task.baseBranch ?? "HEAD");
+      const worktree = gitWorktree(task);
+      if (!worktree) return [];
+      return getWorktreeDiff(worktree, task.baseBranch ?? "HEAD");
     },
     /**
      * Changed-file list without content — cheap enough for the sidebar to poll.
@@ -7519,16 +7953,18 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
      */
     "git:getDiffEntries": (taskId, opts) => {
       const task = requireTask(taskId);
-      if (!task.worktreePath) return [];
+      const worktree = gitWorktree(task);
+      if (!worktree) return [];
       const fetch2 = opts && typeof opts === "object" ? opts.fetch : void 0;
-      return getWorktreeDiffEntries(task.worktreePath, task.baseBranch ?? "HEAD", {
+      return getWorktreeDiffEntries(worktree, task.baseBranch ?? "HEAD", {
         fetch: typeof fetch2 === "boolean" ? fetch2 : void 0
       });
     },
     "git:getDiffFile": (taskId, filePath) => {
       const task = requireTask(taskId);
-      if (!task.worktreePath) return null;
-      return getWorktreeDiffFile(task.worktreePath, task.baseBranch ?? "HEAD", str(filePath, "filePath"));
+      const worktree = gitWorktree(task);
+      if (!worktree) return null;
+      return getWorktreeDiffFile(worktree, task.baseBranch ?? "HEAD", str(filePath, "filePath"));
     },
     "task:listArtifacts": (taskId) => {
       const task = requireTask(taskId);
@@ -7554,6 +7990,7 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "task:getSpecs": async (taskId) => {
       const task = requireTask(taskId);
       const base2 = task.baseBranch ?? "main";
+      if (isMasterTask(task)) return [];
       if (task.worktreePath) return readWorktreeSpecs(task.worktreePath, base2);
       const since = task.provisionedAt ?? task.launchedAt ?? (task.pushed !== void 0 ? task.createdAt : void 0);
       if (!task.projectPath || !since) return [];
@@ -7609,25 +8046,29 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
     "git:approve": async (payload) => {
       const p = obj(payload, "payload");
       const task = requireTask(p.taskId);
-      if (!task.worktreePath) throw new Error("\u627E\u4E0D\u5230\u6B64\u4EFB\u52D9\u7684 worktree");
-      const result = await commitAndPush(task.worktreePath, str(p.message, "message"));
+      const worktree = gitWorktree(task);
+      if (!worktree) throw new Error("\u627E\u4E0D\u5230\u6B64\u4EFB\u52D9\u7684 worktree");
+      const result = await commitAndPush(worktree, str(p.message, "message"));
       if (result.pushed) updateTask(task.id, { pushed: true });
       return { result, state: getState() };
     },
     "git:generateCommitMessage": (taskId) => {
       const task = requireTask(taskId);
-      if (!task.worktreePath) throw new Error("\u627E\u4E0D\u5230\u6B64\u4EFB\u52D9\u7684 worktree");
-      return generateCommitMessage(task.worktreePath, task.baseBranch ?? "main", task.agentCli ?? "claude");
+      const worktree = gitWorktree(task);
+      if (!worktree) throw new Error("\u627E\u4E0D\u5230\u6B64\u4EFB\u52D9\u7684 worktree");
+      return generateCommitMessage(worktree, task.baseBranch ?? "main", task.agentCli ?? "claude");
     },
     "git:getPrStatus": (taskId) => {
       const task = requireTask(taskId);
-      if (!task.worktreePath) return null;
-      return getPrStatus(task.worktreePath);
+      const worktree = gitWorktree(task);
+      if (!worktree) return null;
+      return getPrStatus(worktree);
     },
     "git:getGithubCompareUrl": (taskId) => {
       const task = requireTask(taskId);
-      if (!task.worktreePath) return null;
-      return getGithubCompareUrl(task.worktreePath, task.baseBranch ?? "main");
+      const worktree = gitWorktree(task);
+      if (!worktree) return null;
+      return getGithubCompareUrl(worktree, 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.
@@ -7655,8 +8096,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       await teardownTask(task.id);
       cancelChatSend(task.id);
       let outcome;
-      if (task.worktreePath) {
-        outcome = await captureTaskOutcome(task.worktreePath, task.baseBranch ?? "main") ?? void 0;
+      const worktree = gitWorktree(task);
+      if (worktree) {
+        outcome = await captureTaskOutcome(worktree, task.baseBranch ?? "main") ?? void 0;
       }
       const usage = usageThroughCurrentRun(task);
       progress.untrack(task.id);
@@ -7685,6 +8127,9 @@ function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatu
       if (task.workspacePath) {
         fs21.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
       }
+      if (isMasterTask(task) && task.workspacePath) {
+        fs21.rmSync(task.workspacePath, { recursive: true, force: true });
+      }
       clearConversation(task.id);
       removeTask(task.id);
       return getState();
@@ -8395,119 +8840,6 @@ function isWebDir(dir) {
   return fs25.existsSync(path28.join(dir, "home", "index.html"));
 }
 
-// packages/cli/src/remote.ts
-import WebSocket from "ws";
-
-// packages/core/src/ws-transport.ts
-var OPEN = 1;
-var MAX_BACKOFF_MS = 5e3;
-function createWsTransport(options) {
-  let socket = null;
-  let nextId = 1;
-  let connectedOnce = false;
-  let closed = false;
-  let backoff = 250;
-  const queue = [];
-  const pending = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Map();
-  function flush() {
-    while (socket && socket.readyState === OPEN && queue.length > 0) socket.send(queue.shift());
-  }
-  function open() {
-    if (closed) return;
-    const ws = options.connect();
-    socket = ws;
-    ws.onopen = () => {
-      backoff = 250;
-      options.onStatus?.(true);
-      flush();
-      if (connectedOnce) options.onReconnect?.();
-      connectedOnce = true;
-    };
-    ws.onmessage = (ev) => {
-      let msg;
-      try {
-        msg = JSON.parse(String(ev.data));
-      } catch {
-        return;
-      }
-      if (typeof msg.event === "string") {
-        dispatch(msg.event, msg.payload);
-        return;
-      }
-      const entry = typeof msg.id === "number" ? pending.get(msg.id) : void 0;
-      if (!entry) return;
-      pending.delete(msg.id);
-      if (msg.error) entry.reject(Object.assign(new Error(msg.error.message), { code: msg.error.code }));
-      else entry.resolve(msg.result === null ? void 0 : msg.result);
-    };
-    ws.onerror = () => {
-    };
-    ws.onclose = () => {
-      if (socket !== ws) return;
-      socket = null;
-      options.onStatus?.(false);
-      for (const [id, entry] of Array.from(pending)) {
-        pending.delete(id);
-        entry.reject(new Error("\u8207 VibeFlow core \u7684\u9023\u7DDA\u4E2D\u65B7"));
-      }
-      if (closed) return;
-      setTimeout(open, backoff);
-      backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
-    };
-  }
-  function dispatch(channel, payload) {
-    for (const cb of Array.from(listeners.get(channel) ?? [])) cb(payload);
-  }
-  function post(message) {
-    const data = JSON.stringify(message);
-    if (socket && socket.readyState === OPEN) socket.send(data);
-    else queue.push(data);
-  }
-  open();
-  return {
-    kind: "ws",
-    invoke(method, ...params) {
-      const id = nextId++;
-      return new Promise((resolve, reject) => {
-        pending.set(id, { resolve, reject });
-        post({ id, method, params });
-      });
-    },
-    send(method, ...params) {
-      post({ method, params });
-    },
-    on(channel, callback) {
-      let set = listeners.get(channel);
-      if (!set) listeners.set(channel, set = /* @__PURE__ */ new Set());
-      set.add(callback);
-      return () => {
-        set.delete(callback);
-      };
-    },
-    close() {
-      closed = true;
-      socket?.close();
-    },
-    dispatch
-  };
-}
-
-// packages/cli/src/remote.ts
-function connectToHost(lock) {
-  const url = `ws://127.0.0.1:${lock.port}/ws`;
-  const transport = createWsTransport({
-    connect: () => new WebSocket(url, {
-      headers: { Authorization: `Bearer ${lock.token}`, Host: `127.0.0.1:${lock.port}` }
-    })
-  });
-  return {
-    api: createBridge(transport),
-    invoke: (method, ...params) => transport.invoke(method, ...params),
-    close: () => transport.close()
-  };
-}
-
 // packages/cli/src/doctor.ts
 import fs26 from "fs";
 import path29 from "path";