@kw-yeh/vibeflow 4.5.1 → 4.6.0

package/dist/vibeflow.mjs

@@ -599,11 +599,293 @@ var init_attachments = __esm({
   }
 });
 
+// packages/core/src/progress.ts
+function emptyUsage() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 };
+}
+function addUsage(a, b) {
+  return {
+    input: a.input + b.input,
+    output: a.output + b.output,
+    cacheRead: a.cacheRead + b.cacheRead,
+    cacheWrite: a.cacheWrite + b.cacheWrite,
+    reasoning: a.reasoning + b.reasoning
+  };
+}
+function totalTokens(u) {
+  return u.input + u.output + u.cacheRead + u.cacheWrite;
+}
+function todoStatus(v) {
+  return v === "pending" || v === "in_progress" || v === "completed" ? v : null;
+}
+function parseTime(v) {
+  if (typeof v !== "string") return void 0;
+  const t = Date.parse(v);
+  return Number.isNaN(t) ? void 0 : t;
+}
+function parseLine(line) {
+  try {
+    const value = JSON.parse(line);
+    return value && typeof value === "object" ? value : null;
+  } catch {
+    return null;
+  }
+}
+function initialClaudeState() {
+  return { todos: null, usageById: {}, pendingTasks: {}, activity: { state: "unknown" } };
+}
+function claudeUsage(u) {
+  const details = u.output_tokens_details;
+  return {
+    input: num(u.input_tokens),
+    output: num(u.output_tokens),
+    cacheRead: num(u.cache_read_input_tokens),
+    cacheWrite: num(u.cache_creation_input_tokens),
+    reasoning: num(details?.thinking_tokens)
+  };
+}
+function todoWriteItems(input) {
+  if (!Array.isArray(input.todos)) return null;
+  const items = [];
+  for (const raw of input.todos) {
+    if (!raw || typeof raw !== "object") continue;
+    const t = raw;
+    const status = todoStatus(t.status);
+    if (typeof t.content !== "string" || !status) continue;
+    items.push({
+      content: t.content,
+      status,
+      ...typeof t.activeForm === "string" ? { activeForm: t.activeForm } : {}
+    });
+  }
+  return items;
+}
+function applyClaudeTask(todos, name, input, result) {
+  if (name === "TaskCreate") {
+    const task = result?.task;
+    const id2 = task && (typeof task.id === "string" || typeof task.id === "number") ? String(task.id) : void 0;
+    const content = typeof input.subject === "string" ? input.subject : typeof task?.subject === "string" ? task.subject : null;
+    if (!content) return todos;
+    const item = {
+      ...id2 ? { id: id2 } : {},
+      content,
+      status: "pending",
+      ...typeof input.activeForm === "string" ? { activeForm: input.activeForm } : {}
+    };
+    return [...todos ?? [], item];
+  }
+  if (result && result.success === false) return todos;
+  const id = typeof input.taskId === "string" || typeof input.taskId === "number" ? String(input.taskId) : null;
+  if (!id || !todos) return todos;
+  if (input.status === "deleted") return todos.filter((t) => t.id !== id);
+  const status = todoStatus(input.status);
+  return todos.map((t) => {
+    if (t.id !== id) return t;
+    return {
+      ...t,
+      ...status ? { status } : {},
+      ...typeof input.subject === "string" ? { content: input.subject } : {},
+      ...typeof input.activeForm === "string" ? { activeForm: input.activeForm } : {}
+    };
+  });
+}
+function reduceClaudeLine(state, line) {
+  const entry = parseLine(line);
+  if (!entry) return state;
+  const at = parseTime(entry.timestamp);
+  const next = { ...state, startedAt: state.startedAt ?? at };
+  const message = entry.message;
+  const content = Array.isArray(message?.content) ? message.content : [];
+  if (entry.type === "assistant" && message) {
+    const usage = message.usage;
+    if (usage && typeof message.id === "string") {
+      const u = claudeUsage(usage);
+      next.usageById = { ...state.usageById, [message.id]: u };
+      next.contextTokens = u.input + u.cacheRead + u.cacheWrite;
+    }
+    let tool;
+    for (const block of content) {
+      if (block?.type !== "tool_use" || typeof block.name !== "string") continue;
+      tool = block.name;
+      const input = block.input && typeof block.input === "object" ? block.input : {};
+      if (block.name === "TodoWrite") {
+        const items = todoWriteItems(input);
+        if (items) next.todos = items;
+      } else if ((block.name === "TaskCreate" || block.name === "TaskUpdate") && typeof block.id === "string") {
+        next.pendingTasks = { ...next.pendingTasks, [block.id]: { name: block.name, input } };
+      }
+    }
+    if (tool) next.activity = { state: "working", tool, at };
+    else if (message.stop_reason === "end_turn") next.activity = { state: "waiting", waitingFor: "input", at };
+    else next.activity = { state: "working", at };
+    return next;
+  }
+  if (entry.type === "user" && message) {
+    const result = entry.toolUseResult && typeof entry.toolUseResult === "object" ? entry.toolUseResult : void 0;
+    let pending = next.pendingTasks;
+    for (const block of content) {
+      if (block?.type !== "tool_result" || typeof block.tool_use_id !== "string") continue;
+      const call = pending[block.tool_use_id];
+      if (!call) continue;
+      next.todos = applyClaudeTask(next.todos, call.name, call.input, result);
+      pending = { ...pending };
+      delete pending[block.tool_use_id];
+    }
+    next.pendingTasks = pending;
+    next.activity = { state: "working", at };
+    return next;
+  }
+  return next;
+}
+function claudeUsageTotal(state) {
+  return Object.values(state.usageById).reduce(addUsage, emptyUsage());
+}
+function initialCodexState() {
+  return { todos: null, usage: emptyUsage(), activity: { state: "unknown" } };
+}
+function codexUsage(u) {
+  const cached2 = num(u.cached_input_tokens);
+  return {
+    input: Math.max(0, num(u.input_tokens) - cached2),
+    output: num(u.output_tokens),
+    cacheRead: cached2,
+    cacheWrite: num(u.cache_write_input_tokens),
+    reasoning: num(u.reasoning_output_tokens)
+  };
+}
+function planItems(argumentsJson) {
+  if (typeof argumentsJson !== "string") return null;
+  const args = parseLine(argumentsJson);
+  if (!args || !Array.isArray(args.plan)) return null;
+  const items = [];
+  for (const raw of args.plan) {
+    if (!raw || typeof raw !== "object") continue;
+    const p = raw;
+    const status = todoStatus(p.status);
+    if (typeof p.step === "string" && status) items.push({ content: p.step, status });
+  }
+  return items;
+}
+function reduceCodexLine(state, line) {
+  const entry = parseLine(line);
+  if (!entry) return state;
+  const at = parseTime(entry.timestamp);
+  const payload = entry.payload && typeof entry.payload === "object" ? entry.payload : {};
+  if (entry.type === "session_meta") {
+    return {
+      ...state,
+      cwd: typeof payload.cwd === "string" ? payload.cwd : state.cwd,
+      startedAt: parseTime(payload.timestamp) ?? at ?? state.startedAt
+    };
+  }
+  if (entry.type === "response_item" && (payload.type === "function_call" || payload.type === "custom_tool_call")) {
+    const name = typeof payload.name === "string" ? payload.name : void 0;
+    const next = { ...state, activity: { state: "working", tool: name, at } };
+    if (name === "update_plan") {
+      const items = planItems(payload.arguments);
+      if (items) next.todos = items;
+    }
+    return next;
+  }
+  if (entry.type === "event_msg") {
+    if (payload.type === "token_count") {
+      const info = payload.info;
+      const total = info?.total_token_usage;
+      if (!total) return state;
+      const last = info?.last_token_usage;
+      return { ...state, usage: codexUsage(total), contextTokens: last ? num(last.input_tokens) : state.contextTokens };
+    }
+    if (payload.type === "task_complete") {
+      return { ...state, activity: { state: "waiting", waitingFor: "input", at } };
+    }
+    if (payload.type === "task_started" || payload.type === "user_message") {
+      return { ...state, activity: { state: "working", at } };
+    }
+  }
+  return state;
+}
+function activityFromHook(event, at) {
+  if (!event || typeof event !== "object") return null;
+  const e = event;
+  switch (e.hook_event_name) {
+    case "Notification":
+      return e.notification_type === "idle_prompt" ? { state: "waiting", waitingFor: "input", at } : { state: "waiting", waitingFor: "permission", at };
+    case "Stop":
+      return { state: "waiting", waitingFor: "input", at };
+    case "UserPromptSubmit":
+    case "PostToolUse":
+      return { state: "working", at };
+    default:
+      return null;
+  }
+}
+function latestActivity(a, b) {
+  if (!b) return a;
+  if (a.at == null) return b;
+  if (b.at == null) return a;
+  return b.at >= a.at ? b : a;
+}
+function sameItem(a, b) {
+  return a.id != null || b.id != null ? a.id === b.id : a.content === b.content;
+}
+function diffProgress(prev, next) {
+  if (!prev) return [];
+  const out = [];
+  const todos = next.todos ?? [];
+  const before = prev.todos ?? [];
+  const done = todos.filter((t) => t.status === "completed").length;
+  for (const item of todos) {
+    if (item.status !== "completed") continue;
+    const old = before.find((b) => sameItem(b, item));
+    if (old?.status === "completed") continue;
+    out.push({ kind: "step_completed", item: item.content, done, total: todos.length });
+  }
+  const allDone = (list) => list.length > 0 && list.every((t) => t.status === "completed");
+  if (allDone(todos) && !allDone(before)) {
+    out.push({ kind: "all_completed", done, total: todos.length });
+  }
+  if (next.activity.state === "waiting" && prev.activity.state !== "waiting") {
+    out.push({ kind: "waiting_input", waitingFor: next.activity.waitingFor ?? "input" });
+  }
+  return out;
+}
+function formatTokens(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+  return `${(n / 1e6).toFixed(2)}M`;
+}
+function describeNotification(n) {
+  switch (n.kind) {
+    case "step_completed":
+      return `\u5B8C\u6210 ${n.done}/${n.total} \u2014 ${n.item ?? ""}`;
+    case "all_completed":
+      return "\u6240\u6709\u6B65\u9A5F\u5DF2\u5B8C\u6210";
+    case "waiting_input":
+      return n.waitingFor === "permission" ? "\u7B49\u5F85\u4F60\u5141\u8A31\u6B0A\u9650" : "\u7B49\u5F85\u4F60\u7684\u8F38\u5165";
+  }
+}
+function progressSummary(progress, usage) {
+  const parts = [];
+  const todos = progress?.todos;
+  if (todos && todos.length) parts.push(`${todos.filter((t) => t.status === "completed").length}/${todos.length}`);
+  const total = progress?.totalUsage ?? usage;
+  if (total && totalTokens(total) > 0) parts.push(`${formatTokens(totalTokens(total))} tok`);
+  if (progress?.activity.state === "waiting") parts.push(progress.activity.waitingFor === "permission" ? "\u7B49\u5F85\u6B0A\u9650" : "\u7B49\u5F85\u8F38\u5165");
+  return parts.join(" \xB7 ");
+}
+var num;
+var init_progress = __esm({
+  "packages/core/src/progress.ts"() {
+    "use strict";
+    num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+  }
+});
+
 // packages/tui/src/task-form.ts
 import { spawnSync } from "child_process";
-import fs20 from "fs";
-import os6 from "os";
-import path24 from "path";
+import fs21 from "fs";
+import os7 from "os";
+import path25 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render, useApp, useInput } from "ink";
 function newFormState(defaultAutoMode, agents) {
@@ -722,17 +1004,17 @@ function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs20.mkdtempSync(path24.join(os6.tmpdir(), "vibeflow-"));
-  const file = path24.join(dir, "description.md");
+  const dir = fs21.mkdtempSync(path25.join(os7.tmpdir(), "vibeflow-"));
+  const file = path25.join(dir, "description.md");
   try {
-    fs20.writeFileSync(file, text);
+    fs21.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: fs20.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
+    return { text: fs21.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
   } finally {
-    fs20.rmSync(dir, { recursive: true, force: true });
+    fs21.rmSync(dir, { recursive: true, force: true });
   }
 }
 function cycle(list, current, step) {
@@ -803,10 +1085,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(path24.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir())));
+      if (value2) setProject(path25.resolve(value2.replace(/^~(?=$|\/)/, os7.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path24.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir()));
-      if (!fs20.existsSync(file) || !fs20.statSync(file).isFile()) {
+      const file = path25.resolve(value2.replace(/^~(?=$|\/)/, os7.homedir()));
+      if (!fs21.existsSync(file) || !fs21.statSync(file).isFile()) {
         setMessage(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
         return;
       }
@@ -886,7 +1168,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) => path24.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
+        return s.attachments.length ? s.attachments.map((a) => path25.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");
@@ -917,7 +1199,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       if (info && !info.isRepo) return "\u9019\u500B\u8CC7\u6599\u593E\u4E0D\u662F Git repository\u3002\u8ACB\u6539\u9078\u4E00\u500B Git \u5C08\u6848\uFF0C\u6216\u5728\u4E0B\u65B9\u521D\u59CB\u5316\u3002";
       if (s.mode === "edit" && projectChanged(s)) return "\u5206\u652F\u6703\u5728\u65B0\u5C08\u6848\u3001\u5361\u7247\u958B\u59CB\u57F7\u884C\u6642\u624D\u5EFA\u7ACB\u3002";
       if (info?.isRepo && !info.hasRemote) return `\u6B64 repository \u6C92\u6709 remote\uFF0C\u5C07\u4EE5\u76EE\u524D\u5206\u652F (${info.currentBranch ?? "HEAD"}) \u70BA\u57FA\u6E96\u5EFA\u7ACB\u672C\u5730 worktree\u3002`;
-      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path24.basename(s.projectPath)}`;
+      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path25.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";
@@ -1037,7 +1319,7 @@ __export(src_exports, {
   showDiff: () => showDiff
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import path25 from "path";
+import path26 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) {
@@ -1092,10 +1374,18 @@ function BoardView({ opts, initial, initialMessage, onAction }) {
   const [message, setMessage] = useState2(initialMessage ?? "");
   const [confirm, setConfirm] = useState2(null);
   const [help, setHelp] = useState2(false);
+  const [progress, setProgress] = useState2({});
   useEffect2(() => {
     let alive = true;
     void api.getState().then((s) => alive && setBoard2(s.board));
     const off = api.onStateChanged((s) => setBoard2(s.board));
+    const offProgress = api.onProgressUpdate(({ taskId, progress: p }) => {
+      setProgress((prev) => ({ ...prev, [taskId]: p }));
+    });
+    const offNotify = api.onProgressNotify(({ title, notifications }) => {
+      const last = notifications[notifications.length - 1];
+      if (last) setMessage(`\u300C${title}\u300D${describeNotification(last)}`);
+    });
     const poll = async () => {
       try {
         const info = await api.term.list();
@@ -1110,12 +1400,27 @@ function BoardView({ opts, initial, initialMessage, onAction }) {
     return () => {
       alive = false;
       off();
+      offProgress();
+      offNotify();
       clearInterval(timer);
     };
   }, [api]);
   useEffect2(() => {
     if (board) setSel((s) => clampSelection(board, s));
   }, [board]);
+  const runningIds = board ? board.in_progress.map((t) => t.id).join(",") : "";
+  useEffect2(() => {
+    let alive = true;
+    for (const id of runningIds ? runningIds.split(",") : []) {
+      void api.getProgress(id).then((p) => {
+        if (alive && p) setProgress((prev) => prev[id] ? prev : { ...prev, [id]: p });
+      }).catch(() => {
+      });
+    }
+    return () => {
+      alive = false;
+    };
+  }, [api, runningIds]);
   const selected = board ? board[COLUMNS2[sel.column]][sel.index] : void 0;
   const leave = (action) => {
     onAction(action, sel);
@@ -1259,10 +1564,12 @@ 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 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)),
+          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
         );
       })
@@ -1308,7 +1615,7 @@ function showDiff(task) {
   });
 }
 function tmuxAttach(opts, sessionName) {
-  const conf = path25.join(opts.userDataDir, "tmux.conf");
+  const conf = path26.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 : "" } });
@@ -1422,6 +1729,7 @@ var h2, COLUMNS2, COLUMN_TITLES, DETACH_KEY, RESET_TERMINAL_MODES, CLEAR_SCREEN;
 var init_src = __esm({
   "packages/tui/src/index.ts"() {
     "use strict";
+    init_progress();
     init_tmux_backend();
     init_task_form();
     h2 = React2.createElement;
@@ -1438,8 +1746,8 @@ var init_src = __esm({
 });
 
 // packages/cli/src/main.ts
-import fs21 from "fs";
-import path26 from "path";
+import fs22 from "fs";
+import path27 from "path";
 import { fileURLToPath } from "url";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -1775,6 +2083,21 @@ function recordRecentProject(store, projectPath) {
 }
 
 // packages/core/src/store.ts
+var DEFAULT_NOTIFICATION_SETTINGS = {
+  enabled: true,
+  stepCompleted: false,
+  allCompleted: true,
+  waitingInput: true,
+  desktop: false
+};
+function resolveNotificationSettings(settings) {
+  const stored = settings?.notifications ?? {};
+  const out = { ...DEFAULT_NOTIFICATION_SETTINGS };
+  for (const key of Object.keys(out)) {
+    if (typeof stored[key] === "boolean") out[key] = stored[key];
+  }
+  return out;
+}
 function resolveWorkstationPath(settings) {
   const p = settings?.workstationPath?.trim();
   return p && p.length > 0 ? p : join(homedir2(), "Desktop");
@@ -1832,6 +2155,11 @@ function getSettings() {
 }
 function setSettings(patch) {
   const next = { ...getSettings(), ...patch };
+  if (patch.notifications !== void 0) {
+    next.notifications = resolveNotificationSettings({
+      notifications: { ...resolveNotificationSettings(getSettings()), ...patch.notifications ?? {} }
+    });
+  }
   if (typeof next.systemPrompt === "string" && next.systemPrompt.trim() === "") {
     delete next.systemPrompt;
   }
@@ -1962,6 +2290,16 @@ function createBridge(t) {
       return t.on("subagents:update", (payload) => callback(payload));
     },
     deleteTask: (taskId) => t.invoke("vibeflow:deleteTask", taskId),
+    /** A running card's progress now (todos, usage, activity); null = nothing to show yet. */
+    getProgress: (taskId) => t.invoke("progress:get", taskId),
+    /** Every change to a card's progress, read from its agent's transcript. */
+    onProgressUpdate: (callback) => {
+      return t.on("progress:update", (payload) => callback(payload));
+    },
+    /** Stage notifications, already filtered by the user's notification settings. */
+    onProgressNotify: (callback) => {
+      return t.on("progress:notify", (payload) => callback(payload));
+    },
     attachments: {
       write: (payload) => t.invoke("attachments:write", payload)
     },
@@ -2357,103 +2695,287 @@ function unwatchAllSubAgents() {
   }
 }
 
-// packages/core/src/git.ts
-init_env();
-init_attachments();
-
-// packages/core/src/artifacts.ts
-import fs7 from "fs";
-import path11 from "path";
+// packages/core/src/launch.ts
 var ARTIFACTS_DIR_SUFFIX = ".artifacts";
 var SCRATCH_DIR_NAME = "scratch";
 var ARTIFACTS_FALLBACK_DIR = ".vibeflow-artifacts";
-var IMAGE_MIME = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".bmp": "image/bmp",
-  ".svg": "image/svg+xml"
-};
-var VIDEO_MIME = {
-  ".mp4": "video/mp4",
-  ".m4v": "video/mp4",
-  ".webm": "video/webm",
-  ".mov": "video/mp4"
-};
-var MAX_VIDEO_BYTES = 20 * 1024 * 1024;
-var MAX_TEXT_BYTES = 256 * 1024;
-var MAX_DEPTH = 3;
-var MAX_ARTIFACTS = 200;
-var SNIFF_BYTES = 8 * 1024;
-function agentArtifactsPath(baseDir, worktreePath) {
-  return path11.join(baseDir, `${path11.basename(worktreePath)}${ARTIFACTS_DIR_SUFFIX}`);
+function pathBasename(p) {
+  const norm = p.replace(/\\/g, "/").replace(/\/+$/, "");
+  const i = norm.lastIndexOf("/");
+  return i >= 0 ? norm.slice(i + 1) : norm;
 }
-function mediaKind(filePath, size) {
-  const extension = path11.extname(filePath).toLowerCase();
-  const imageMime = IMAGE_MIME[extension];
-  if (imageMime) return { kind: "image", mime: imageMime };
-  const videoMime = VIDEO_MIME[extension];
-  if (videoMime) {
-    return size > MAX_VIDEO_BYTES ? { kind: "binary" } : { kind: "video", mime: videoMime };
+function agentArtifactsDir(worktreePath, workspacePath) {
+  if (!worktreePath || !workspacePath) return null;
+  const dir = toShellPath(workspacePath);
+  const ws = pathBasename(worktreePath);
+  return `${dir}/${ws}${ARTIFACTS_DIR_SUFFIX}`;
+}
+function buildArtifactPrompt(artifactsDir = ARTIFACTS_FALLBACK_DIR) {
+  return [
+    "Artifact \u8A2D\u5B9A\uFF08\u672C\u6B21 session \u5168\u7A0B\u9069\u7528\uFF09\uFF1A",
+    `1. \u672C\u4EFB\u52D9\u7684 Artifact \u8CC7\u6599\u593E\u662F ${artifactsDir}/\uFF1B\u9700\u8981\u4FDD\u5B58\u7D66\u4F7F\u7528\u8005\u7684\u9A57\u8B49\u8B49\u64DA\u6216\u5831\u544A\u6642\uFF0C\u8ACB\u5BEB\u5165\u6B64\u8CC7\u6599\u593E\uFF08\u4E0D\u5B58\u5728\u8ACB\u5EFA\u7ACB\uFF09\u3002`,
+    `2. \u4F7F\u7528\u8005\u6703\u5728 VibeFlow \u7684 Artifacts \u5206\u9801\u6AA2\u8996\u6839\u76EE\u9304\u5167\u5BB9\uFF1B\u53EA\u653E\u4F60\u6703\u4E3B\u52D5\u8ACB\u4F7F\u7528\u8005\u904E\u76EE\u7684\u6A94\u6848\u3002`,
+    `3. \u4F60\u81EA\u5DF1\u7684\u5DE5\u4F5C\u66AB\u5B58\uFF08\u4E00\u6B21\u6027 script\u3001log\u3001\u4E2D\u9593\u8F38\u51FA\u3001debug \u6A94\uFF09\u653E\u5728 ${artifactsDir}/${SCRATCH_DIR_NAME}/\u3002`,
+    `4. \u82E5\u5DE5\u5177\u5148\u8F38\u51FA\u5230 /tmp\u3001/private/tmp\u3001$TMPDIR \u6216 ~/Downloads\uFF0C\u8ACB\u628A\u6700\u7D42\u8981\u5448\u73FE\u7684\u6A94\u6848\u8907\u88FD\u5230 ${artifactsDir}/ \u4E26\u78BA\u8A8D\u5B58\u5728\u3002`,
+    "5. Artifact \u8CC7\u6599\u593E\u4F4D\u65BC worktree \u4E4B\u5916\uFF1B\u4E0D\u8981\u628A\u5176\u4E2D\u5167\u5BB9\u52A0\u5165 git commit\uFF0C\u4E5F\u4E0D\u8981\u628A\u6700\u7D42\u4EA4\u4ED8\u7269\u53EA\u7559\u5728\u9019\u88E1\u3002"
+  ].join("\n");
+}
+var AUTO_PERMISSION_MODE = "auto";
+function claudePermissionFlag(autoMode) {
+  return autoMode ? ` --permission-mode ${AUTO_PERMISSION_MODE}` : "";
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function toShellPath(p) {
+  return p.replace(/\\/g, "/");
+}
+function boardEnvPrefix(task, opts) {
+  const board = opts?.boardCli;
+  if (!board) return "";
+  const entries = [
+    ["VIBEFLOW_TASK_ID", task.id],
+    ["VIBEFLOW_PROJECT_PATH", task.projectPath],
+    ["VIBEFLOW_BRANCH", task.branch],
+    ["VIBEFLOW_BASE_BRANCH", task.baseBranch],
+    ["VIBEFLOW_STORE_DIR", board?.storeDir],
+    ["VIBEFLOW_CLI", board?.cliPath],
+    ["VIBEFLOW_CLI_LOADER", board?.loaderPath],
+    ["VIBEFLOW_AUTO_MODE", opts?.autoMode ? "1" : "0"]
+  ];
+  const exports = entries.filter((entry) => Boolean(entry[1])).map(([key, value]) => `${key}=${shellQuote(toShellPath(value))}`);
+  return exports.length ? `export ${exports.join(" ")}; ` : "";
+}
+function codexAutoFlag(autoMode) {
+  return autoMode ? "--dangerously-bypass-approvals-and-sandbox " : "";
+}
+function claudeResumeOrFresh(sessionId, worktreePath, tail) {
+  if (!worktreePath) return `claude --resume ${sessionId} ${tail}\r`;
+  const munged = worktreePath.replace(/[^a-zA-Z0-9]/g, "-");
+  const sessionFile = `"$HOME/.claude/projects/${munged}/${sessionId}.jsonl"`;
+  return `if [ -f ${sessionFile} ]; then claude --resume ${sessionId} ${tail}; else claude --session-id ${sessionId} ${tail}; fi\r`;
+}
+var SUBAGENTS_DIR2 = ".vibeflow-subagents";
+var PROGRESS_EVENTS_DIR = ".vibeflow-events";
+var TODO_TOOLS = "TodoWrite|TaskCreate|TaskUpdate";
+function buildClaudeSettings(worktreePath) {
+  const settings = { theme: "dark" };
+  if (worktreePath) {
+    const dir = `${toShellPath(worktreePath)}/${SUBAGENTS_DIR2}`;
+    const command = `mkdir -p "${dir}" && cat > "${dir}/$(date +%s)-$$-$RANDOM.json"`;
+    const taskHook = {
+      matcher: "Task",
+      hooks: [{ type: "command", command }]
+    };
+    const eventsDir = `${toShellPath(worktreePath)}/${PROGRESS_EVENTS_DIR}`;
+    const progress = {
+      hooks: [{ type: "command", command: `mkdir -p "${eventsDir}" && cat > "${eventsDir}/$(date +%s)-$$-$RANDOM.json"; exit 0` }]
+    };
+    settings.hooks = {
+      PreToolUse: [taskHook],
+      PostToolUse: [taskHook, { matcher: TODO_TOOLS, ...progress }],
+      Stop: [progress],
+      Notification: [progress],
+      UserPromptSubmit: [progress]
+    };
   }
-  return null;
+  return JSON.stringify(settings);
 }
-function sniffKind(filePath) {
-  let fd;
-  try {
-    fd = fs7.openSync(filePath, "r");
-    const buf = Buffer.alloc(SNIFF_BYTES);
-    const read = fs7.readSync(fd, buf, 0, SNIFF_BYTES, 0);
-    return buf.subarray(0, read).includes(0) ? "binary" : "text";
-  } catch {
-    return "binary";
-  } finally {
-    if (fd !== void 0) {
-      try {
-        fs7.closeSync(fd);
-      } catch {
-      }
-    }
+function resolveSystemPrompt(custom) {
+  return custom && custom.trim() ? custom : "";
+}
+function buildPrompt(task) {
+  const lines = [`\u4EFB\u52D9\u6A19\u984C\uFF1A${task.title}`];
+  const description = task.description?.trim();
+  if (description) {
+    lines.push("", "\u4EFB\u52D9\u63CF\u8FF0\uFF1A", description);
   }
+  return lines.join("\n");
 }
-function resolveInside(dir, name) {
-  let root;
-  let target;
-  try {
-    root = fs7.realpathSync(path11.resolve(dir));
-    target = fs7.realpathSync(path11.resolve(root, name));
-  } catch {
-    return null;
+function executorSessionId(taskId, runId) {
+  const source = runId ? `${taskId}:${runId}` : taskId;
+  const raw = source.replace(/[^0-9a-f]/gi, "").toLowerCase();
+  const hex = runId ? `${raw.slice(0, 24).padEnd(24, "0")}${namespaceHash(`executor:${source}`)}` : raw.padEnd(32, "0").slice(0, 32);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+function namespaceHash(namespace) {
+  let hash = 2166136261;
+  for (let i = 0; i < namespace.length; i += 1) {
+    hash ^= namespace.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
   }
-  if (target !== root && !target.startsWith(root + path11.sep)) return null;
-  return target;
+  return (hash >>> 0).toString(16).padStart(8, "0");
 }
-function listArtifacts(dir) {
-  const found2 = [];
-  const walk = (current, prefix, depth, scratch) => {
-    if (found2.length >= MAX_ARTIFACTS) return;
-    let dirents;
-    try {
-      dirents = fs7.readdirSync(current, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const dirent of dirents) {
-      if (found2.length >= MAX_ARTIFACTS) return;
-      const name = prefix ? `${prefix}/${dirent.name}` : dirent.name;
-      const full = path11.join(current, dirent.name);
-      if (dirent.isDirectory()) {
-        if (!scratch && depth === 1 && dirent.name === SCRATCH_DIR_NAME) continue;
-        if (depth < MAX_DEPTH) walk(full, name, depth + 1, scratch);
-        continue;
-      }
-      if (!dirent.isFile()) continue;
-      let stat;
-      try {
-        stat = fs7.statSync(full);
+function assembleCommand(agent, systemPrompt, prompt, model, effort, opts, worktreePath, sessionId, workspacePath) {
+  let cmd;
+  if (agent === "claude") {
+    const settings = ` --settings ${shellQuote(buildClaudeSettings(worktreePath))}`;
+    const addDir = workspacePath ? ` --add-dir ${shellQuote(toShellPath(workspacePath))}` : "";
+    const modelFlag = model ? ` --model ${model}` : "";
+    const effortFlag = effort ? ` --effort ${effort}` : "";
+    const library = opts?.library;
+    const libraryFlags = library ? ` --plugin-dir ${shellQuote(toShellPath(library.pluginDir))} --add-dir ${shellQuote(toShellPath(library.libraryDir))}` : "";
+    const flags = `--chrome${claudePermissionFlag(opts?.autoMode)}${modelFlag}${effortFlag}${settings}${addDir}${libraryFlags}`;
+    const sysFlag = systemPrompt ? ` --append-system-prompt ${shellQuote(systemPrompt)}` : "";
+    const promptArg = prompt ? ` ${shellQuote(prompt)}` : "";
+    const tail = `${flags}${sysFlag}${promptArg}`;
+    cmd = sessionId && opts?.resume ? claudeResumeOrFresh(sessionId, worktreePath, tail) : `claude ${sessionId ? `--session-id ${sessionId} ` : opts?.resume ? "--continue " : ""}${tail}\r`;
+  } else {
+    const combined = [systemPrompt, prompt].filter(Boolean).join("\n\n");
+    const codexEffortFlag = effort ? `-c ${shellQuote(`model_reasoning_effort="${effort}"`)} ` : "";
+    const codexHome = opts?.library ? `CODEX_HOME=${shellQuote(toShellPath(opts.library.codexHome))} ` : "";
+    const promptArg = combined ? ` ${shellQuote(combined)}` : "";
+    cmd = `${codexHome}codex ${codexAutoFlag(opts?.autoMode)}${codexEffortFlag}--model ${model}${promptArg}\r`;
+  }
+  if (cmd.length > 2e5) console.warn(`[VibeFlow] launch command is ${cmd.length} bytes \u2014 approaching ARG_MAX`);
+  return cmd;
+}
+var AGENT_NAMES = {
+  claude: "Claude Code",
+  codex: "Codex CLI"
+};
+var DEFAULT_MODELS = {
+  claude: "sonnet",
+  codex: "gpt-5.5"
+};
+var LEGACY_MODEL_FALLBACKS = {
+  codex: {
+    "gpt-5-codex": "gpt-5.5",
+    "gpt-5": "gpt-5.5"
+  }
+};
+function normalizeModel(agent, model) {
+  return LEGACY_MODEL_FALLBACKS[agent]?.[model] ?? model;
+}
+function taskAgent(task) {
+  const agent = task.agentCli;
+  return agent && agent in AGENT_NAMES ? agent : "claude";
+}
+function taskModel(task) {
+  const agent = taskAgent(task);
+  return normalizeModel(agent, task.model || DEFAULT_MODELS[agent]);
+}
+function buildAgentCommand(task, systemPrompt, opts, workspacePath) {
+  const agent = taskAgent(task);
+  const model = taskModel(task);
+  const artifactsDir = agentArtifactsDir(task.worktreePath, workspacePath) ?? ARTIFACTS_FALLBACK_DIR;
+  const builtInPrompt = buildArtifactPrompt(artifactsDir);
+  const libraryPrompt = opts?.library?.promptText?.trim();
+  const customPrompt = resolveSystemPrompt(systemPrompt);
+  const sys = [builtInPrompt, libraryPrompt, customPrompt].filter(Boolean).join("\n\n");
+  const includeTaskPrompt = opts?.includeTaskPrompt !== false;
+  const prompt = includeTaskPrompt && !opts?.resume ? buildPrompt(task) : "";
+  const sessionId = agent === "claude" && includeTaskPrompt ? executorSessionId(task.id, task.runId) : void 0;
+  return boardEnvPrefix(task, opts) + assembleCommand(
+    agent,
+    sys,
+    prompt,
+    model,
+    task.effort,
+    opts,
+    task.worktreePath,
+    sessionId,
+    workspacePath
+  );
+}
+
+// packages/core/src/git.ts
+init_env();
+init_attachments();
+
+// packages/core/src/artifacts.ts
+import fs7 from "fs";
+import path11 from "path";
+var ARTIFACTS_DIR_SUFFIX2 = ".artifacts";
+var SCRATCH_DIR_NAME2 = "scratch";
+var ARTIFACTS_FALLBACK_DIR2 = ".vibeflow-artifacts";
+var IMAGE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".svg": "image/svg+xml"
+};
+var VIDEO_MIME = {
+  ".mp4": "video/mp4",
+  ".m4v": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/mp4"
+};
+var MAX_VIDEO_BYTES = 20 * 1024 * 1024;
+var MAX_TEXT_BYTES = 256 * 1024;
+var MAX_DEPTH = 3;
+var MAX_ARTIFACTS = 200;
+var SNIFF_BYTES = 8 * 1024;
+function agentArtifactsPath(baseDir, worktreePath) {
+  return path11.join(baseDir, `${path11.basename(worktreePath)}${ARTIFACTS_DIR_SUFFIX2}`);
+}
+function mediaKind(filePath, size) {
+  const extension = path11.extname(filePath).toLowerCase();
+  const imageMime = IMAGE_MIME[extension];
+  if (imageMime) return { kind: "image", mime: imageMime };
+  const videoMime = VIDEO_MIME[extension];
+  if (videoMime) {
+    return size > MAX_VIDEO_BYTES ? { kind: "binary" } : { kind: "video", mime: videoMime };
+  }
+  return null;
+}
+function sniffKind(filePath) {
+  let fd;
+  try {
+    fd = fs7.openSync(filePath, "r");
+    const buf = Buffer.alloc(SNIFF_BYTES);
+    const read = fs7.readSync(fd, buf, 0, SNIFF_BYTES, 0);
+    return buf.subarray(0, read).includes(0) ? "binary" : "text";
+  } catch {
+    return "binary";
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs7.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function resolveInside(dir, name) {
+  let root;
+  let target;
+  try {
+    root = fs7.realpathSync(path11.resolve(dir));
+    target = fs7.realpathSync(path11.resolve(root, name));
+  } catch {
+    return null;
+  }
+  if (target !== root && !target.startsWith(root + path11.sep)) return null;
+  return target;
+}
+function listArtifacts(dir) {
+  const found2 = [];
+  const walk = (current, prefix, depth, scratch) => {
+    if (found2.length >= MAX_ARTIFACTS) return;
+    let dirents;
+    try {
+      dirents = fs7.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const dirent of dirents) {
+      if (found2.length >= MAX_ARTIFACTS) return;
+      const name = prefix ? `${prefix}/${dirent.name}` : dirent.name;
+      const full = path11.join(current, dirent.name);
+      if (dirent.isDirectory()) {
+        if (!scratch && depth === 1 && dirent.name === SCRATCH_DIR_NAME2) continue;
+        if (depth < MAX_DEPTH) walk(full, name, depth + 1, scratch);
+        continue;
+      }
+      if (!dirent.isFile()) continue;
+      let stat;
+      try {
+        stat = fs7.statSync(full);
       } catch {
         continue;
       }
@@ -2470,7 +2992,7 @@ function listArtifacts(dir) {
     }
   };
   walk(dir, "", 1, false);
-  walk(path11.join(dir, SCRATCH_DIR_NAME), SCRATCH_DIR_NAME, 2, true);
+  walk(path11.join(dir, SCRATCH_DIR_NAME2), SCRATCH_DIR_NAME2, 2, true);
   return found2.sort(
     (a, b) => Number(a.scratch) - Number(b.scratch) || b.modifiedAt - a.modifiedAt
   );
@@ -2637,7 +3159,13 @@ async function ensureLocalExclude(projectPath) {
   );
   await appendLineIfMissing(
     path12.join(infoDir, "exclude"),
-    `${ARTIFACTS_FALLBACK_DIR}/`,
+    `${PROGRESS_EVENTS_DIR}/`,
+    "# VibeFlow progress hook events (runtime-only)",
+    { mkdir: true }
+  );
+  await appendLineIfMissing(
+    path12.join(infoDir, "exclude"),
+    `${ARTIFACTS_FALLBACK_DIR2}/`,
     "# VibeFlow task artifacts (runtime-only)",
     { mkdir: true }
   );
@@ -2727,7 +3255,7 @@ async function resolveBranchName(projectPath, workspacePath, taskId, preferredBr
   }
   return preferredBranch;
 }
-var RUNTIME_ARTIFACT_DENYLIST = /* @__PURE__ */ new Set([SUBAGENTS_DIR]);
+var RUNTIME_ARTIFACT_DENYLIST = /* @__PURE__ */ new Set([SUBAGENTS_DIR, PROGRESS_EVENTS_DIR]);
 var MAX_IGNORED_COPY_BYTES = 10 * 1024 * 1024;
 var MAX_IGNORED_COPY_FILES = 200;
 var HEAVY_IGNORED_DIR_NAMES = /* @__PURE__ */ new Set([
@@ -2998,7 +3526,7 @@ async function resetWorktreeToBase(worktreePath, baseBranch) {
   const baseRef = await resolveBaseRef(worktreePath, baseBranch);
   await git(worktreePath, ["reset", "--hard", baseRef]);
   await git(worktreePath, ["clean", "-fd"]);
-  await fs8.rm(path12.join(worktreePath, ARTIFACTS_FALLBACK_DIR), {
+  await fs8.rm(path12.join(worktreePath, ARTIFACTS_FALLBACK_DIR2), {
     recursive: true,
     force: true
   });
@@ -3082,7 +3610,9 @@ async function collectDiffEntries(worktreePath, baseRef) {
     }
   }
   const entries = Array.from(entryMap.values()).filter(
-    (e) => e.path !== SUBAGENTS_DIR && !e.path.startsWith(`${SUBAGENTS_DIR}/`)
+    (e) => ![SUBAGENTS_DIR, PROGRESS_EVENTS_DIR].some(
+      (dir) => e.path === dir || e.path.startsWith(`${dir}/`)
+    )
   );
   await Promise.all(
     entries.map(async (entry) => {
@@ -3465,7 +3995,8 @@ async function provisionTaskWorktree(task) {
       branch: result.branch,
       worktreePath: result.worktreePath,
       baseBranch: result.baseBranch,
-      pushed: result.pushed
+      pushed: result.pushed,
+      provisionedAt: Date.now()
     };
   } catch (err) {
     throw Object.assign(
@@ -3713,8 +4244,8 @@ async function taskCommand(argv) {
 }
 
 // packages/cli/src/host.ts
-import fs18 from "fs";
-import path22 from "path";
+import fs19 from "fs";
+import path23 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // packages/core/src/events.ts
@@ -4252,9 +4783,9 @@ async function syncBuiltinsAtStartup() {
 }
 
 // packages/core/src/service.ts
-import fs16 from "fs";
-import os5 from "os";
-import path20 from "path";
+import fs17 from "fs";
+import os6 from "os";
+import path21 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // packages/core/src/agent-models.ts
@@ -4888,176 +5419,288 @@ function startChatSend(opts, sender) {
 // packages/core/src/service.ts
 init_attachments();
 
-// packages/core/src/launch.ts
-var ARTIFACTS_DIR_SUFFIX2 = ".artifacts";
-var SCRATCH_DIR_NAME2 = "scratch";
-var ARTIFACTS_FALLBACK_DIR2 = ".vibeflow-artifacts";
-function pathBasename(p) {
-  const norm = p.replace(/\\/g, "/").replace(/\/+$/, "");
-  const i = norm.lastIndexOf("/");
-  return i >= 0 ? norm.slice(i + 1) : norm;
-}
-function agentArtifactsDir(worktreePath, workspacePath) {
-  if (!worktreePath || !workspacePath) return null;
-  const dir = toShellPath(workspacePath);
-  const ws = pathBasename(worktreePath);
-  return `${dir}/${ws}${ARTIFACTS_DIR_SUFFIX2}`;
-}
-function buildArtifactPrompt(artifactsDir = ARTIFACTS_FALLBACK_DIR2) {
-  return [
-    "Artifact \u8A2D\u5B9A\uFF08\u672C\u6B21 session \u5168\u7A0B\u9069\u7528\uFF09\uFF1A",
-    `1. \u672C\u4EFB\u52D9\u7684 Artifact \u8CC7\u6599\u593E\u662F ${artifactsDir}/\uFF1B\u9700\u8981\u4FDD\u5B58\u7D66\u4F7F\u7528\u8005\u7684\u9A57\u8B49\u8B49\u64DA\u6216\u5831\u544A\u6642\uFF0C\u8ACB\u5BEB\u5165\u6B64\u8CC7\u6599\u593E\uFF08\u4E0D\u5B58\u5728\u8ACB\u5EFA\u7ACB\uFF09\u3002`,
-    `2. \u4F7F\u7528\u8005\u6703\u5728 VibeFlow \u7684 Artifacts \u5206\u9801\u6AA2\u8996\u6839\u76EE\u9304\u5167\u5BB9\uFF1B\u53EA\u653E\u4F60\u6703\u4E3B\u52D5\u8ACB\u4F7F\u7528\u8005\u904E\u76EE\u7684\u6A94\u6848\u3002`,
-    `3. \u4F60\u81EA\u5DF1\u7684\u5DE5\u4F5C\u66AB\u5B58\uFF08\u4E00\u6B21\u6027 script\u3001log\u3001\u4E2D\u9593\u8F38\u51FA\u3001debug \u6A94\uFF09\u653E\u5728 ${artifactsDir}/${SCRATCH_DIR_NAME2}/\u3002`,
-    `4. \u82E5\u5DE5\u5177\u5148\u8F38\u51FA\u5230 /tmp\u3001/private/tmp\u3001$TMPDIR \u6216 ~/Downloads\uFF0C\u8ACB\u628A\u6700\u7D42\u8981\u5448\u73FE\u7684\u6A94\u6848\u8907\u88FD\u5230 ${artifactsDir}/ \u4E26\u78BA\u8A8D\u5B58\u5728\u3002`,
-    "5. Artifact \u8CC7\u6599\u593E\u4F4D\u65BC worktree \u4E4B\u5916\uFF1B\u4E0D\u8981\u628A\u5176\u4E2D\u5167\u5BB9\u52A0\u5165 git commit\uFF0C\u4E5F\u4E0D\u8981\u628A\u6700\u7D42\u4EA4\u4ED8\u7269\u53EA\u7559\u5728\u9019\u88E1\u3002"
-  ].join("\n");
-}
-var AUTO_PERMISSION_MODE = "auto";
-function claudePermissionFlag(autoMode) {
-  return autoMode ? ` --permission-mode ${AUTO_PERMISSION_MODE}` : "";
-}
-function shellQuote(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-function toShellPath(p) {
-  return p.replace(/\\/g, "/");
-}
-function boardEnvPrefix(task, opts) {
-  const board = opts?.boardCli;
-  if (!board) return "";
-  const entries = [
-    ["VIBEFLOW_TASK_ID", task.id],
-    ["VIBEFLOW_PROJECT_PATH", task.projectPath],
-    ["VIBEFLOW_BRANCH", task.branch],
-    ["VIBEFLOW_BASE_BRANCH", task.baseBranch],
-    ["VIBEFLOW_STORE_DIR", board?.storeDir],
-    ["VIBEFLOW_CLI", board?.cliPath],
-    ["VIBEFLOW_CLI_LOADER", board?.loaderPath],
-    ["VIBEFLOW_AUTO_MODE", opts?.autoMode ? "1" : "0"]
-  ];
-  const exports = entries.filter((entry) => Boolean(entry[1])).map(([key, value]) => `${key}=${shellQuote(toShellPath(value))}`);
-  return exports.length ? `export ${exports.join(" ")}; ` : "";
+// packages/core/src/progress-tracker.ts
+init_progress();
+import fs16 from "fs";
+import os5 from "os";
+import path20 from "path";
+var SINCE_SLACK_MS = 5e3;
+function claudeProjectDir(home, cwd) {
+  return path20.join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+}
+function samePath(a, b) {
+  const norm = (p) => {
+    const r = path20.resolve(p).replace(/\\/g, "/").replace(/\/+$/, "");
+    return process.platform === "win32" ? r.toLowerCase() : r;
+  };
+  return norm(a) === norm(b);
 }
-function codexAutoFlag(autoMode) {
-  return autoMode ? "--dangerously-bypass-approvals-and-sandbox " : "";
+function listFiles(dir, test) {
+  try {
+    return fs16.readdirSync(dir).filter(test).map((name) => path20.join(dir, name));
+  } catch {
+    return [];
+  }
 }
-function claudeResumeOrFresh(sessionId, worktreePath, tail) {
-  if (!worktreePath) return `claude --resume ${sessionId} ${tail}\r`;
-  const munged = worktreePath.replace(/[^a-zA-Z0-9]/g, "-");
-  const sessionFile = `"$HOME/.claude/projects/${munged}/${sessionId}.jsonl"`;
-  return `if [ -f ${sessionFile} ]; then claude --resume ${sessionId} ${tail}; else claude --session-id ${sessionId} ${tail}; fi\r`;
+function firstLine(file) {
+  let fd;
+  try {
+    fd = fs16.openSync(file, "r");
+    const buf = Buffer.alloc(64 * 1024);
+    const n = fs16.readSync(fd, buf, 0, buf.length, 0);
+    const text = buf.subarray(0, n).toString("utf8");
+    const nl = text.indexOf("\n");
+    return nl === -1 ? null : text.slice(0, nl);
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) fs16.closeSync(fd);
+  }
 }
-var SUBAGENTS_DIR2 = ".vibeflow-subagents";
-function buildClaudeSettings(worktreePath) {
-  const settings = { theme: "dark" };
-  if (worktreePath) {
-    const dir = `${toShellPath(worktreePath)}/${SUBAGENTS_DIR2}`;
-    const command = `mkdir -p "${dir}" && cat > "${dir}/$(date +%s)-$$-$RANDOM.json"`;
-    const taskHook = {
-      matcher: "Task",
-      hooks: [{ type: "command", command }]
+function advance(file, cursor, reduce, initial) {
+  let size;
+  try {
+    size = fs16.statSync(file).size;
+  } catch {
+    return;
+  }
+  if (size < cursor.offset) {
+    cursor.offset = 0;
+    cursor.rest = Buffer.alloc(0);
+    cursor.state = initial();
+  }
+  if (size === cursor.offset) return;
+  let fd;
+  try {
+    fd = fs16.openSync(file, "r");
+    const chunk = Buffer.alloc(size - cursor.offset);
+    const n = fs16.readSync(fd, chunk, 0, chunk.length, cursor.offset);
+    cursor.offset += n;
+    const data = Buffer.concat([cursor.rest, chunk.subarray(0, n)]);
+    const nl = data.lastIndexOf(10);
+    if (nl === -1) {
+      cursor.rest = data;
+      return;
+    }
+    cursor.rest = data.subarray(nl + 1);
+    for (const line of data.subarray(0, nl).toString("utf8").split("\n")) {
+      if (line.trim()) cursor.state = reduce(cursor.state, line);
+    }
+  } catch {
+  } finally {
+    if (fd !== void 0) fs16.closeSync(fd);
+  }
+}
+function newCursor(state) {
+  return { offset: 0, rest: Buffer.alloc(0), state };
+}
+function codexDayDirs(sessionsRoot, since) {
+  const days = [];
+  const end = /* @__PURE__ */ new Date();
+  const start = since != null ? new Date(since - 24 * 36e5) : null;
+  if (!start) {
+    for (const y of listFiles(sessionsRoot, () => true))
+      for (const m of listFiles(y, () => true))
+        for (const d of listFiles(m, () => true)) days.push(d);
+    return days;
+  }
+  const cur = new Date(start.getFullYear(), start.getMonth(), start.getDate());
+  while (cur <= end) {
+    const pad = (n) => String(n).padStart(2, "0");
+    days.push(path20.join(sessionsRoot, String(cur.getFullYear()), pad(cur.getMonth() + 1), pad(cur.getDate())));
+    cur.setDate(cur.getDate() + 1);
+  }
+  return days;
+}
+function createProgressTracker(opts) {
+  const home = opts.homeDir ?? os5.homedir();
+  const codexHomes = opts.codexHomes ?? (() => [path20.join(home, ".codex")]);
+  const pollMs = opts.pollMs ?? 2e3;
+  const entries = /* @__PURE__ */ new Map();
+  const belongsToRun = (target, startedAt) => target.since == null || startedAt != null && startedAt >= target.since - SINCE_SLACK_MS;
+  function discoverClaude(entry) {
+    const { target } = entry;
+    const dir = claudeProjectDir(home, target.worktreePath);
+    for (const file of listFiles(dir, (n) => n.endsWith(".jsonl"))) {
+      if (entry.claude.has(file) || entry.rejected.has(file)) continue;
+      const session = path20.basename(file, ".jsonl");
+      if (session !== target.sessionId) {
+        const head = firstLine(file);
+        if (head == null) continue;
+        const started = reduceClaudeLine(initialClaudeState(), head).startedAt;
+        if (!belongsToRun(target, started)) {
+          entry.rejected.add(file);
+          continue;
+        }
+      }
+      entry.claude.set(file, newCursor(initialClaudeState()));
+    }
+    for (const file of Array.from(entry.claude.keys())) {
+      if (file.includes(`${path20.sep}subagents${path20.sep}`)) continue;
+      const sub = path20.join(file.slice(0, -".jsonl".length), "subagents");
+      for (const f of listFiles(sub, (n) => n.endsWith(".jsonl"))) {
+        if (!entry.claude.has(f)) entry.claude.set(f, newCursor(initialClaudeState()));
+      }
+    }
+  }
+  function discoverCodex(entry) {
+    const { target } = entry;
+    for (const codexHome of codexHomes()) {
+      for (const day of codexDayDirs(path20.join(codexHome, "sessions"), target.since)) {
+        for (const file of listFiles(day, (n) => n.startsWith("rollout-") && n.endsWith(".jsonl"))) {
+          if (entry.codex.has(file) || entry.rejected.has(file)) continue;
+          const head = firstLine(file);
+          if (head == null) continue;
+          const meta = reduceCodexLine(initialCodexState(), head);
+          if (!meta.cwd) continue;
+          if (!samePath(meta.cwd, target.worktreePath) || !belongsToRun(target, meta.startedAt)) {
+            entry.rejected.add(file);
+            continue;
+          }
+          entry.codex.set(file, newCursor(initialCodexState()));
+        }
+      }
+    }
+  }
+  function drainHooks(entry) {
+    const dir = path20.join(entry.target.worktreePath, PROGRESS_EVENTS_DIR);
+    for (const file of listFiles(dir, (n) => n.endsWith(".json")).sort()) {
+      try {
+        const at = fs16.statSync(file).mtimeMs;
+        const event = JSON.parse(fs16.readFileSync(file, "utf8"));
+        const foreign = entry.target.sessionId && typeof event.session_id === "string" && event.session_id !== entry.target.sessionId;
+        const activity = foreign ? null : activityFromHook(event, at);
+        if (activity) entry.hookActivity = latestActivity(entry.hookActivity ?? activity, activity);
+      } catch {
+        continue;
+      }
+      try {
+        fs16.unlinkSync(file);
+      } catch {
+      }
+    }
+  }
+  function compose(entry) {
+    const { target } = entry;
+    let runUsage = emptyUsage();
+    let primary = null;
+    if (target.agent === "claude") {
+      for (const [file, cursor] of entry.claude) {
+        runUsage = addUsage(runUsage, claudeUsageTotal(cursor.state));
+        if (file.includes(`${path20.sep}subagents${path20.sep}`)) continue;
+        const isExecutor = path20.basename(file, ".jsonl") === target.sessionId;
+        const s = cursor.state;
+        if (isExecutor || !target.sessionId && (!primary || (s.startedAt ?? 0) > (primary.startedAt ?? 0))) {
+          primary = { todos: s.todos, contextTokens: s.contextTokens, activity: s.activity, startedAt: s.startedAt };
+        }
+      }
+    } else {
+      for (const cursor of entry.codex.values()) {
+        const s = cursor.state;
+        runUsage = addUsage(runUsage, s.usage);
+        if (!primary || (s.startedAt ?? 0) >= (primary.startedAt ?? 0)) {
+          primary = { todos: s.todos, contextTokens: s.contextTokens, activity: s.activity, startedAt: s.startedAt };
+        }
+      }
+    }
+    if (!primary) return null;
+    const hook = entry.hookActivity;
+    const activity = hook?.state === "working" && primary.activity.state === "working" ? primary.activity : latestActivity(primary.activity, hook);
+    return {
+      todos: primary.todos,
+      runUsage,
+      totalUsage: addUsage(target.priorUsage ?? emptyUsage(), runUsage),
+      ...primary.contextTokens != null ? { contextTokens: primary.contextTokens } : {},
+      activity
     };
-    settings.hooks = { PreToolUse: [taskHook], PostToolUse: [taskHook] };
   }
-  return JSON.stringify(settings);
-}
-function resolveSystemPrompt(custom) {
-  return custom && custom.trim() ? custom : "";
-}
-function buildPrompt(task) {
-  const lines = [`\u4EFB\u52D9\u6A19\u984C\uFF1A${task.title}`];
-  const description = task.description?.trim();
-  if (description) {
-    lines.push("", "\u4EFB\u52D9\u63CF\u8FF0\uFF1A", description);
+  function sync(entry) {
+    drainHooks(entry);
+    if (entry.target.agent === "claude") {
+      discoverClaude(entry);
+      for (const [file, cursor] of entry.claude) advance(file, cursor, reduceClaudeLine, initialClaudeState);
+    } else {
+      discoverCodex(entry);
+      for (const [file, cursor] of entry.codex) advance(file, cursor, reduceCodexLine, initialCodexState);
+    }
+    const next = compose(entry);
+    if (!next) return null;
+    const json = JSON.stringify(next);
+    if (json !== entry.lastJson) {
+      const notifications = diffProgress(entry.last, next);
+      entry.last = next;
+      entry.lastJson = json;
+      opts.onUpdate(entry.target.taskId, next);
+      if (notifications.length) opts.onNotify(entry.target.taskId, notifications);
+    }
+    return next;
   }
-  return lines.join("\n");
-}
-function executorSessionId(taskId, runId) {
-  const source = runId ? `${taskId}:${runId}` : taskId;
-  const raw = source.replace(/[^0-9a-f]/gi, "").toLowerCase();
-  const hex = runId ? `${raw.slice(0, 24).padEnd(24, "0")}${namespaceHash(`executor:${source}`)}` : raw.padEnd(32, "0").slice(0, 32);
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
-}
-function namespaceHash(namespace) {
-  let hash = 2166136261;
-  for (let i = 0; i < namespace.length; i += 1) {
-    hash ^= namespace.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
+  function safeSync(entry) {
+    try {
+      return sync(entry);
+    } catch {
+      return entry.last ?? null;
+    }
   }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function assembleCommand(agent, systemPrompt, prompt, model, effort, opts, worktreePath, sessionId, workspacePath) {
-  let cmd;
-  if (agent === "claude") {
-    const settings = ` --settings ${shellQuote(buildClaudeSettings(worktreePath))}`;
-    const addDir = workspacePath ? ` --add-dir ${shellQuote(toShellPath(workspacePath))}` : "";
-    const modelFlag = model ? ` --model ${model}` : "";
-    const effortFlag = effort ? ` --effort ${effort}` : "";
-    const library = opts?.library;
-    const libraryFlags = library ? ` --plugin-dir ${shellQuote(toShellPath(library.pluginDir))} --add-dir ${shellQuote(toShellPath(library.libraryDir))}` : "";
-    const flags = `--chrome${claudePermissionFlag(opts?.autoMode)}${modelFlag}${effortFlag}${settings}${addDir}${libraryFlags}`;
-    const sysFlag = systemPrompt ? ` --append-system-prompt ${shellQuote(systemPrompt)}` : "";
-    const promptArg = prompt ? ` ${shellQuote(prompt)}` : "";
-    const tail = `${flags}${sysFlag}${promptArg}`;
-    cmd = sessionId && opts?.resume ? claudeResumeOrFresh(sessionId, worktreePath, tail) : `claude ${sessionId ? `--session-id ${sessionId} ` : opts?.resume ? "--continue " : ""}${tail}\r`;
-  } else {
-    const combined = [systemPrompt, prompt].filter(Boolean).join("\n\n");
-    const codexEffortFlag = effort ? `-c ${shellQuote(`model_reasoning_effort="${effort}"`)} ` : "";
-    const codexHome = opts?.library ? `CODEX_HOME=${shellQuote(toShellPath(opts.library.codexHome))} ` : "";
-    const promptArg = combined ? ` ${shellQuote(combined)}` : "";
-    cmd = `${codexHome}codex ${codexAutoFlag(opts?.autoMode)}${codexEffortFlag}--model ${model}${promptArg}\r`;
+  function stop(entry) {
+    clearInterval(entry.timer);
+    if (entry.pending) clearTimeout(entry.pending);
+    entry.watcher?.close();
   }
-  if (cmd.length > 2e5) console.warn(`[VibeFlow] launch command is ${cmd.length} bytes \u2014 approaching ARG_MAX`);
-  return cmd;
-}
-var AGENT_NAMES = {
-  claude: "Claude Code",
-  codex: "Codex CLI"
-};
-var DEFAULT_MODELS = {
-  claude: "sonnet",
-  codex: "gpt-5.5"
-};
-var LEGACY_MODEL_FALLBACKS = {
-  codex: {
-    "gpt-5-codex": "gpt-5.5",
-    "gpt-5": "gpt-5.5"
+  function sameTarget(a, b) {
+    return a.agent === b.agent && a.worktreePath === b.worktreePath && a.sessionId === b.sessionId && a.since === b.since && JSON.stringify(a.priorUsage ?? null) === JSON.stringify(b.priorUsage ?? null);
   }
-};
-function normalizeModel(agent, model) {
-  return LEGACY_MODEL_FALLBACKS[agent]?.[model] ?? model;
-}
-function taskAgent(task) {
-  const agent = task.agentCli;
-  return agent && agent in AGENT_NAMES ? agent : "claude";
-}
-function taskModel(task) {
-  const agent = taskAgent(task);
-  return normalizeModel(agent, task.model || DEFAULT_MODELS[agent]);
-}
-function buildAgentCommand(task, systemPrompt, opts, workspacePath) {
-  const agent = taskAgent(task);
-  const model = taskModel(task);
-  const artifactsDir = agentArtifactsDir(task.worktreePath, workspacePath) ?? ARTIFACTS_FALLBACK_DIR2;
-  const builtInPrompt = buildArtifactPrompt(artifactsDir);
-  const libraryPrompt = opts?.library?.promptText?.trim();
-  const customPrompt = resolveSystemPrompt(systemPrompt);
-  const sys = [builtInPrompt, libraryPrompt, customPrompt].filter(Boolean).join("\n\n");
-  const includeTaskPrompt = opts?.includeTaskPrompt !== false;
-  const prompt = includeTaskPrompt && !opts?.resume ? buildPrompt(task) : "";
-  const sessionId = agent === "claude" && includeTaskPrompt ? executorSessionId(task.id, task.runId) : void 0;
-  return boardEnvPrefix(task, opts) + assembleCommand(
-    agent,
-    sys,
-    prompt,
-    model,
-    task.effort,
-    opts,
-    task.worktreePath,
-    sessionId,
-    workspacePath
-  );
+  return {
+    track(target) {
+      const existing = entries.get(target.taskId);
+      if (existing && sameTarget(existing.target, target)) return;
+      if (existing) stop(existing);
+      const entry = {
+        target,
+        claude: /* @__PURE__ */ new Map(),
+        codex: /* @__PURE__ */ new Map(),
+        rejected: /* @__PURE__ */ new Set(),
+        hookActivity: null,
+        timer: setInterval(() => safeSync(entry), pollMs),
+        watcher: null,
+        pending: null
+      };
+      entry.timer.unref?.();
+      entries.set(target.taskId, entry);
+      const eventsDir = path20.join(target.worktreePath, PROGRESS_EVENTS_DIR);
+      try {
+        fs16.mkdirSync(eventsDir, { recursive: true });
+        entry.watcher = fs16.watch(eventsDir, () => {
+          if (entry.pending) return;
+          entry.pending = setTimeout(() => {
+            entry.pending = null;
+            safeSync(entry);
+          }, 50);
+        });
+        entry.watcher.on("error", () => entry.watcher?.close());
+        entry.watcher.unref?.();
+      } catch {
+      }
+      safeSync(entry);
+    },
+    untrack(taskId) {
+      const entry = entries.get(taskId);
+      if (!entry) return;
+      stop(entry);
+      entries.delete(taskId);
+    },
+    untrackAll() {
+      for (const entry of entries.values()) stop(entry);
+      entries.clear();
+    },
+    snapshot(taskId) {
+      const entry = entries.get(taskId);
+      return entry ? safeSync(entry) : null;
+    },
+    isTracking(taskId) {
+      return entries.has(taskId);
+    }
+  };
 }
 
 // packages/core/src/service.ts
@@ -5112,8 +5755,61 @@ function validBoard(value) {
   }
   return next;
 }
-function createCore({ sessions, bus, version }) {
+function createCore({ sessions, bus, version, homeDir }) {
   const sink = bus.sink();
+  let libraryCodexHome = null;
+  void libraryRoot().then((root) => {
+    libraryCodexHome = libraryPaths(root).codexHome;
+  }).catch(() => {
+  });
+  const home = homeDir ?? os6.homedir();
+  const progress = createProgressTracker({
+    homeDir: home,
+    codexHomes: () => [path21.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
+    onUpdate: (taskId, value) => bus.emit("progress:update", { taskId, progress: value }),
+    onNotify: (taskId, list) => {
+      const prefs = resolveNotificationSettings(getSettings());
+      if (!prefs.enabled) return;
+      const wanted = {
+        step_completed: prefs.stepCompleted,
+        all_completed: prefs.allCompleted,
+        waiting_input: prefs.waitingInput
+      };
+      const notifications = list.filter((n) => wanted[n.kind]);
+      const task = findTask(taskId);
+      if (!task || !notifications.length) return;
+      bus.emit("progress:notify", { taskId, title: task.title, notifications });
+    }
+  });
+  function progressTarget(task) {
+    if (!task.worktreePath) return null;
+    const agent = taskAgent(task);
+    return {
+      taskId: task.id,
+      agent,
+      worktreePath: task.worktreePath,
+      sessionId: agent === "claude" ? executorSessionId(task.id, task.runId) : void 0,
+      since: task.launchedAt,
+      priorUsage: task.usage
+    };
+  }
+  function trackProgress(task) {
+    const target = progressTarget(task);
+    if (target) progress.track(target);
+  }
+  function usageThroughCurrentRun(task) {
+    const target = progressTarget(task);
+    if (!target) return task.usage;
+    const wasTracking = progress.isTracking(task.id);
+    progress.track(target);
+    const snapshot = progress.snapshot(task.id);
+    if (!wasTracking) progress.untrack(task.id);
+    return snapshot?.totalUsage ?? task.usage;
+  }
+  try {
+    for (const task of getState().board.in_progress) trackProgress(task);
+  } catch {
+  }
   async function teardownSession(key) {
     await sessions.kill(key);
     unwatchSubAgents(key);
@@ -5152,13 +5848,13 @@ function createCore({ sessions, bus, version }) {
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path20.join(os5.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path21.join(os6.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 ?? path20.dirname(task.worktreePath), task.worktreePath);
+    deleteArtifacts(task.workspacePath ?? path21.dirname(task.worktreePath), task.worktreePath);
     await deleteBranch(task.projectPath, branch);
   }
   function columnOf(taskId) {
@@ -5203,6 +5899,17 @@ function createCore({ sessions, bus, version }) {
   let folderDialog = null;
   const handlers = {
     "vibeflow:getState": () => getState(),
+    // A card's progress right now (todo list, usage, activity), for a frontend
+    // that just connected; 'progress:update' carries every later change. Null
+    // when the card has no transcript yet or is not running.
+    "progress:get": (taskId) => {
+      const task = requireTask(taskId);
+      if (!progress.isTracking(task.id)) {
+        if (columnOf(task.id) !== "in_progress") return null;
+        trackProgress(task);
+      }
+      return progress.snapshot(task.id);
+    },
     "app:getVersion": () => version,
     "vibeflow:setBoard": (board) => {
       setBoard(validBoard(board));
@@ -5237,8 +5944,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 = path20.resolve(str(projectPath, "projectPath"));
-      if (!fs16.existsSync(p) || !fs16.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
+      const p = path21.resolve(str(projectPath, "projectPath"));
+      if (!fs17.existsSync(p) || !fs17.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
       recordRecentProject(getStore(), p);
       return listRecentProjects(getStore());
     },
@@ -5265,7 +5972,9 @@ function createCore({ sessions, bus, version }) {
       return { state: getState(), task };
     },
     "vibeflow:removeTask": (taskId) => {
-      removeTask(requireTask(taskId).id);
+      const id = requireTask(taskId).id;
+      progress.untrack(id);
+      removeTask(id);
       return getState();
     },
     // Discard everything the last run left behind — the PTY session, the
@@ -5276,6 +5985,7 @@ function createCore({ sessions, bus, version }) {
       const task = requireTask(taskId);
       if (!task.worktreePath) {
         await teardownTask(task.id);
+        progress.untrack(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");
@@ -5284,11 +5994,13 @@ function createCore({ sessions, bus, version }) {
       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 ?? path20.dirname(task.worktreePath);
+      const workspacePath = task.workspacePath ?? path21.dirname(task.worktreePath);
       deleteArtifacts(workspacePath, task.worktreePath);
       deleteDecisions(workspacePath, decisionsKey(task.worktreePath, task.branch));
       resetSubAgents(task.worktreePath);
-      updateTask(task.id, { launchedAt: Date.now(), runId: randomUUID4() });
+      const usage = usageThroughCurrentRun(task);
+      progress.untrack(task.id);
+      updateTask(task.id, { launchedAt: Date.now(), runId: randomUUID4(), ...usage ? { usage } : {} });
       const reset = findTask(task.id);
       if (!reset) throw new Error("\u627E\u4E0D\u5230\u8981\u91CD\u7F6E\u7684\u4EFB\u52D9");
       bus.emit("subagents:update", { taskId: task.id, subAgents: [] });
@@ -5325,7 +6037,7 @@ function createCore({ sessions, bus, version }) {
         }
         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 projectName = path21.basename(nextProject);
         const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
         await teardownTask(existing.id);
         await removeTaskWorktree(existing);
@@ -5339,6 +6051,7 @@ function createCore({ sessions, bus, version }) {
           ...branchChanged ? { branch: nextBranch, branchExplicit: true } : {},
           worktreePath: void 0,
           pushed: void 0,
+          provisionedAt: void 0,
           launchedAt: void 0
         };
       }
@@ -5387,6 +6100,10 @@ function createCore({ sessions, bus, version }) {
       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;
     },
     // Join a session as it is: no restart, for a frontend that attaches
@@ -5414,7 +6131,7 @@ function createCore({ sessions, bus, version }) {
     "claude:sessionExists": (taskId) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return false;
-      return fs16.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
+      return fs17.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
     },
     "sessions:list": async () => {
       const keys = await sessions.list();
@@ -5461,16 +6178,17 @@ 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 (!fs16.existsSync(dir)) return "artifacts directory does not exist yet";
+      if (!fs17.existsSync(dir)) return "artifacts directory does not exist yet";
       return getPlatform().openPath(dir);
     },
     "task:getSpecs": async (taskId) => {
       const task = requireTask(taskId);
       const base = task.baseBranch ?? "main";
       if (task.worktreePath) return readWorktreeSpecs(task.worktreePath, base);
-      if (!task.projectPath || !task.launchedAt) return [];
+      const since = task.provisionedAt ?? task.launchedAt ?? (task.pushed !== void 0 ? task.createdAt : void 0);
+      if (!task.projectPath || !since) return [];
       const changed = task.outcome?.files.filter((f) => f.status !== "D").map((f) => f.path);
-      return readBranchSpecs(task.projectPath, task.branch, base, changed, task.launchedAt);
+      return readBranchSpecs(task.projectPath, task.branch, base, changed, since);
     },
     "board:getCliLaunchInfo": () => boardCliLaunchInfo(),
     "library:list": async () => listLibrary(await libraryRoot(), builtinSkillsDir()),
@@ -5570,24 +6288,31 @@ function createCore({ sessions, bus, version }) {
       if (task.worktreePath) {
         outcome = await captureTaskOutcome(task.worktreePath, task.baseBranch ?? "main") ?? void 0;
       }
+      const usage = usageThroughCurrentRun(task);
+      progress.untrack(task.id);
       if (task.projectPath && task.worktreePath) {
         await removeTaskWorktree(task);
         await syncBaseBranch(task.projectPath, task.baseBranch ?? "main");
       }
-      updateTask(task.id, outcome ? { worktreePath: void 0, outcome } : { worktreePath: void 0 });
+      updateTask(task.id, {
+        worktreePath: void 0,
+        ...outcome ? { outcome } : {},
+        ...usage ? { usage } : {}
+      });
       return getState();
     },
     // Delete: cleanup (PTY + worktree) AND drop the card from the board.
     "vibeflow:deleteTask": async (taskId) => {
       const task = requireTask(taskId);
       await teardownTask(task.id);
+      progress.untrack(task.id);
       cancelChatSend(task.id);
       if (task.workspacePath) {
         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 });
+        fs17.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
       }
       clearConversation(task.id);
       removeTask(task.id);
@@ -5640,9 +6365,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 = path20.basename(getStorePath());
+      const file = path21.basename(getStorePath());
       let debounce = null;
-      storeWatcher = fs16.watch(path20.dirname(getStorePath()), (_event, filename) => {
+      storeWatcher = fs17.watch(path21.dirname(getStorePath()), (_event, filename) => {
         if (filename !== file) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -5658,6 +6383,7 @@ function createCore({ sessions, bus, version }) {
       sessions.shutdown();
       cancelAllChatSends();
       unwatchAllSubAgents();
+      progress.untrackAll();
       storeWatcher?.close();
     }
   };
@@ -5674,9 +6400,9 @@ function createSessionBackend(sink, choice) {
 }
 
 // packages/core/src/web-server.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import http from "http";
-import path21 from "path";
+import path22 from "path";
 import { timingSafeEqual } from "crypto";
 import { WebSocketServer } from "ws";
 var TOKEN_COOKIE = "vf_token";
@@ -5729,14 +6455,14 @@ function resolveStatic(root, urlPath) {
     return null;
   }
   if (decoded.includes("\0")) return null;
-  const rel = path21.posix.normalize(decoded).replace(/^\/+/, "");
-  const base = path21.resolve(root);
-  const candidates = [rel, path21.posix.join(rel, "index.html"), `${rel}.html`];
+  const rel = path22.posix.normalize(decoded).replace(/^\/+/, "");
+  const base = path22.resolve(root);
+  const candidates = [rel, path22.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path21.resolve(base, c);
-    if (full !== base && !full.startsWith(base + path21.sep)) return null;
+    const full = path22.resolve(base, c);
+    if (full !== base && !full.startsWith(base + path22.sep)) return null;
     try {
-      if (fs17.statSync(full).isFile()) return full;
+      if (fs18.statSync(full).isFile()) return full;
     } catch {
     }
   }
@@ -5797,7 +6523,7 @@ async function startWebServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const ext = path21.extname(file).toLowerCase();
+    const ext = path22.extname(file).toLowerCase();
     const immutable = url.pathname.startsWith("/_next/static/");
     res.writeHead(200, {
       "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream",
@@ -5810,7 +6536,7 @@ async function startWebServer(options) {
       res.end();
       return;
     }
-    fs17.createReadStream(file).pipe(res);
+    fs18.createReadStream(file).pipe(res);
   }
   const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
   function reject(socket, status, reason) {
@@ -5982,7 +6708,7 @@ function loginUrl(lock, pathname = "/home/") {
   return `http://127.0.0.1:${lock.port}${pathname}?token=${encodeURIComponent(lock.token)}`;
 }
 function isWebDir(dir) {
-  return fs18.existsSync(path22.join(dir, "home", "index.html"));
+  return fs19.existsSync(path23.join(dir, "home", "index.html"));
 }
 
 // packages/cli/src/remote.ts
@@ -6099,8 +6825,8 @@ function connectToHost(lock) {
 }
 
 // packages/cli/src/doctor.ts
-import fs19 from "fs";
-import path23 from "path";
+import fs20 from "fs";
+import path24 from "path";
 import { execFile as execFile8 } from "child_process";
 import { promisify as promisify5 } from "util";
 init_env();
@@ -6240,10 +6966,10 @@ async function runDoctor(options) {
     });
   }
   try {
-    fs19.mkdirSync(options.userDataDir, { recursive: true });
-    const probe = path23.join(options.userDataDir, `.doctor-${process.pid}`);
-    fs19.writeFileSync(probe, "");
-    fs19.rmSync(probe);
+    fs20.mkdirSync(options.userDataDir, { recursive: true });
+    const probe = path24.join(options.userDataDir, `.doctor-${process.pid}`);
+    fs20.writeFileSync(probe, "");
+    fs20.rmSync(probe);
     checks.push({ id: "data", name: "\u8CC7\u6599\u76EE\u9304", level: "ok", detail: options.userDataDir });
   } catch (err) {
     checks.push({
@@ -6297,24 +7023,24 @@ Options:
 `.trim();
 function detectLayout() {
   const file = fileURLToPath(import.meta.url);
-  const here = path26.dirname(file);
-  const bundledWeb = path26.join(here, "web");
-  if (isWebDir(bundledWeb) || path26.basename(here) === "dist") {
+  const here = path27.dirname(file);
+  const bundledWeb = path27.join(here, "web");
+  if (isWebDir(bundledWeb) || path27.basename(here) === "dist") {
     return {
-      version: readVersion(path26.join(here, "..", "package.json")),
+      version: readVersion(path27.join(here, "..", "package.json")),
       webDir: isWebDir(bundledWeb) ? bundledWeb : null,
       sourceRoot: null,
       cliEntry: file
     };
   }
-  const root = path26.resolve(here, "..", "..", "..");
+  const root = path27.resolve(here, "..", "..", "..");
   const override = process.env.VIBEFLOW_WEB_DIR;
-  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 };
+  const webDir = override && isWebDir(override) ? override : isWebDir(path27.join(root, "app")) ? path27.join(root, "app") : null;
+  return { version: readVersion(path27.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
 }
 function readVersion(pkgPath) {
   try {
-    return JSON.parse(fs21.readFileSync(pkgPath, "utf8")).version;
+    return JSON.parse(fs22.readFileSync(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -6520,8 +7246,8 @@ async function cmdOpen(values, target, layout, userDataDir) {
     console.error("\u7528\u6CD5\uFF1Avibeflow open <path>");
     return 1;
   }
-  const dir = path26.resolve(target);
-  if (!fs21.existsSync(dir) || !fs21.statSync(dir).isDirectory()) {
+  const dir = path27.resolve(target);
+  if (!fs22.existsSync(dir) || !fs22.statSync(dir).isDirectory()) {
     console.error(`\u4E0D\u662F\u8CC7\u6599\u593E\uFF1A${dir}`);
     return 1;
   }