@kw-yeh/vibeflow 4.6.2 → 4.8.0

package/dist/vibeflow.mjs

@@ -499,6 +499,196 @@ var init_tmux_backend = __esm({
   }
 });
 
+// packages/core/src/launch.ts
+function pathBasename(p) {
+  const norm = p.replace(/\\/g, "/").replace(/\/+$/, "");
+  const i = norm.lastIndexOf("/");
+  return i >= 0 ? norm.slice(i + 1) : norm;
+}
+function agentArtifactsDir(worktreePath, workspacePath) {
+  if (!worktreePath || !workspacePath) return null;
+  const dir = toShellPath(workspacePath);
+  const ws = pathBasename(worktreePath);
+  return `${dir}/${ws}${ARTIFACTS_DIR_SUFFIX}`;
+}
+function buildArtifactPrompt(artifactsDir = ARTIFACTS_FALLBACK_DIR) {
+  return [
+    "Artifact \u8A2D\u5B9A\uFF08\u672C\u6B21 session \u5168\u7A0B\u9069\u7528\uFF09\uFF1A",
+    `1. \u672C\u4EFB\u52D9\u7684 Artifact \u8CC7\u6599\u593E\u662F ${artifactsDir}/\uFF1B\u9700\u8981\u4FDD\u5B58\u7D66\u4F7F\u7528\u8005\u7684\u9A57\u8B49\u8B49\u64DA\u6216\u5831\u544A\u6642\uFF0C\u8ACB\u5BEB\u5165\u6B64\u8CC7\u6599\u593E\uFF08\u4E0D\u5B58\u5728\u8ACB\u5EFA\u7ACB\uFF09\u3002`,
+    `2. \u4F7F\u7528\u8005\u6703\u5728 VibeFlow \u7684 Artifacts \u5206\u9801\u6AA2\u8996\u6839\u76EE\u9304\u5167\u5BB9\uFF1B\u53EA\u653E\u4F60\u6703\u4E3B\u52D5\u8ACB\u4F7F\u7528\u8005\u904E\u76EE\u7684\u6A94\u6848\u3002`,
+    `3. \u4F60\u81EA\u5DF1\u7684\u5DE5\u4F5C\u66AB\u5B58\uFF08\u4E00\u6B21\u6027 script\u3001log\u3001\u4E2D\u9593\u8F38\u51FA\u3001debug \u6A94\uFF09\u653E\u5728 ${artifactsDir}/${SCRATCH_DIR_NAME}/\u3002`,
+    `4. \u82E5\u5DE5\u5177\u5148\u8F38\u51FA\u5230 /tmp\u3001/private/tmp\u3001$TMPDIR \u6216 ~/Downloads\uFF0C\u8ACB\u628A\u6700\u7D42\u8981\u5448\u73FE\u7684\u6A94\u6848\u8907\u88FD\u5230 ${artifactsDir}/ \u4E26\u78BA\u8A8D\u5B58\u5728\u3002`,
+    "5. Artifact \u8CC7\u6599\u593E\u4F4D\u65BC worktree \u4E4B\u5916\uFF1B\u4E0D\u8981\u628A\u5176\u4E2D\u5167\u5BB9\u52A0\u5165 git commit\uFF0C\u4E5F\u4E0D\u8981\u628A\u6700\u7D42\u4EA4\u4ED8\u7269\u53EA\u7559\u5728\u9019\u88E1\u3002"
+  ].join("\n");
+}
+function claudePermissionFlag(autoMode) {
+  return autoMode ? ` --permission-mode ${AUTO_PERMISSION_MODE}` : "";
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function toShellPath(p) {
+  return p.replace(/\\/g, "/");
+}
+function boardEnvPrefix(task, opts) {
+  const board = opts?.boardCli;
+  if (!board) return "";
+  const entries = [
+    ["VIBEFLOW_TASK_ID", task.id],
+    ["VIBEFLOW_PROJECT_PATH", task.projectPath],
+    ["VIBEFLOW_BRANCH", task.branch],
+    ["VIBEFLOW_BASE_BRANCH", task.baseBranch],
+    ["VIBEFLOW_STORE_DIR", board?.storeDir],
+    ["VIBEFLOW_CLI", board?.cliPath],
+    ["VIBEFLOW_CLI_LOADER", board?.loaderPath],
+    ["VIBEFLOW_AUTO_MODE", opts?.autoMode ? "1" : "0"]
+  ];
+  const exports = entries.filter((entry) => Boolean(entry[1])).map(([key, value]) => `${key}=${shellQuote(toShellPath(value))}`);
+  return exports.length ? `export ${exports.join(" ")}; ` : "";
+}
+function codexAutoFlag(autoMode) {
+  return autoMode ? "--dangerously-bypass-approvals-and-sandbox " : "";
+}
+function claudeResumeOrFresh(sessionId, worktreePath, tail) {
+  if (!worktreePath) return `claude --resume ${sessionId} ${tail}\r`;
+  const munged = worktreePath.replace(/[^a-zA-Z0-9]/g, "-");
+  const sessionFile = `"$HOME/.claude/projects/${munged}/${sessionId}.jsonl"`;
+  return `if [ -f ${sessionFile} ]; then claude --resume ${sessionId} ${tail}; else claude --session-id ${sessionId} ${tail}; fi\r`;
+}
+function buildClaudeSettings(worktreePath) {
+  const settings = { theme: "dark" };
+  if (worktreePath) {
+    const dir = `${toShellPath(worktreePath)}/${SUBAGENTS_DIR2}`;
+    const command = `mkdir -p "${dir}" && cat > "${dir}/$(date +%s)-$$-$RANDOM.json"`;
+    const taskHook = {
+      matcher: "Task",
+      hooks: [{ type: "command", command }]
+    };
+    const eventsDir = `${toShellPath(worktreePath)}/${PROGRESS_EVENTS_DIR}`;
+    const progress = {
+      hooks: [{ type: "command", command: `mkdir -p "${eventsDir}" && cat > "${eventsDir}/$(date +%s)-$$-$RANDOM.json"; exit 0` }]
+    };
+    settings.hooks = {
+      PreToolUse: [taskHook],
+      PostToolUse: [taskHook, { matcher: TODO_TOOLS, ...progress }],
+      Stop: [progress],
+      Notification: [progress],
+      UserPromptSubmit: [progress]
+    };
+  }
+  return JSON.stringify(settings);
+}
+function resolveSystemPrompt(custom) {
+  return custom && custom.trim() ? custom : "";
+}
+function buildPrompt(task) {
+  const lines = [`\u4EFB\u52D9\u6A19\u984C\uFF1A${task.title}`];
+  const description = task.description?.trim();
+  if (description) {
+    lines.push("", "\u4EFB\u52D9\u63CF\u8FF0\uFF1A", description);
+  }
+  return lines.join("\n");
+}
+function executorSessionId(taskId, runId) {
+  const source = runId ? `${taskId}:${runId}` : taskId;
+  const raw = source.replace(/[^0-9a-f]/gi, "").toLowerCase();
+  const hex = runId ? `${raw.slice(0, 24).padEnd(24, "0")}${namespaceHash(`executor:${source}`)}` : raw.padEnd(32, "0").slice(0, 32);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+function namespaceHash(namespace) {
+  let hash = 2166136261;
+  for (let i = 0; i < namespace.length; i += 1) {
+    hash ^= namespace.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function assembleCommand(agent, systemPrompt, prompt, model, effort, opts, worktreePath, sessionId, workspacePath) {
+  let cmd;
+  if (agent === "claude") {
+    const settings = ` --settings ${shellQuote(buildClaudeSettings(worktreePath))}`;
+    const addDir = workspacePath ? ` --add-dir ${shellQuote(toShellPath(workspacePath))}` : "";
+    const modelFlag = model ? ` --model ${model}` : "";
+    const effortFlag = effort ? ` --effort ${effort}` : "";
+    const library = opts?.library;
+    const libraryFlags = library ? ` --plugin-dir ${shellQuote(toShellPath(library.pluginDir))} --add-dir ${shellQuote(toShellPath(library.libraryDir))}` : "";
+    const flags = `--chrome${claudePermissionFlag(opts?.autoMode)}${modelFlag}${effortFlag}${settings}${addDir}${libraryFlags}`;
+    const sysFlag = systemPrompt ? ` --append-system-prompt ${shellQuote(systemPrompt)}` : "";
+    const promptArg = prompt ? ` ${shellQuote(prompt)}` : "";
+    const tail = `${flags}${sysFlag}${promptArg}`;
+    cmd = sessionId && opts?.resume ? claudeResumeOrFresh(sessionId, worktreePath, tail) : `claude ${sessionId ? `--session-id ${sessionId} ` : opts?.resume ? "--continue " : ""}${tail}\r`;
+  } else {
+    const combined = [systemPrompt, prompt].filter(Boolean).join("\n\n");
+    const codexEffortFlag = effort ? `-c ${shellQuote(`model_reasoning_effort="${effort}"`)} ` : "";
+    const codexHome = opts?.library ? `CODEX_HOME=${shellQuote(toShellPath(opts.library.codexHome))} ` : "";
+    const 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;
+}
+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
+  );
+}
+var ARTIFACTS_DIR_SUFFIX, SCRATCH_DIR_NAME, ARTIFACTS_FALLBACK_DIR, AUTO_PERMISSION_MODE, SUBAGENTS_DIR2, PROGRESS_EVENTS_DIR, TODO_TOOLS, AGENT_NAMES, DEFAULT_MODELS, LEGACY_MODEL_FALLBACKS;
+var init_launch = __esm({
+  "packages/core/src/launch.ts"() {
+    "use strict";
+    ARTIFACTS_DIR_SUFFIX = ".artifacts";
+    SCRATCH_DIR_NAME = "scratch";
+    ARTIFACTS_FALLBACK_DIR = ".vibeflow-artifacts";
+    AUTO_PERMISSION_MODE = "auto";
+    SUBAGENTS_DIR2 = ".vibeflow-subagents";
+    PROGRESS_EVENTS_DIR = ".vibeflow-events";
+    TODO_TOOLS = "TodoWrite|TaskCreate|TaskUpdate";
+    AGENT_NAMES = {
+      claude: "Claude Code",
+      codex: "Codex CLI"
+    };
+    DEFAULT_MODELS = {
+      claude: "sonnet",
+      codex: "gpt-5.5"
+    };
+    LEGACY_MODEL_FALLBACKS = {
+      codex: {
+        "gpt-5-codex": "gpt-5.5",
+        "gpt-5": "gpt-5.5"
+      }
+    };
+  }
+});
+
 // packages/core/src/attachments.ts
 import { randomUUID } from "crypto";
 import { execFileSync as execFileSync3 } from "child_process";
@@ -522,9 +712,9 @@ function truncateUtf8(value, maxBytes) {
   return result;
 }
 function safeAttachmentName(name) {
-  const basename2 = name.replace(/\\/g, "/").split("/").pop() ?? "";
+  const basename3 = name.replace(/\\/g, "/").split("/").pop() ?? "";
   const sanitized = truncateUtf8(
-    basename2.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
+    basename3.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
     MAX_FILENAME_BYTES
   );
   return sanitized && sanitized !== "." && sanitized !== ".." ? sanitized : "attachment";
@@ -599,6 +789,33 @@ var init_attachments = __esm({
   }
 });
 
+// packages/core/src/effort.ts
+function isAgentEffort(value) {
+  return typeof value === "string" && AGENT_EFFORTS.includes(value);
+}
+function allowedEfforts(model) {
+  return model?.efforts ?? null;
+}
+function selectableEfforts(model) {
+  return allowedEfforts(model) ?? UNKNOWN_MODEL_EFFORTS;
+}
+function clampEffort(effort, allowed) {
+  if (allowed.length === 0) return void 0;
+  if (effort === void 0 || allowed.includes(effort)) return effort;
+  const rank = AGENT_EFFORTS.indexOf(effort);
+  const ordered = AGENT_EFFORTS.filter((level) => allowed.includes(level));
+  const notDeeper = ordered.filter((level) => AGENT_EFFORTS.indexOf(level) <= rank);
+  return notDeeper.length > 0 ? notDeeper[notDeeper.length - 1] : ordered[0];
+}
+var AGENT_EFFORTS, UNKNOWN_MODEL_EFFORTS;
+var init_effort = __esm({
+  "packages/core/src/effort.ts"() {
+    "use strict";
+    AGENT_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
+    UNKNOWN_MODEL_EFFORTS = ["low", "medium", "high", "xhigh"];
+  }
+});
+
 // packages/core/src/progress.ts
 function emptyUsage() {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 };
@@ -883,9 +1100,9 @@ var init_progress = __esm({
 
 // packages/tui/src/task-form.ts
 import { spawnSync } from "child_process";
-import fs21 from "fs";
-import os7 from "os";
-import path25 from "path";
+import fs22 from "fs";
+import os9 from "os";
+import path26 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render, useApp, useInput } from "ink";
 function newFormState(defaultAutoMode, agents) {
@@ -951,11 +1168,19 @@ function visibleFields(s, ctx) {
   return fields;
 }
 function modelOptions(ctx, agentCli, current) {
-  const listed = ctx.models[agentCli] ?? [];
+  const listed = (ctx.models[agentCli] ?? []).map((m) => m.id);
   const options = ["", ...listed];
   if (current && !listed.includes(current)) options.push(current);
   return options;
 }
+function effortOptions(ctx, agentCli, model) {
+  const id = taskModel({ agentCli, model });
+  return selectableEfforts(ctx.models[agentCli]?.find((m) => m.id === id));
+}
+function fitEffort(ctx, s) {
+  const effort = clampEffort(s.effort, effortOptions(ctx, s.agentCli, s.model)) ?? s.effort;
+  return effort === s.effort ? s : { ...s, effort };
+}
 function blockReason(s, ctx, loadingGit) {
   if (!s.title.trim()) return "\u8ACB\u8F38\u5165\u4EFB\u52D9\u6A19\u984C";
   if (loadingGit) return "\u5075\u6E2C Git \u72C0\u614B\u4E2D\u2026";
@@ -1004,17 +1229,17 @@ function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs21.mkdtempSync(path25.join(os7.tmpdir(), "vibeflow-"));
-  const file = path25.join(dir, "description.md");
+  const dir = fs22.mkdtempSync(path26.join(os9.tmpdir(), "vibeflow-"));
+  const file = path26.join(dir, "description.md");
   try {
-    fs21.writeFileSync(file, text);
+    fs22.writeFileSync(file, text);
     const cmd = editorCommand(process.env, process.platform);
     const r = spawnSync(`${cmd} "${file}"`, { stdio: "inherit", shell: true });
     if (r.error) return { error: `\u7121\u6CD5\u555F\u52D5\u7DE8\u8F2F\u5668\uFF08${cmd}\uFF09\uFF1A${r.error.message}` };
     if (r.status !== 0) return { error: `\u7DE8\u8F2F\u5668\uFF08${cmd}\uFF09\u7D50\u675F\u78BC ${r.status}\uFF0C\u63CF\u8FF0\u672A\u8B8A\u66F4` };
-    return { text: fs21.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
+    return { text: fs22.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
   } finally {
-    fs21.rmSync(dir, { recursive: true, force: true });
+    fs22.rmSync(dir, { recursive: true, force: true });
   }
 }
 function cycle(list, current, step) {
@@ -1085,10 +1310,10 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
     if (editing === "title") setS((prev) => ({ ...prev, title: draft }));
     else if (editing === "branch") setS((prev) => ({ ...prev, branch: value2 }));
     else if (editing === "project") {
-      if (value2) setProject(path25.resolve(value2.replace(/^~(?=$|\/)/, os7.homedir())));
+      if (value2) setProject(path26.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path25.resolve(value2.replace(/^~(?=$|\/)/, os7.homedir()));
-      if (!fs21.existsSync(file) || !fs21.statSync(file).isFile()) {
+      const file = path26.resolve(value2.replace(/^~(?=$|\/)/, os9.homedir()));
+      if (!fs22.existsSync(file) || !fs22.statSync(file).isFile()) {
         setMessage(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
         return;
       }
@@ -1127,13 +1352,16 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       } else if (field === "baseBranch") {
         setS((prev) => ({ ...prev, baseBranch: cycle(prev.gitInfo?.branches ?? [], prev.baseBranch, step) }));
       } else if (field === "effort") {
-        setS((prev) => ({ ...prev, effort: cycle(EFFORTS.map((e) => e.value), prev.effort, step) }));
+        setS((prev) => {
+          const levels = effortOptions(ctx, prev.agentCli, prev.model);
+          return levels.length ? { ...prev, effort: cycle([...levels], prev.effort, step) } : prev;
+        });
       } else if (field === "autoMode") {
         setS((prev) => ({ ...prev, autoMode: !prev.autoMode }));
       } else if (field === "agent" && ctx.agents?.length) {
-        setS((prev) => ({ ...prev, agentCli: cycle(ctx.agents.map((a) => a.id), prev.agentCli, step), model: "" }));
+        setS((prev) => fitEffort(ctx, { ...prev, agentCli: cycle(ctx.agents.map((a) => a.id), prev.agentCli, step), model: "" }));
       } else if (field === "model") {
-        setS((prev) => ({ ...prev, model: cycle(modelOptions(ctx, prev.agentCli, prev.model), prev.model, step) }));
+        setS((prev) => fitEffort(ctx, { ...prev, model: cycle(modelOptions(ctx, prev.agentCli, prev.model), prev.model, step) }));
       }
       return;
     }
@@ -1168,14 +1396,15 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       case "branch":
         return s.branch || "\uFF08\u7559\u7A7A\u5247\u81EA\u52D5\u547D\u540D\uFF0C\u4F8B\u5982 feature/login-fix\uFF09";
       case "attachments":
-        return s.attachments.length ? s.attachments.map((a) => path25.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
+        return s.attachments.length ? s.attachments.map((a) => path26.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
       case "description": {
         if (!s.description) return "\uFF08Enter \u7528\u7DE8\u8F2F\u5668\u64B0\u5BEB\uFF09";
         const lines = s.description.split("\n");
         return lines.length > 1 ? `${lines[0]} \u2026\uFF08\u5171 ${lines.length} \u884C\uFF09` : lines[0];
       }
       case "effort": {
-        const e = EFFORTS.find((x) => x.value === s.effort);
+        if (effortOptions(ctx, s.agentCli, s.model).length === 0) return "\u4E0D\u9069\u7528";
+        const e = EFFORTS.find((x) => x.value === s.effort) ?? EFFORTS[0];
         return `\u2039 ${e.label} \xB7 ${e.value} \u203A`;
       }
       case "autoMode":
@@ -1185,8 +1414,11 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
         if (ctx.agents.length === 0) return "\u672A\u5075\u6E2C\u5230 Agent CLI\uFF08claude / codex\uFF09";
         return `\u2039 ${ctx.agents.find((a) => a.id === s.agentCli)?.name ?? s.agentCli} \u203A`;
       }
-      case "model":
-        return modelOptions(ctx, s.agentCli, s.model).length > 1 ? `\u2039 ${s.model || "\u4F7F\u7528\u9810\u8A2D model"} \u203A` : "\u7121\u6CD5\u53D6\u5F97 model list\uFF0C\u5C07\u4F7F\u7528\u9810\u8A2D model";
+      case "model": {
+        if (modelOptions(ctx, s.agentCli, s.model).length <= 1) return "\u7121\u6CD5\u53D6\u5F97 model list\uFF0C\u5C07\u4F7F\u7528\u9810\u8A2D model";
+        const listed = ctx.models[s.agentCli]?.find((m) => m.id === s.model);
+        return `\u2039 ${s.model ? listed?.label ?? s.model : "\u4F7F\u7528\u9810\u8A2D model"} \u203A`;
+      }
       case "submit":
         return busy ?? (s.mode === "new" ? "\uFF3B \u5EFA\u7ACB\u4EFB\u52D9 \uFF3D" : "\uFF3B \u5132\u5B58\u8B8A\u66F4 \uFF3D");
     }
@@ -1199,13 +1431,17 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       if (info && !info.isRepo) return "\u9019\u500B\u8CC7\u6599\u593E\u4E0D\u662F Git repository\u3002\u8ACB\u6539\u9078\u4E00\u500B Git \u5C08\u6848\uFF0C\u6216\u5728\u4E0B\u65B9\u521D\u59CB\u5316\u3002";
       if (s.mode === "edit" && projectChanged(s)) return "\u5206\u652F\u6703\u5728\u65B0\u5C08\u6848\u3001\u5361\u7247\u958B\u59CB\u57F7\u884C\u6642\u624D\u5EFA\u7ACB\u3002";
       if (info?.isRepo && !info.hasRemote) return `\u6B64 repository \u6C92\u6709 remote\uFF0C\u5C07\u4EE5\u76EE\u524D\u5206\u652F (${info.currentBranch ?? "HEAD"}) \u70BA\u57FA\u6E96\u5EFA\u7ACB\u672C\u5730 worktree\u3002`;
-      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path25.basename(s.projectPath)}`;
+      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path26.basename(s.projectPath)}`;
     }
     if (field === "branch") {
       const when = info?.hasRemote ? "\u958B\u59CB\u57F7\u884C\u6642\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u4E26\u63A8\u5230 origin\uFF1B\u82E5 remote \u5DF2\u6709\u9019\u500B\u5206\u652F\uFF0C\u5247\u76F4\u63A5\u53D6\u56DE\u4E26\u63A5\u7E8C\u4E0A\u9762\u7684\u5DE5\u4F5C\u3002" : "\u958B\u59CB\u57F7\u884C\u6642\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u3002";
       return s.mode === "edit" && s.worktreePath ? `${when} \u9019\u5F35\u5361\u5DF2\u6709 worktree\uFF1A\u66F4\u6539\u5206\u652F\u3001\u5C08\u6848\u6216\u57FA\u6E96\u5206\u652F\u6703\u79FB\u9664\u5B83\uFF08\u6709\u672A\u5B8C\u6210\u8B8A\u66F4\u6642\u7121\u6CD5\u5132\u5B58\uFF09\u3002` : when;
     }
-    if (field === "effort") return `${EFFORTS.find((x) => x.value === s.effort).description} Claude Code \u8207 Codex \u6703\u5728\u555F\u52D5\u6B64\u4EFB\u52D9\u6642\u5957\u7528\uFF1B\u5BE6\u969B\u53EF\u7528\u7D1A\u8DDD\u4F9D model \u800C\u5B9A\u3002`;
+    if (field === "effort") {
+      if (effortOptions(ctx, s.agentCli, s.model).length === 0) return "\u9019\u500B model \u4E0D\u652F\u63F4\u8ABF\u6574\u63A8\u7406\u5F37\u5EA6\uFF0C\u555F\u52D5\u6642\u4E0D\u6703\u6307\u5B9A\u4EFB\u52D9\u8907\u96DC\u5EA6\u3002";
+      const e = EFFORTS.find((x) => x.value === s.effort) ?? EFFORTS[0];
+      return `${e.description} Claude Code \u8207 Codex \u6703\u5728\u555F\u52D5\u6B64\u4EFB\u52D9\u6642\u5957\u7528\uFF1B\u53EF\u9078\u7684\u7D1A\u8DDD\u4F9D model \u800C\u5B9A\u3002`;
+    }
     if (field === "autoMode") return s.autoMode ? "\u958B\u555F\uFF1AAgent \u6703\u76F4\u63A5\u4FEE\u6539\u6A94\u6848\u3001\u57F7\u884C\u6307\u4EE4\uFF0C\u4E0D\u6703\u9010\u6B21\u5411\u4F60\u78BA\u8A8D\u3002" : "\u95DC\u9589\uFF1AAgent \u6BCF\u6B21\u8981\u52D5\u4F5C\u524D\uFF0C\u90FD\u6703\u5728\u7D42\u7AEF\u6A5F\u88E1\u7B49\u4F60\u5141\u8A31\u3002";
     if (field === "submit") return blockReason(s, ctx, loadingGit);
     return null;
@@ -1260,7 +1496,7 @@ async function loadFormContext(api) {
   const lists = await Promise.all(
     (agents ?? []).map(async (a) => {
       const list = await api.listAgentModels(a.id).catch(() => null);
-      return [a.id, list ? list.models.map((m) => m.id) : []];
+      return [a.id, list ? list.models : []];
     })
   );
   return {
@@ -1277,13 +1513,17 @@ var h, EFFORTS, DEFAULT_EFFORT, LABELS, TEXT_FIELDS;
 var init_task_form = __esm({
   "packages/tui/src/task-form.ts"() {
     "use strict";
+    init_effort();
+    init_launch();
     init_attachments();
     h = React.createElement;
     EFFORTS = [
       { value: "low", label: "\u5FEB\u901F", description: "\u9069\u5408\u7BC4\u570D\u660E\u78BA\u3001\u4F4E\u98A8\u96AA\u7684\u5C0F\u4EFB\u52D9\u3002" },
       { value: "medium", label: "\u6A19\u6E96", description: "\u517C\u9867\u901F\u5EA6\u8207\u63A8\u7406\u6DF1\u5EA6\uFF0C\u9069\u5408\u4E00\u822C\u958B\u767C\u4EFB\u52D9\u3002" },
       { value: "high", label: "\u6DF1\u5165", description: "\u9069\u5408\u8DE8\u6A94\u6848\u3001\u9664\u932F\u6216\u9700\u8981\u8F03\u591A\u5224\u65B7\u7684\u4EFB\u52D9\u3002" },
-      { value: "xhigh", label: "\u6975\u81F4", description: "\u9069\u5408\u9AD8\u8907\u96DC\u5EA6\u3001\u9577\u93C8\u63A8\u7406\u6216\u9AD8\u98A8\u96AA\u8B8A\u66F4\u3002" }
+      { value: "xhigh", label: "\u6975\u81F4", description: "\u9069\u5408\u9AD8\u8907\u96DC\u5EA6\u3001\u9577\u93C8\u63A8\u7406\u6216\u9AD8\u98A8\u96AA\u8B8A\u66F4\u3002" },
+      { value: "max", label: "\u6700\u5927", description: "\u6700\u6DF1\u7684\u63A8\u7406\uFF0C\u9069\u5408\u6700\u56F0\u96E3\u7684\u554F\u984C\u3002" },
+      { value: "ultra", label: "\u59D4\u6D3E", description: "\u6700\u6DF1\u63A8\u7406\u4E26\u81EA\u52D5\u59D4\u6D3E\u5B50\u4EFB\u52D9\uFF0C\u8017\u6642\u8207\u7528\u91CF\u53EF\u80FD\u660E\u986F\u589E\u52A0\u3002" }
     ];
     DEFAULT_EFFORT = "medium";
     LABELS = {
@@ -1319,7 +1559,7 @@ __export(src_exports, {
   showDiff: () => showDiff
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import path26 from "path";
+import path27 from "path";
 import React2, { useEffect as useEffect2, useState as useState2 } from "react";
 import { Box as Box2, Text as Text2, render as render2, useApp as useApp2, useInput as useInput2, useStdout } from "ink";
 function findDetachKey(text) {
@@ -1333,8 +1573,8 @@ function quitHelp(backend, isHost) {
   if (isHost) return "q         \u96E2\u958B\uFF08\u9019\u500B TUI \u5C31\u662F host\uFF0C\u57F7\u884C\u4E2D\u7684 agent \u6703\u4E00\u8D77\u7D50\u675F\uFF09";
   return "q         \u96E2\u958B\uFF08agent \u7531\u57F7\u884C\u4E2D\u7684 host \u6301\u6709\uFF0C\u6703\u7E7C\u7E8C\u57F7\u884C\uFF09";
 }
-function diffEnv(base, hasDelta) {
-  const env = { ...base };
+function diffEnv(base2, hasDelta) {
+  const env = { ...base2 };
   if (hasDelta) env.GIT_PAGER = "delta --side-by-side --paging=always";
   else if (env.LESS === void 0) env.LESS = "R";
   return env;
@@ -1607,15 +1847,15 @@ function hasCommand(cmd, args) {
   return spawnSync2(cmd, args, { stdio: "ignore" }).status === 0;
 }
 function showDiff(task) {
-  const base = task.baseBranch ?? "HEAD";
+  const base2 = task.baseBranch ?? "HEAD";
   const env = diffEnv(process.env, hasCommand("delta", ["--version"]));
-  spawnSync2("git", ["-C", task.worktreePath, "-c", "color.ui=always", "diff", base], {
+  spawnSync2("git", ["-C", task.worktreePath, "-c", "color.ui=always", "diff", base2], {
     stdio: "inherit",
     env
   });
 }
 function tmuxAttach(opts, sessionName) {
-  const conf = path26.join(opts.userDataDir, "tmux.conf");
+  const conf = path27.join(opts.userDataDir, "tmux.conf");
   const inOurServer = (process.env.TMUX ?? "").split(",")[0].endsWith(`/${TMUX_SOCKET}`);
   const args = inOurServer ? ["-L", TMUX_SOCKET, "-f", conf, "switch-client", "-t", `=${sessionName}`] : ["-L", TMUX_SOCKET, "-f", conf, "attach-session", "-t", `=${sessionName}`];
   spawnSync2("tmux", args, { stdio: "inherit", env: { ...process.env, TMUX: inOurServer ? process.env.TMUX : "" } });
@@ -1746,8 +1986,8 @@ var init_src = __esm({
 });
 
 // packages/cli/src/main.ts
-import fs22 from "fs";
-import path27 from "path";
+import fs23 from "fs";
+import path28 from "path";
 import { fileURLToPath } from "url";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -2223,6 +2463,10 @@ function createBridge(t) {
     startGithubAuthLogin: () => t.invoke("settings:startGithubAuthLogin"),
     cancelGithubAuthLogin: () => t.invoke("settings:cancelGithubAuthLogin"),
     logoutGithubAuth: () => t.invoke("settings:logoutGithubAuth"),
+    /** Open Issues/PRs of the board's GitHub repos that involve me; cached unless `force`. */
+    getGithubInbox: (opts) => t.invoke("github:inbox", opts ?? {}),
+    /** The Issue/PR each card belongs to, keyed by task id. */
+    getGithubTaskLinks: (opts) => t.invoke("github:taskLinks", opts ?? {}),
     onGithubAuthEvent: (callback) => {
       return t.on("github-auth:event", (payload) => callback(payload));
     },
@@ -2533,8 +2777,8 @@ async function generateBranchName(title, description) {
 }
 
 // packages/core/src/git.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify } from "util";
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify2 } from "util";
 import path12 from "path";
 import fs8 from "fs/promises";
 
@@ -2695,192 +2939,303 @@ function unwatchAllSubAgents() {
   }
 }
 
-// packages/core/src/launch.ts
-var ARTIFACTS_DIR_SUFFIX = ".artifacts";
-var SCRATCH_DIR_NAME = "scratch";
-var ARTIFACTS_FALLBACK_DIR = ".vibeflow-artifacts";
-function pathBasename(p) {
-  const norm = p.replace(/\\/g, "/").replace(/\/+$/, "");
-  const i = norm.lastIndexOf("/");
-  return i >= 0 ? norm.slice(i + 1) : norm;
-}
-function agentArtifactsDir(worktreePath, workspacePath) {
-  if (!worktreePath || !workspacePath) return null;
-  const dir = toShellPath(workspacePath);
-  const ws = pathBasename(worktreePath);
-  return `${dir}/${ws}${ARTIFACTS_DIR_SUFFIX}`;
-}
-function buildArtifactPrompt(artifactsDir = ARTIFACTS_FALLBACK_DIR) {
-  return [
-    "Artifact \u8A2D\u5B9A\uFF08\u672C\u6B21 session \u5168\u7A0B\u9069\u7528\uFF09\uFF1A",
-    `1. \u672C\u4EFB\u52D9\u7684 Artifact \u8CC7\u6599\u593E\u662F ${artifactsDir}/\uFF1B\u9700\u8981\u4FDD\u5B58\u7D66\u4F7F\u7528\u8005\u7684\u9A57\u8B49\u8B49\u64DA\u6216\u5831\u544A\u6642\uFF0C\u8ACB\u5BEB\u5165\u6B64\u8CC7\u6599\u593E\uFF08\u4E0D\u5B58\u5728\u8ACB\u5EFA\u7ACB\uFF09\u3002`,
-    `2. \u4F7F\u7528\u8005\u6703\u5728 VibeFlow \u7684 Artifacts \u5206\u9801\u6AA2\u8996\u6839\u76EE\u9304\u5167\u5BB9\uFF1B\u53EA\u653E\u4F60\u6703\u4E3B\u52D5\u8ACB\u4F7F\u7528\u8005\u904E\u76EE\u7684\u6A94\u6848\u3002`,
-    `3. \u4F60\u81EA\u5DF1\u7684\u5DE5\u4F5C\u66AB\u5B58\uFF08\u4E00\u6B21\u6027 script\u3001log\u3001\u4E2D\u9593\u8F38\u51FA\u3001debug \u6A94\uFF09\u653E\u5728 ${artifactsDir}/${SCRATCH_DIR_NAME}/\u3002`,
-    `4. \u82E5\u5DE5\u5177\u5148\u8F38\u51FA\u5230 /tmp\u3001/private/tmp\u3001$TMPDIR \u6216 ~/Downloads\uFF0C\u8ACB\u628A\u6700\u7D42\u8981\u5448\u73FE\u7684\u6A94\u6848\u8907\u88FD\u5230 ${artifactsDir}/ \u4E26\u78BA\u8A8D\u5B58\u5728\u3002`,
-    "5. Artifact \u8CC7\u6599\u593E\u4F4D\u65BC worktree \u4E4B\u5916\uFF1B\u4E0D\u8981\u628A\u5176\u4E2D\u5167\u5BB9\u52A0\u5165 git commit\uFF0C\u4E5F\u4E0D\u8981\u628A\u6700\u7D42\u4EA4\u4ED8\u7269\u53EA\u7559\u5728\u9019\u88E1\u3002"
-  ].join("\n");
-}
-var AUTO_PERMISSION_MODE = "auto";
-function claudePermissionFlag(autoMode) {
-  return autoMode ? ` --permission-mode ${AUTO_PERMISSION_MODE}` : "";
-}
-function shellQuote(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
+// packages/core/src/git.ts
+init_launch();
+init_env();
+
+// packages/core/src/github.ts
+init_env();
+import { execFile as execFile4 } from "child_process";
+import { promisify } from "util";
+var pexec = promisify(execFile4);
+var defaultGhRunner = async (args) => {
+  const { stdout } = await pexec("gh", args, {
+    env: execEnv(),
+    maxBuffer: 16 * 1024 * 1024,
+    timeout: 3e4,
+    windowsHide: true
+  });
+  return stdout.toString();
+};
+function parseGithubRepo(remoteUrl) {
+  if (!remoteUrl) return null;
+  const url = remoteUrl.trim();
+  const match = url.match(/^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/) ?? url.match(/^ssh:\/\/git@github\.com(?::\d+)?\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/) ?? url.match(/^https?:\/\/(?:[^@/\s]+@)?github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/);
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+var REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+function isGithubRef(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return (v.kind === "issue" || v.kind === "pr") && typeof v.repo === "string" && REPO_RE.test(v.repo) && typeof v.number === "number" && Number.isInteger(v.number) && v.number > 0 && typeof v.url === "string" && v.url.startsWith(`https://github.com/${v.repo}/`);
+}
+var ITEM_FIELDS = "number,title,url,body,author,assignees,labels,milestone,createdAt";
+var ISSUE_FIELDS = `${ITEM_FIELDS},issueType`;
+var PR_FIELDS = `${ITEM_FIELDS},state,isDraft,reviewDecision,headRefName,baseRefName`;
+var PR_INDEX_FIELDS = "number,url,state,isDraft,headRefName,closingIssuesReferences";
+var LIST_LIMIT = "50";
+var PR_INDEX_LIMIT = "100";
+async function runJson(run3, args) {
+  const out = await run3(args);
+  const parsed = JSON.parse(out || "[]");
+  return Array.isArray(parsed) ? parsed : [];
+}
+function user(raw) {
+  const u = raw;
+  if (!u || typeof u.login !== "string") return null;
+  return typeof u.name === "string" && u.name ? { login: u.login, name: u.name } : { login: u.login };
+}
+function base(raw, repo) {
+  const milestone = raw.milestone;
+  return {
+    repo,
+    number: Number(raw.number),
+    title: String(raw.title ?? ""),
+    url: String(raw.url ?? ""),
+    body: typeof raw.body === "string" ? raw.body : "",
+    author: user(raw.author),
+    assignees: Array.isArray(raw.assignees) ? raw.assignees.map(user).filter(Boolean) : [],
+    labels: Array.isArray(raw.labels) ? raw.labels.map((l) => ({ name: String(l.name ?? ""), color: String(l.color ?? "") })) : [],
+    milestone: milestone && typeof milestone.title === "string" ? milestone.title : null,
+    createdAt: String(raw.createdAt ?? "")
+  };
 }
-function toShellPath(p) {
-  return p.replace(/\\/g, "/");
+function prStateOf(raw) {
+  if (raw.state === "MERGED") return "merged";
+  if (raw.state === "CLOSED") return "closed";
+  return raw.isDraft ? "draft" : "open";
 }
-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 toIssue(raw, repo) {
+  const type = raw.issueType;
+  return {
+    ...base(raw, repo),
+    kind: "issue",
+    issueType: type && typeof type.name === "string" ? { name: type.name, ...typeof type.color === "string" ? { color: type.color } : {} } : null
+  };
 }
-function codexAutoFlag(autoMode) {
-  return autoMode ? "--dangerously-bypass-approvals-and-sandbox " : "";
+function toPr(raw, repo) {
+  return {
+    ...base(raw, repo),
+    kind: "pr",
+    state: prStateOf(raw),
+    reviewDecision: typeof raw.reviewDecision === "string" && raw.reviewDecision ? raw.reviewDecision : null,
+    headRefName: String(raw.headRefName ?? ""),
+    baseRefName: String(raw.baseRefName ?? "")
+  };
 }
-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 mergeItems(lists) {
+  const byNumber = /* @__PURE__ */ new Map();
+  for (const list of lists) for (const item of list) if (!byNumber.has(item.number)) byNumber.set(item.number, item);
+  return Array.from(byNumber.values()).sort(
+    (a, b) => b.createdAt.localeCompare(a.createdAt) || b.number - a.number
+  );
 }
-var SUBAGENTS_DIR2 = ".vibeflow-subagents";
-var PROGRESS_EVENTS_DIR = ".vibeflow-events";
-var TODO_TOOLS = "TodoWrite|TaskCreate|TaskUpdate";
-function buildClaudeSettings(worktreePath) {
-  const settings = { theme: "dark" };
-  if (worktreePath) {
-    const dir = `${toShellPath(worktreePath)}/${SUBAGENTS_DIR2}`;
-    const command = `mkdir -p "${dir}" && cat > "${dir}/$(date +%s)-$$-$RANDOM.json"`;
-    const taskHook = {
-      matcher: "Task",
-      hooks: [{ type: "command", command }]
-    };
-    const eventsDir = `${toShellPath(worktreePath)}/${PROGRESS_EVENTS_DIR}`;
-    const progress = {
-      hooks: [{ type: "command", command: `mkdir -p "${eventsDir}" && cat > "${eventsDir}/$(date +%s)-$$-$RANDOM.json"; exit 0` }]
-    };
-    settings.hooks = {
-      PreToolUse: [taskHook],
-      PostToolUse: [taskHook, { matcher: TODO_TOOLS, ...progress }],
-      Stop: [progress],
-      Notification: [progress],
-      UserPromptSubmit: [progress]
-    };
-  }
-  return JSON.stringify(settings);
+async function listIssues(run3, repo, filter) {
+  const args = ["issue", "list", "-R", repo, "--state", "open", "--limit", LIST_LIMIT, ...filter];
+  let rows;
+  try {
+    rows = await runJson(run3, [...args, "--json", ISSUE_FIELDS]);
+  } catch (err) {
+    if (!/issueType/.test(errorText(err))) throw err;
+    rows = await runJson(run3, [...args, "--json", ITEM_FIELDS]);
+  }
+  return rows.map((r) => toIssue(r, repo));
+}
+async function listPrs(run3, repo, filter) {
+  const rows = await runJson(run3, [
+    "pr",
+    "list",
+    "-R",
+    repo,
+    "--state",
+    "open",
+    "--limit",
+    LIST_LIMIT,
+    ...filter,
+    "--json",
+    PR_FIELDS
+  ]);
+  return rows.map((r) => toPr(r, repo));
+}
+async function fetchRepoItems(run3, repo) {
+  const [assignedIssues, authoredIssues, assignedPrs, authoredPrs, reviewPrs] = await Promise.all([
+    listIssues(run3, repo, ["--assignee", "@me"]),
+    listIssues(run3, repo, ["--author", "@me"]),
+    listPrs(run3, repo, ["--assignee", "@me"]),
+    listPrs(run3, repo, ["--author", "@me"]),
+    listPrs(run3, repo, ["--search", "review-requested:@me"])
+  ]);
+  return {
+    issues: mergeItems([assignedIssues, authoredIssues]),
+    prs: mergeItems([assignedPrs, authoredPrs, reviewPrs])
+  };
 }
-function resolveSystemPrompt(custom) {
-  return custom && custom.trim() ? custom : "";
+async function fetchPrIndex(run3, repo) {
+  const rows = await runJson(run3, [
+    "pr",
+    "list",
+    "-R",
+    repo,
+    "--state",
+    "all",
+    "--limit",
+    PR_INDEX_LIMIT,
+    "--json",
+    PR_INDEX_FIELDS
+  ]);
+  const [owner, name] = repo.split("/");
+  return rows.map((r) => ({
+    number: Number(r.number),
+    url: String(r.url ?? ""),
+    state: prStateOf(r),
+    headRefName: String(r.headRefName ?? ""),
+    closingIssues: (Array.isArray(r.closingIssuesReferences) ? r.closingIssuesReferences : []).filter((ref) => {
+      const repository = ref.repository;
+      const refOwner = repository?.owner?.login;
+      return !repository || repository.name === name && refOwner === owner;
+    }).map((ref) => ({
+      number: Number(ref.number),
+      url: typeof ref.url === "string" ? ref.url : `https://github.com/${repo}/issues/${ref.number}`
+    }))
+  }));
 }
-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 linkFromRef(ref, state) {
+  return { kind: ref.kind, number: ref.number, url: ref.url, state };
+}
+function hasRealBranch(task) {
+  return Boolean(task.provisionedAt || task.worktreePath || task.outcome);
+}
+function resolveTaskLinks(tasks, repoOfProject, prIndex) {
+  const links = {};
+  for (const task of tasks) {
+    const source = task.github;
+    const repo = source?.repo ?? (task.projectPath ? repoOfProject.get(task.projectPath) : void 0);
+    const index = repo ? prIndex.get(repo) ?? [] : [];
+    let pr;
+    let prEntry;
+    if (source?.kind === "pr") {
+      prEntry = index.find((e) => e.number === source.number);
+      pr = linkFromRef(source, prEntry?.state ?? "open");
+    } else {
+      if (hasRealBranch(task)) {
+        prEntry = index.filter((e) => e.headRefName === task.branch).sort((a, b) => b.number - a.number)[0];
+      }
+      if (prEntry) {
+        pr = { kind: "pr", number: prEntry.number, url: prEntry.url, state: prEntry.state };
+      } else if (task.outcome?.pr) {
+        const o = task.outcome.pr;
+        pr = { kind: "pr", number: o.number, url: o.url, state: prStateOf({ state: o.state }) };
+      }
+    }
+    const issueState = pr?.state === "merged" ? "closed" : "open";
+    let issue;
+    if (source?.kind === "issue") {
+      issue = linkFromRef(source, issueState);
+    } else if (prEntry?.closingIssues[0]) {
+      const ref = prEntry.closingIssues[0];
+      issue = { kind: "issue", number: ref.number, url: ref.url, state: issueState };
+    }
+    if (pr || issue) links[task.id] = { ...issue ? { issue } : {}, ...pr ? { pr } : {} };
   }
-  return lines.join("\n");
+  return links;
 }
-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 errorText(err) {
+  const e = err;
+  const stderr = e?.stderr ? e.stderr.toString().trim() : "";
+  return stderr || e?.message || String(err);
 }
-function namespaceHash(namespace) {
-  let hash = 2166136261;
-  for (let i = 0; i < namespace.length; i += 1) {
-    hash ^= namespace.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
+var GITHUB_CACHE_TTL_MS = 5 * 60 * 1e3;
+function boardTasks(board) {
+  return [...board.in_progress, ...board.backlog, ...board.done];
 }
-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 boardProjects(board) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const t of boardTasks(board)) {
+    if (!t.projectPath) continue;
+    latest.set(t.projectPath, Math.max(latest.get(t.projectPath) ?? 0, t.createdAt ?? 0));
   }
-  if (cmd.length > 2e5) console.warn(`[VibeFlow] launch command is ${cmd.length} bytes \u2014 approaching ARG_MAX`);
-  return cmd;
+  return Array.from(latest.entries()).sort((a, b) => b[1] - a[1]).map(([p]) => p);
 }
-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 basename(p) {
+  return p.split(/[/\\]/).filter(Boolean).pop() ?? p;
+}
+function createGithubService(options) {
+  const run3 = options.run ?? defaultGhRunner;
+  const authStatus = options.authStatus;
+  const now = options.now ?? Date.now;
+  const items = /* @__PURE__ */ new Map();
+  const indexes = /* @__PURE__ */ new Map();
+  const repos = /* @__PURE__ */ new Map();
+  function cached2(map, key, force, load) {
+    const hit = map.get(key);
+    if (hit && !force && now() - hit.at < GITHUB_CACHE_TTL_MS) return hit;
+    const entry = { at: now(), value: load() };
+    entry.value.catch(() => {
+    });
+    map.set(key, entry);
+    return entry;
+  }
+  async function projectRepos(board, force) {
+    const out = /* @__PURE__ */ new Map();
+    const projects = boardProjects(board);
+    const resolved = await Promise.all(
+      projects.map((p) => cached2(repos, p, force, () => options.repoOf(p)).value.catch(() => null))
+    );
+    projects.forEach((p, i) => {
+      const repo = resolved[i];
+      if (repo) out.set(p, repo);
+    });
+    return out;
   }
-};
-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
-  );
+  return {
+    async inbox(board, opts = {}) {
+      const force = opts.force === true;
+      const auth = await authStatus();
+      if (!auth.installed) return { status: "gh-missing", fetchedAt: 0, repos: [] };
+      if (!auth.authenticated) return { status: "unauthenticated", fetchedAt: 0, repos: [] };
+      const byProject = await projectRepos(board, force);
+      const repoProject = /* @__PURE__ */ new Map();
+      for (const [project, repo] of byProject) if (!repoProject.has(repo)) repoProject.set(repo, project);
+      const entries = Array.from(repoProject.entries());
+      const results = await Promise.all(
+        entries.map(async ([repo, projectPath]) => {
+          const entry = cached2(items, repo, force, () => fetchRepoItems(run3, repo));
+          const head = { repo, projectPath, projectName: basename(projectPath) };
+          try {
+            return { at: entry.at, inbox: { ...head, ...await entry.value } };
+          } catch (err) {
+            return { at: entry.at, inbox: { ...head, issues: [], prs: [], error: errorText(err) } };
+          }
+        })
+      );
+      return {
+        status: "ok",
+        ...auth.login ? { login: auth.login } : {},
+        fetchedAt: results.length ? Math.min(...results.map((r) => r.at)) : 0,
+        repos: results.map((r) => r.inbox).sort((a, b) => a.repo.localeCompare(b.repo))
+      };
+    },
+    async taskLinks(board, opts = {}) {
+      const force = opts.force === true;
+      const tasks = boardTasks(board);
+      const byProject = await projectRepos(board, force);
+      const wanted = new Set(byProject.values());
+      for (const t of tasks) if (t.github) wanted.add(t.github.repo);
+      const prIndex = /* @__PURE__ */ new Map();
+      await Promise.all(
+        Array.from(wanted).map(async (repo) => {
+          try {
+            prIndex.set(repo, await cached2(indexes, repo, force, () => fetchPrIndex(run3, repo)).value);
+          } catch {
+          }
+        })
+      );
+      return resolveTaskLinks(tasks, byProject, prIndex);
+    }
+  };
 }
 
 // packages/core/src/git.ts
-init_env();
 init_attachments();
 
 // packages/core/src/artifacts.ts
@@ -3038,9 +3393,9 @@ function deleteArtifacts(baseDir, worktreePath) {
 }
 
 // packages/core/src/git.ts
-var pexec = promisify(execFile4);
+var pexec2 = promisify2(execFile5);
 async function git(cwd, args) {
-  const { stdout } = await pexec("git", args, {
+  const { stdout } = await pexec2("git", args, {
     cwd,
     maxBuffer: 32 * 1024 * 1024,
     env: execEnv()
@@ -3409,7 +3764,7 @@ function copyIgnoredDependenciesInBackground(projectPath, worktreePath, entries)
     }
   })();
 }
-async function adoptRemoteBranch(projectPath, worktreePath, branch, base) {
+async function adoptRemoteBranch(projectPath, worktreePath, branch, base2) {
   try {
     await git(projectPath, ["fetch", "origin", branch]);
   } catch {
@@ -3431,32 +3786,32 @@ async function adoptRemoteBranch(projectPath, worktreePath, branch, base) {
   }
   const ignoredEntries = await copySmallIgnoredFiles(projectPath, worktreePath);
   copyIgnoredDependenciesInBackground(projectPath, worktreePath, ignoredEntries);
-  return { branch, worktreePath, pushed: true, baseBranch: base };
+  return { branch, worktreePath, pushed: true, baseBranch: base2 };
 }
 async function provisionWorktree(projectPath, workspacePath, taskId, baseBranch, preferredBranch, opts = {}) {
   await ensureLocalExclude(projectPath);
   const branch = opts.explicitBranch && preferredBranch ? preferredBranch : await resolveBranchName(projectPath, workspacePath, taskId, preferredBranch);
   const worktreePath = path12.join(workspacePath, worktreeDirName(branch));
   const info = await getGitInfo(projectPath);
-  const base = baseBranch || info.defaultBase || info.currentBranch || "HEAD";
+  const base2 = baseBranch || info.defaultBase || info.currentBranch || "HEAD";
   if (opts.explicitBranch && info.hasRemote && await remoteBranchExists(projectPath, branch)) {
-    return adoptRemoteBranch(projectPath, worktreePath, branch, base);
+    return adoptRemoteBranch(projectPath, worktreePath, branch, base2);
   }
-  let startPoint = base;
+  let startPoint = base2;
   if (info.hasRemote) {
     try {
-      await git(projectPath, ["fetch", "origin", `${base}:${base}`]);
+      await git(projectPath, ["fetch", "origin", `${base2}:${base2}`]);
     } catch {
       try {
-        await git(projectPath, ["fetch", "origin", base]);
+        await git(projectPath, ["fetch", "origin", base2]);
       } catch {
       }
     }
     try {
-      await git(projectPath, ["rev-parse", "--verify", `origin/${base}`]);
-      startPoint = `origin/${base}`;
+      await git(projectPath, ["rev-parse", "--verify", `origin/${base2}`]);
+      startPoint = `origin/${base2}`;
     } catch {
-      startPoint = base;
+      startPoint = base2;
     }
   }
   try {
@@ -3486,7 +3841,7 @@ async function provisionWorktree(projectPath, workspacePath, taskId, baseBranch,
     copySmallIgnoredFiles(projectPath, worktreePath)
   ]);
   copyIgnoredDependenciesInBackground(projectPath, worktreePath, ignoredEntries);
-  return { branch, worktreePath, pushed, baseBranch: base };
+  return { branch, worktreePath, pushed, baseBranch: base2 };
 }
 async function removeWorktree(projectPath, worktreePath) {
   try {
@@ -3698,7 +4053,7 @@ var MAX_OUTCOME_COMMITS = 50;
 var OUTCOME_LOG_FORMAT = "%h%x00%s";
 async function getOutcomePr(worktreePath) {
   try {
-    const { stdout } = await pexec(
+    const { stdout } = await pexec2(
       "gh",
       ["pr", "view", "--json", "url,number,state,title,body"],
       { cwd: worktreePath, env: execEnv() }
@@ -3759,7 +4114,7 @@ async function captureTaskOutcome(worktreePath, baseBranch) {
 }
 async function getPrStatus(worktreePath) {
   try {
-    const { stdout } = await pexec(
+    const { stdout } = await pexec2(
       "gh",
       ["pr", "view", "--json", "url,number,state"],
       { cwd: worktreePath, env: execEnv() }
@@ -3775,17 +4130,9 @@ async function getGithubCompareUrl(worktreePath, baseBranch) {
   try {
     const remoteUrl = await git(worktreePath, ["remote", "get-url", "origin"]);
     const branch = await git(worktreePath, ["rev-parse", "--abbrev-ref", "HEAD"]);
-    let webUrl;
-    const sshMatch = remoteUrl.match(/git@github\.com:(.+?)(?:\.git)?$/);
-    const httpsMatch = remoteUrl.match(/https?:\/\/github\.com\/(.+?)(?:\.git)?$/);
-    if (sshMatch) {
-      webUrl = `https://github.com/${sshMatch[1]}`;
-    } else if (httpsMatch) {
-      webUrl = `https://github.com/${httpsMatch[1]}`;
-    } else {
-      return null;
-    }
-    return `${webUrl}/compare/${baseBranch}...${branch}?expand=1`;
+    const repo = parseGithubRepo(remoteUrl);
+    if (!repo) return null;
+    return `https://github.com/${repo}/compare/${baseBranch}...${branch}?expand=1`;
   } catch {
     return null;
   }
@@ -3852,10 +4199,10 @@ function taskAttachmentStagingPath(workspacePath, taskId) {
 
 // packages/core/src/agents.ts
 init_env();
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify2 } from "util";
-var pexec2 = promisify2(execFile5);
-var AGENT_EFFORTS = ["low", "medium", "high", "xhigh"];
+init_effort();
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify3 } from "util";
+var pexec3 = promisify3(execFile6);
 var DEFAULT_TASK_EFFORT = "medium";
 var AGENT_CLIS = [
   {
@@ -3882,7 +4229,7 @@ var AGENT_CLIS = [
 async function commandExists(bin) {
   try {
     const command = process.platform === "win32" ? "where.exe" : "which";
-    await pexec2(command, [bin], {
+    await pexec3(command, [bin], {
       env: execEnv(),
       timeout: 2500,
       windowsHide: true
@@ -3957,7 +4304,8 @@ async function createTaskFromInput(input) {
     agentCli: input.agentCli ?? "claude",
     model: input.model || void 0,
     effort: input.effort ?? DEFAULT_TASK_EFFORT,
-    autoMode: input.autoMode
+    autoMode: input.autoMode,
+    ...input.github ? { github: input.github } : {}
   };
   try {
     const board = store.get("board");
@@ -4244,8 +4592,8 @@ async function taskCommand(argv) {
 }
 
 // packages/cli/src/host.ts
-import fs19 from "fs";
-import path23 from "path";
+import fs20 from "fs";
+import path24 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // packages/core/src/events.ts
@@ -4311,9 +4659,9 @@ function truncateUtf82(value, maxBytes) {
   return result;
 }
 function safeLibraryName(name) {
-  const basename2 = name.replace(/\\/g, "/").split("/").pop() ?? "";
+  const basename3 = name.replace(/\\/g, "/").split("/").pop() ?? "";
   const cleaned = truncateUtf82(
-    basename2.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
+    basename3.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
     MAX_NAME_BYTES
   );
   return cleaned && cleaned !== "." && cleaned !== ".." ? cleaned : "untitled";
@@ -4783,35 +5131,266 @@ async function syncBuiltinsAtStartup() {
 }
 
 // packages/core/src/service.ts
-import fs17 from "fs";
-import os6 from "os";
-import path21 from "path";
+import fs18 from "fs";
+import os8 from "os";
+import path22 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // packages/core/src/agent-models.ts
-import { execFile as execFile6 } from "child_process";
+import fs13 from "fs";
+import os6 from "os";
+import path17 from "path";
+
+// packages/core/src/claude-models.ts
+init_effort();
 import fs12 from "fs";
 import os4 from "os";
 import path16 from "path";
-import { promisify as promisify3 } from "util";
+
+// packages/core/src/json-lines-process.ts
 init_env();
-var pexec3 = promisify3(execFile6);
+import { spawn as spawn4 } from "child_process";
+function spawnJsonLines(bin, args, opts) {
+  const spawnOpts = { cwd: opts.cwd, env: opts.env ?? execEnv(), windowsHide: true };
+  const proc = process.platform === "win32" ? spawn4([bin, ...args].join(" "), { ...spawnOpts, shell: true }) : spawn4(bin, args, spawnOpts);
+  const inbox = [];
+  const waiters = [];
+  let failure = null;
+  let stderr = "";
+  let exited = false;
+  const finished = () => {
+    if (exited) return;
+    exited = true;
+    opts.onExit?.();
+  };
+  const fail2 = (err) => {
+    if (failure) return;
+    failure = err;
+    for (const w of waiters.splice(0)) w.reject(err);
+  };
+  const deliver = (message) => {
+    const i = waiters.findIndex((w) => w.match(message));
+    if (i === -1) inbox.push(message);
+    else waiters.splice(i, 1)[0].resolve(message);
+  };
+  let buffered = "";
+  proc.stdout.setEncoding("utf8");
+  proc.stdout.on("data", (chunk) => {
+    buffered += chunk;
+    let nl;
+    while ((nl = buffered.indexOf("\n")) >= 0) {
+      const line = buffered.slice(0, nl).trim();
+      buffered = buffered.slice(nl + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      deliver(message);
+    }
+  });
+  proc.stderr.setEncoding("utf8");
+  proc.stderr.on("data", (chunk) => {
+    stderr = (stderr + chunk).slice(-2048);
+  });
+  proc.on("error", (err) => {
+    fail2(err);
+    if (proc.pid === void 0) {
+      clearTimeout(timer);
+      finished();
+    }
+  });
+  proc.on("exit", (code2, signal) => {
+    finished();
+    clearTimeout(timer);
+    clearTimeout(graceTimer);
+    const reason = signal ? `was killed (${signal})` : `exited with code ${code2}`;
+    fail2(new Error(`${bin} ${reason}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+  });
+  proc.stdin.on("error", () => {
+  });
+  const kill = () => {
+    if (exited) return;
+    if (process.platform === "win32" && proc.pid !== void 0) {
+      spawn4("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true }).on("error", () => proc.kill());
+      return;
+    }
+    proc.kill();
+  };
+  const timer = setTimeout(() => {
+    fail2(new Error(`${bin} did not answer within ${opts.timeoutMs}ms`));
+    kill();
+  }, opts.timeoutMs);
+  let graceTimer;
+  return {
+    send(message) {
+      if (!failure) proc.stdin.write(`${JSON.stringify(message)}
+`);
+    },
+    next(match) {
+      const i = inbox.findIndex(match);
+      if (i >= 0) return Promise.resolve(inbox.splice(i, 1)[0]);
+      if (failure) return Promise.reject(failure);
+      return new Promise((resolve, reject) => waiters.push({ match, resolve, reject }));
+    },
+    close() {
+      clearTimeout(timer);
+      fail2(new Error(`${bin} conversation closed`));
+      proc.stdin.end();
+      if (!exited && !graceTimer) graceTimer = setTimeout(kill, opts.exitGraceMs ?? 3e3);
+    }
+  };
+}
+
+// packages/core/src/claude-models.ts
+var CLAUDE_MODELS_TIMEOUT_MS = 15e3;
+var REQUEST_ID = "vibeflow-models";
+var CLAUDE_ARGS = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"];
+function openClaude() {
+  const cwd = fs12.mkdtempSync(path16.join(os4.tmpdir(), "vf-claude-models-"));
+  return spawnJsonLines("claude", CLAUDE_ARGS, {
+    cwd,
+    timeoutMs: CLAUDE_MODELS_TIMEOUT_MS,
+    onExit: () => fs12.rmSync(cwd, { recursive: true, force: true })
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOurResponse(message) {
+  return isRecord(message) && message.type === "control_response" && isRecord(message.response) && message.response.request_id === REQUEST_ID;
+}
+function parseClaudeInitialize(message) {
+  const outer = isRecord(message) && isRecord(message.response) ? message.response : null;
+  if (outer?.subtype === "error") throw new Error(`claude refused the handshake: ${String(outer.error ?? "unknown error")}`);
+  const body = outer && isRecord(outer.response) ? outer.response : null;
+  if (!body || !Array.isArray(body.models)) throw new Error("claude handshake has no models array");
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  for (const entry of body.models) {
+    if (!isRecord(entry) || typeof entry.value !== "string") continue;
+    const id = entry.value.trim();
+    if (!id || id === "default" || seen.has(id)) continue;
+    seen.add(id);
+    const label = typeof entry.displayName === "string" && entry.displayName.trim() ? entry.displayName.trim() : id;
+    const description = typeof entry.description === "string" && entry.description.trim() ? entry.description.trim() : void 0;
+    const levels = entry.supportsEffort === true && Array.isArray(entry.supportedEffortLevels) ? entry.supportedEffortLevels.filter(isAgentEffort) : [];
+    models.push({ id, label, ...description ? { description } : {}, efforts: levels });
+  }
+  if (models.length === 0) throw new Error("claude handshake lists no selectable models");
+  return models;
+}
+async function fetchClaudeModels(open = openClaude) {
+  const channel = open();
+  try {
+    channel.send({ type: "control_request", request_id: REQUEST_ID, request: { subtype: "initialize" } });
+    return parseClaudeInitialize(await channel.next(isOurResponse));
+  } finally {
+    channel.close();
+  }
+}
+
+// packages/core/src/codex-models.ts
+init_effort();
+init_env();
+import os5 from "os";
 var CODEX_MODELS_TIMEOUT_MS = 2e4;
+var MAX_PAGES = 20;
+var CodexLoginRequiredError = class extends Error {
+  constructor() {
+    super("Codex CLI is not signed in; run `codex login`");
+    this.name = "CodexLoginRequiredError";
+  }
+};
+function codexAppServerCommand() {
+  return {
+    bin: "codex",
+    args: ["app-server", "--listen", "stdio://"],
+    cwd: os5.homedir(),
+    env: execEnv()
+  };
+}
+function openCodex() {
+  const { bin, args, cwd, env } = codexAppServerCommand();
+  return spawnJsonLines(bin, args, { cwd, env, timeoutMs: CODEX_MODELS_TIMEOUT_MS });
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var responseTo = (id) => (message) => isRecord2(message) && message.id === id && ("result" in message || "error" in message);
+function resultOf(message, method) {
+  if (!isRecord2(message)) throw new Error(`codex ${method}: malformed response`);
+  if (isRecord2(message.error)) throw new Error(`codex ${method}: ${String(message.error.message ?? "request failed")}`);
+  if (!isRecord2(message.result)) throw new Error(`codex ${method}: response has no result`);
+  return message.result;
+}
+function isCodexSignedIn(result) {
+  return result.account != null || result.requiresOpenaiAuth === false;
+}
+function parseCodexModelPage(result) {
+  if (!Array.isArray(result.data)) throw new Error("codex model/list has no data array");
+  const models = [];
+  for (const entry of result.data) {
+    if (!isRecord2(entry) || typeof entry.id !== "string" || !entry.id.trim() || entry.hidden === true) continue;
+    const id = entry.id.trim();
+    const label = typeof entry.displayName === "string" && entry.displayName.trim() ? entry.displayName.trim() : id;
+    const description = typeof entry.description === "string" && entry.description.trim() ? entry.description.trim() : void 0;
+    const efforts = Array.isArray(entry.supportedReasoningEfforts) ? entry.supportedReasoningEfforts.map((e) => isRecord2(e) ? e.reasoningEffort : void 0).filter(isAgentEffort) : void 0;
+    models.push({ id, label, ...description ? { description } : {}, ...efforts ? { efforts } : {} });
+  }
+  const nextCursor = typeof result.nextCursor === "string" && result.nextCursor ? result.nextCursor : null;
+  return { models, nextCursor };
+}
+async function fetchCodexModels(clientVersion, open = openCodex) {
+  const channel = open();
+  try {
+    channel.send({
+      method: "initialize",
+      id: 1,
+      params: { clientInfo: { name: "vibeflow", title: "VibeFlow", version: clientVersion } }
+    });
+    resultOf(await channel.next(responseTo(1)), "initialize");
+    channel.send({ method: "initialized", params: {} });
+    channel.send({ method: "account/read", id: 2, params: { refreshToken: false } });
+    if (!isCodexSignedIn(resultOf(await channel.next(responseTo(2)), "account/read"))) {
+      throw new CodexLoginRequiredError();
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const models = [];
+    let cursor = null;
+    for (let page = 0; page < MAX_PAGES; page++) {
+      const id = 3 + page;
+      channel.send({
+        method: "model/list",
+        id,
+        params: { limit: 100, includeHidden: false, ...cursor ? { cursor } : {} }
+      });
+      const parsed = parseCodexModelPage(resultOf(await channel.next(responseTo(id)), "model/list"));
+      for (const model of parsed.models) {
+        if (seen.has(model.id)) continue;
+        seen.add(model.id);
+        models.push(model);
+      }
+      cursor = parsed.nextCursor;
+      if (!cursor) break;
+    }
+    if (cursor) throw new Error(`codex model/list did not finish within ${MAX_PAGES} pages`);
+    if (models.length === 0) throw new Error("codex model/list lists no selectable models");
+    return models;
+  } finally {
+    channel.close();
+  }
+}
+
+// packages/core/src/agent-models.ts
 function builtinModels(id) {
   return (AGENT_CLIS.find((a) => a.id === id) ?? AGENT_CLIS[0]).models;
 }
 function defaultCodexHome() {
   const configured = process.env.CODEX_HOME?.trim();
-  return configured ? configured : path16.join(os4.homedir(), ".codex");
-}
-async function defaultRunCodexModels() {
-  const { stdout } = await pexec3("codex", ["debug", "models"], {
-    env: execEnv(),
-    timeout: CODEX_MODELS_TIMEOUT_MS,
-    maxBuffer: 16 * 1024 * 1024,
-    windowsHide: true
-  });
-  return stdout;
+  return configured ? configured : path17.join(os6.homedir(), ".codex");
 }
 function parseCodexCatalog(raw) {
   const body = JSON.parse(raw);
@@ -4836,29 +5415,68 @@ function parseCodexCatalog(raw) {
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
-async function listAgentModels(id, opts = {}) {
-  if (id !== "codex") return { models: builtinModels(id), source: "builtin" };
-  if (opts.refresh) {
-    try {
-      const stdout = await (opts.runCodexModels ?? defaultRunCodexModels)();
-      return { models: parseCodexCatalog(stdout), source: "codex-cli" };
-    } catch (err) {
-      return { models: builtinModels(id), source: "builtin", error: errorMessage(err) };
-    }
-  }
-  const cachePath = path16.join(opts.codexHome ?? defaultCodexHome(), "models_cache.json");
+async function readCodexCache(codexHome) {
+  const cachePath = path17.join(codexHome, "models_cache.json");
   try {
-    const raw = await fs12.promises.readFile(cachePath, "utf8");
+    const raw = await fs13.promises.readFile(cachePath, "utf8");
     return { models: parseCodexCatalog(raw), source: "codex-cache" };
   } catch (err) {
     const missing = err.code === "ENOENT";
     return {
-      models: builtinModels(id),
+      models: builtinModels("codex"),
       source: "builtin",
       ...missing ? {} : { error: errorMessage(err) }
     };
   }
 }
+function createModelCatalog(opts) {
+  const fetchClaude = opts.fetchClaude ?? (() => fetchClaudeModels());
+  const fetchCodex = opts.fetchCodex ?? (() => fetchCodexModels(opts.version));
+  const inFlight = /* @__PURE__ */ new Map();
+  const settled = /* @__PURE__ */ new Map();
+  const fallback = (id) => id === "codex" ? readCodexCache(opts.codexHome ?? defaultCodexHome()) : Promise.resolve({ models: builtinModels(id), source: "builtin" });
+  const ask = async (id) => {
+    try {
+      const models = await (id === "codex" ? fetchCodex() : fetchClaude());
+      return { models, source: id === "codex" ? "codex-app-server" : "claude-cli" };
+    } catch (err) {
+      const list = await fallback(id);
+      return {
+        ...list,
+        error: errorMessage(err),
+        ...err instanceof CodexLoginRequiredError ? { loginRequired: true } : {}
+      };
+    }
+  };
+  const refresh = (id) => {
+    const running = inFlight.get(id);
+    if (running) return running;
+    const pending = ask(id).then((list) => {
+      settled.set(id, list);
+      return list;
+    }).finally(() => inFlight.delete(id));
+    inFlight.set(id, pending);
+    return pending;
+  };
+  return {
+    async get(id) {
+      const answer = settled.get(id);
+      if (answer) return answer;
+      const list = await fallback(id);
+      return inFlight.has(id) ? { ...list, pending: true } : list;
+    },
+    refresh,
+    warm() {
+      for (const agent of AGENT_CLIS) void refresh(agent.id);
+    },
+    findModel(id, modelId) {
+      return settled.get(id)?.models.find((model) => model.id === modelId);
+    }
+  };
+}
+
+// packages/core/src/service.ts
+init_effort();
 
 // packages/core/src/github-auth.ts
 init_env();
@@ -5015,45 +5633,45 @@ function startGitHubCliLogin(onEvent) {
 }
 
 // packages/core/src/board-cli.ts
-import fs13 from "fs";
-import path17 from "path";
+import fs14 from "fs";
+import path18 from "path";
 import { pathToFileURL } from "url";
 async function boardCliLaunchInfo() {
-  const storeDir = path17.dirname(getStorePath());
+  const storeDir = path18.dirname(getStorePath());
   const entry = getPlatform().cliEntry?.();
-  if (entry && fs13.existsSync(entry)) return { storeDir, cliPath: entry };
+  if (entry && fs14.existsSync(entry)) return { storeDir, cliPath: entry };
   const root = getPlatform().sourceRoot();
   if (!root) return { storeDir };
-  const cliPath = path17.join(root, "scripts", "vibeflow.mjs");
-  const loaderPath = path17.join(root, "test", "support", "register.mjs");
-  if (!fs13.existsSync(cliPath) || !fs13.existsSync(loaderPath)) return { storeDir };
+  const cliPath = path18.join(root, "scripts", "vibeflow.mjs");
+  const loaderPath = path18.join(root, "test", "support", "register.mjs");
+  if (!fs14.existsSync(cliPath) || !fs14.existsSync(loaderPath)) return { storeDir };
   return { storeDir, cliPath, loaderPath: pathToFileURL(loaderPath).href };
 }
 
 // packages/core/src/decisions.ts
-import fs14 from "fs";
-import path18 from "path";
+import fs15 from "fs";
+import path19 from "path";
 var DECISIONS_FILE_SUFFIX = ".DECISIONS.md";
 function decisionsKey(worktreePath, branch) {
-  return worktreePath ? path18.basename(worktreePath) : branch.replace(/\//g, "-");
+  return worktreePath ? path19.basename(worktreePath) : branch.replace(/\//g, "-");
 }
 function decisionsPath(workspacePath, key) {
-  return path18.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
+  return path19.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
 }
 function deleteDecisions(workspacePath, key) {
   try {
-    fs14.rmSync(decisionsPath(workspacePath, key), { force: true });
+    fs15.rmSync(decisionsPath(workspacePath, key), { force: true });
   } catch {
   }
 }
 
 // packages/core/src/specs.ts
-import fs15 from "fs";
-import path19 from "path";
+import fs16 from "fs";
+import path20 from "path";
 var SPEC_FILE_NAME = "spec.md";
 var MAX_SPEC_BYTES = 256 * 1024;
 function isSpecPath(p) {
-  return path19.posix.basename(p) === SPEC_FILE_NAME;
+  return path20.posix.basename(p) === SPEC_FILE_NAME;
 }
 function clip2(buf) {
   return {
@@ -5068,10 +5686,10 @@ async function readWorktreeSpecs(worktreePath, baseBranch) {
   for (const entry of entries) {
     if (entry.status === "D" || !isSpecPath(entry.path)) continue;
     try {
-      const full = path19.join(worktreePath, entry.path);
-      const stat = fs15.statSync(full);
+      const full = path20.join(worktreePath, entry.path);
+      const stat = fs16.statSync(full);
       if (!stat.isFile()) continue;
-      specs.push({ path: entry.path, ...clip2(fs15.readFileSync(full)), updatedAt: stat.mtimeMs });
+      specs.push({ path: entry.path, ...clip2(fs16.readFileSync(full)), updatedAt: stat.mtimeMs });
     } catch {
     }
   }
@@ -5136,7 +5754,7 @@ async function readSpecsAt(cwd, ref, paths) {
 // packages/core/src/chat-session.ts
 init_env();
 init_git_bash();
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // packages/core/src/chat-store.ts
@@ -5184,7 +5802,7 @@ function clearMessages(taskId, newSessionId) {
 
 // packages/core/src/chat-session.ts
 init_attachments();
-function basename(p) {
+function basename2(p) {
   return p.split("/").pop() ?? p;
 }
 function truncate(s, n) {
@@ -5200,14 +5818,14 @@ function summarizeToolUse(name, input) {
       break;
     }
     case "Read":
-      summary = `Reading \`${basename(String(input.file_path ?? ""))}\``;
+      summary = `Reading \`${basename2(String(input.file_path ?? ""))}\``;
       break;
     case "Write":
-      summary = `Writing \`${basename(String(input.file_path ?? ""))}\``;
+      summary = `Writing \`${basename2(String(input.file_path ?? ""))}\``;
       break;
     case "Edit":
     case "MultiEdit":
-      summary = `Editing \`${basename(String(input.file_path ?? ""))}\``;
+      summary = `Editing \`${basename2(String(input.file_path ?? ""))}\``;
       break;
     case "Glob":
     case "Grep":
@@ -5292,7 +5910,7 @@ ${attachmentLines.join("\n")}` : text;
     `--append-system-prompt ${quote(systemPrompt)}`,
     quote(fullText)
   ].filter(Boolean).join(" ") : buildRawAgentCommand(agentCli, model, fullText, systemPrompt, worktreePath, quote, workspacePath);
-  const proc = spawn5(shell.command, shell.args(cmd), {
+  const proc = spawn6(shell.command, shell.args(cmd), {
     cwd: worktreePath,
     env: execEnv()
   });
@@ -5418,20 +6036,22 @@ function startChatSend(opts, sender) {
 
 // packages/core/src/service.ts
 init_attachments();
+init_launch();
 
 // packages/core/src/progress-tracker.ts
 init_progress();
-import fs16 from "fs";
-import os5 from "os";
-import path20 from "path";
+init_launch();
+import fs17 from "fs";
+import os7 from "os";
+import path21 from "path";
 var SINCE_SLACK_MS = 5e3;
 function claudeProjectDir(home, cwd) {
-  return path20.join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+  return path21.join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
 }
 function pathAliases(p) {
-  const resolved = path20.resolve(p);
+  const resolved = path21.resolve(p);
   try {
-    const real = fs16.realpathSync(resolved);
+    const real = fs17.realpathSync(resolved);
     return real === resolved ? [resolved] : [resolved, real];
   } catch {
     return [resolved];
@@ -5447,7 +6067,7 @@ function samePath(a, b) {
 }
 function listFiles(dir, test) {
   try {
-    return fs16.readdirSync(dir).filter(test).map((name) => path20.join(dir, name));
+    return fs17.readdirSync(dir).filter(test).map((name) => path21.join(dir, name));
   } catch {
     return [];
   }
@@ -5455,22 +6075,22 @@ function listFiles(dir, test) {
 function firstLine(file) {
   let fd;
   try {
-    fd = fs16.openSync(file, "r");
+    fd = fs17.openSync(file, "r");
     const buf = Buffer.alloc(64 * 1024);
-    const n = fs16.readSync(fd, buf, 0, buf.length, 0);
+    const n = fs17.readSync(fd, buf, 0, buf.length, 0);
     const text = buf.subarray(0, n).toString("utf8");
     const nl = text.indexOf("\n");
     return nl === -1 ? null : text.slice(0, nl);
   } catch {
     return null;
   } finally {
-    if (fd !== void 0) fs16.closeSync(fd);
+    if (fd !== void 0) fs17.closeSync(fd);
   }
 }
 function advance(file, cursor, reduce, initial) {
   let size;
   try {
-    size = fs16.statSync(file).size;
+    size = fs17.statSync(file).size;
   } catch {
     return;
   }
@@ -5482,9 +6102,9 @@ function advance(file, cursor, reduce, initial) {
   if (size === cursor.offset) return;
   let fd;
   try {
-    fd = fs16.openSync(file, "r");
+    fd = fs17.openSync(file, "r");
     const chunk = Buffer.alloc(size - cursor.offset);
-    const n = fs16.readSync(fd, chunk, 0, chunk.length, cursor.offset);
+    const n = fs17.readSync(fd, chunk, 0, chunk.length, cursor.offset);
     cursor.offset += n;
     const data = Buffer.concat([cursor.rest, chunk.subarray(0, n)]);
     const nl = data.lastIndexOf(10);
@@ -5498,7 +6118,7 @@ function advance(file, cursor, reduce, initial) {
     }
   } catch {
   } finally {
-    if (fd !== void 0) fs16.closeSync(fd);
+    if (fd !== void 0) fs17.closeSync(fd);
   }
 }
 function newCursor(state) {
@@ -5517,14 +6137,14 @@ function codexDayDirs(sessionsRoot, since) {
   const cur = new Date(start.getFullYear(), start.getMonth(), start.getDate());
   while (cur <= end) {
     const pad = (n) => String(n).padStart(2, "0");
-    days.push(path20.join(sessionsRoot, String(cur.getFullYear()), pad(cur.getMonth() + 1), pad(cur.getDate())));
+    days.push(path21.join(sessionsRoot, String(cur.getFullYear()), pad(cur.getMonth() + 1), pad(cur.getDate())));
     cur.setDate(cur.getDate() + 1);
   }
   return days;
 }
 function createProgressTracker(opts) {
-  const home = opts.homeDir ?? os5.homedir();
-  const codexHomes = opts.codexHomes ?? (() => [path20.join(home, ".codex")]);
+  const home = opts.homeDir ?? os7.homedir();
+  const codexHomes = opts.codexHomes ?? (() => [path21.join(home, ".codex")]);
   const pollMs = opts.pollMs ?? 2e3;
   const entries = /* @__PURE__ */ new Map();
   const belongsToRun = (target, startedAt) => target.since == null || startedAt != null && startedAt >= target.since - SINCE_SLACK_MS;
@@ -5533,7 +6153,7 @@ function createProgressTracker(opts) {
     const dirs = pathAliases(target.worktreePath).map((p) => claudeProjectDir(home, p));
     for (const file of dirs.flatMap((dir) => listFiles(dir, (n) => n.endsWith(".jsonl")))) {
       if (entry.claude.has(file) || entry.rejected.has(file)) continue;
-      const session = path20.basename(file, ".jsonl");
+      const session = path21.basename(file, ".jsonl");
       if (session !== target.sessionId) {
         const head = firstLine(file);
         if (head == null) continue;
@@ -5546,8 +6166,8 @@ function createProgressTracker(opts) {
       entry.claude.set(file, newCursor(initialClaudeState()));
     }
     for (const file of Array.from(entry.claude.keys())) {
-      if (file.includes(`${path20.sep}subagents${path20.sep}`)) continue;
-      const sub = path20.join(file.slice(0, -".jsonl".length), "subagents");
+      if (file.includes(`${path21.sep}subagents${path21.sep}`)) continue;
+      const sub = path21.join(file.slice(0, -".jsonl".length), "subagents");
       for (const f of listFiles(sub, (n) => n.endsWith(".jsonl"))) {
         if (!entry.claude.has(f)) entry.claude.set(f, newCursor(initialClaudeState()));
       }
@@ -5556,7 +6176,7 @@ function createProgressTracker(opts) {
   function discoverCodex(entry) {
     const { target } = entry;
     for (const codexHome of codexHomes()) {
-      for (const day of codexDayDirs(path20.join(codexHome, "sessions"), target.since)) {
+      for (const day of codexDayDirs(path21.join(codexHome, "sessions"), target.since)) {
         for (const file of listFiles(day, (n) => n.startsWith("rollout-") && n.endsWith(".jsonl"))) {
           if (entry.codex.has(file) || entry.rejected.has(file)) continue;
           const head = firstLine(file);
@@ -5573,11 +6193,11 @@ function createProgressTracker(opts) {
     }
   }
   function drainHooks(entry) {
-    const dir = path20.join(entry.target.worktreePath, PROGRESS_EVENTS_DIR);
+    const dir = path21.join(entry.target.worktreePath, PROGRESS_EVENTS_DIR);
     for (const file of listFiles(dir, (n) => n.endsWith(".json")).sort()) {
       try {
-        const at = fs16.statSync(file).mtimeMs;
-        const event = JSON.parse(fs16.readFileSync(file, "utf8"));
+        const at = fs17.statSync(file).mtimeMs;
+        const event = JSON.parse(fs17.readFileSync(file, "utf8"));
         const foreign = entry.target.sessionId && typeof event.session_id === "string" && event.session_id !== entry.target.sessionId;
         const activity = foreign ? null : activityFromHook(event, at);
         if (activity) entry.hookActivity = latestActivity(entry.hookActivity ?? activity, activity);
@@ -5585,7 +6205,7 @@ function createProgressTracker(opts) {
         continue;
       }
       try {
-        fs16.unlinkSync(file);
+        fs17.unlinkSync(file);
       } catch {
       }
     }
@@ -5597,8 +6217,8 @@ function createProgressTracker(opts) {
     if (target.agent === "claude") {
       for (const [file, cursor] of entry.claude) {
         runUsage = addUsage(runUsage, claudeUsageTotal(cursor.state));
-        if (file.includes(`${path20.sep}subagents${path20.sep}`)) continue;
-        const isExecutor = path20.basename(file, ".jsonl") === target.sessionId;
+        if (file.includes(`${path21.sep}subagents${path21.sep}`)) continue;
+        const isExecutor = path21.basename(file, ".jsonl") === target.sessionId;
         const s = cursor.state;
         if (isExecutor || !target.sessionId && (!primary || (s.startedAt ?? 0) > (primary.startedAt ?? 0))) {
           primary = { todos: s.todos, contextTokens: s.contextTokens, activity: s.activity, startedAt: s.startedAt };
@@ -5677,10 +6297,10 @@ function createProgressTracker(opts) {
       };
       entry.timer.unref?.();
       entries.set(target.taskId, entry);
-      const eventsDir = path20.join(target.worktreePath, PROGRESS_EVENTS_DIR);
+      const eventsDir = path21.join(target.worktreePath, PROGRESS_EVENTS_DIR);
       try {
-        fs16.mkdirSync(eventsDir, { recursive: true });
-        entry.watcher = fs16.watch(eventsDir, () => {
+        fs17.mkdirSync(eventsDir, { recursive: true });
+        entry.watcher = fs17.watch(eventsDir, () => {
           if (entry.pending) return;
           entry.pending = setTimeout(() => {
             entry.pending = null;
@@ -5765,17 +6385,18 @@ function validBoard(value) {
   }
   return next;
 }
-function createCore({ sessions, bus, version, homeDir }) {
+function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatus, modelCatalog }) {
   const sink = bus.sink();
+  const models = modelCatalog ?? createModelCatalog({ version });
   let libraryCodexHome = null;
   void libraryRoot().then((root) => {
     libraryCodexHome = libraryPaths(root).codexHome;
   }).catch(() => {
   });
-  const home = homeDir ?? os6.homedir();
+  const home = homeDir ?? os8.homedir();
   const progress = createProgressTracker({
     homeDir: home,
-    codexHomes: () => [path21.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
+    codexHomes: () => [path22.join(home, ".codex"), ...libraryCodexHome ? [libraryCodexHome] : []],
     onUpdate: (taskId, value) => bus.emit("progress:update", { taskId, progress: value }),
     onNotify: (taskId, list) => {
       const prefs = resolveNotificationSettings(getSettings());
@@ -5839,12 +6460,16 @@ function createCore({ sessions, bus, version, homeDir }) {
     requireTask(key.split(":")[0]);
     return key;
   }
+  function launchEffort(task) {
+    const model = models.findModel(taskAgent(task), taskModel(task));
+    return model?.efforts ? clampEffort(task.effort, model.efforts) : task.effort;
+  }
   async function launchCommand(task, intent) {
     const settings = getSettings();
     const library = await libraryLaunchInfo(task.worktreePath);
     const boardCli = await boardCliLaunchInfo();
     return buildAgentCommand(
-      task,
+      { ...task, effort: launchEffort(task) },
       settings.systemPrompt ?? "",
       {
         resume: intent.resume === true,
@@ -5858,13 +6483,13 @@ function createCore({ sessions, bus, version, homeDir }) {
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path21.join(os6.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path22.join(os8.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
   }
   async function removeTaskWorktree(task) {
     if (!task.projectPath || !task.worktreePath) return;
     const branch = task.branch || fallbackBranchName(task.id);
     await removeWorktree(task.projectPath, task.worktreePath);
-    deleteArtifacts(task.workspacePath ?? path21.dirname(task.worktreePath), task.worktreePath);
+    deleteArtifacts(task.workspacePath ?? path22.dirname(task.worktreePath), task.worktreePath);
     await deleteBranch(task.projectPath, branch);
   }
   function columnOf(taskId) {
@@ -5907,6 +6532,11 @@ function createCore({ sessions, bus, version, homeDir }) {
     bus.emit("state:changed", getState());
   }
   let folderDialog = null;
+  const github = createGithubService({
+    run: ghRunner,
+    authStatus: githubAuthStatus ?? getGitHubCliAuthStatus,
+    repoOf: async (projectPath) => parseGithubRepo((await getGitInfo(projectPath)).remoteUrl)
+  });
   const handlers = {
     "vibeflow:getState": () => getState(),
     // A card's progress right now (todo list, usage, activity), for a frontend
@@ -5937,10 +6567,21 @@ function createCore({ sessions, bus, version, homeDir }) {
       cancelGitHubCliLogin();
     },
     "settings:logoutGithubAuth": () => logoutGitHubCli(),
+    // Open Issues/PRs of the board's GitHub repos that involve the signed-in
+    // `gh` user; cached per repo, `force` refetches.
+    "github:inbox": async (payload) => {
+      const p = payload === void 0 ? {} : obj(payload, "payload");
+      return github.inbox(getState().board, { force: p.force === true });
+    },
+    "github:taskLinks": async (payload) => {
+      const p = payload === void 0 ? {} : obj(payload, "payload");
+      return github.taskLinks(getState().board, { force: p.force === true });
+    },
     "env:detectAgents": () => detectAgents(),
     "agents:listModels": (payload) => {
       const { agentId: rawId, refresh } = obj(payload, "payload");
-      return listAgentModels(agentId(rawId), { refresh: refresh === true });
+      const id = agentId(rawId);
+      return refresh === true ? models.refresh(id) : models.get(id);
     },
     // A task does not exist yet when a project is picked, so these two are the
     // ones that must take a path. They only inspect or `git init` it.
@@ -5954,8 +6595,8 @@ function createCore({ sessions, bus, version, homeDir }) {
     "projects:listRecent": () => listRecentProjects(getStore()),
     // `vibeflow open <path>` while a host runs: only the host writes the store.
     "projects:record": (projectPath) => {
-      const p = path21.resolve(str(projectPath, "projectPath"));
-      if (!fs17.existsSync(p) || !fs17.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
+      const p = path22.resolve(str(projectPath, "projectPath"));
+      if (!fs18.existsSync(p) || !fs18.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
       recordRecentProject(getStore(), p);
       return listRecentProjects(getStore());
     },
@@ -5966,6 +6607,7 @@ function createCore({ sessions, bus, version, homeDir }) {
       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");
+      if (p.github !== void 0 && !isGithubRef(p.github)) invalid("github must be an issue or pr ref on github.com");
       const { task } = await createTaskFromInput({
         projectPath: p.projectPath,
         title: p.title,
@@ -5977,7 +6619,8 @@ function createCore({ sessions, bus, version, homeDir }) {
         model: p.model,
         effort: p.effort,
         autoMode: p.autoMode,
-        attachments: p.attachments
+        attachments: p.attachments,
+        github: p.github
       });
       return { state: getState(), task };
     },
@@ -6004,7 +6647,7 @@ function createCore({ sessions, bus, version, homeDir }) {
       if (!task.baseBranch) throw new Error("\u4EFB\u52D9\u6C92\u6709\u8A18\u9304 base branch\uFF0C\u7121\u6CD5\u9084\u539F worktree");
       await teardownTask(task.id);
       await resetWorktreeToBase(task.worktreePath, task.baseBranch);
-      const workspacePath = task.workspacePath ?? path21.dirname(task.worktreePath);
+      const workspacePath = task.workspacePath ?? path22.dirname(task.worktreePath);
       deleteArtifacts(workspacePath, task.worktreePath);
       deleteDecisions(workspacePath, decisionsKey(task.worktreePath, task.branch));
       resetSubAgents(task.worktreePath);
@@ -6028,6 +6671,7 @@ function createCore({ sessions, bus, version, homeDir }) {
       if (columnOf(existing.id) !== "backlog") {
         throw new Error("\u53EA\u6709 Backlog \u7684\u4EFB\u52D9\u53EF\u4EE5\u7DE8\u8F2F");
       }
+      if (p.effort !== void 0 && !AGENT_EFFORTS.includes(p.effort)) invalid("unknown effort");
       let gitPatch = {};
       const nextProject = p.projectPath || existing.projectPath;
       const nextBranch = p.branch === void 0 ? "" : str(p.branch, "branch").trim();
@@ -6047,7 +6691,7 @@ function createCore({ sessions, bus, version, homeDir }) {
         }
         const info = await getGitInfo(nextProject);
         if (!info.isRepo) throw new Error("\u76EE\u6A19\u8CC7\u6599\u593E\u4E0D\u662F git repository");
-        const projectName = path21.basename(nextProject);
+        const projectName = path22.basename(nextProject);
         const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
         await teardownTask(existing.id);
         await removeTaskWorktree(existing);
@@ -6141,7 +6785,7 @@ function createCore({ sessions, bus, version, homeDir }) {
     "claude:sessionExists": (taskId) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return false;
-      return fs17.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
+      return fs18.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
     },
     "sessions:list": async () => {
       const keys = await sessions.list();
@@ -6188,17 +6832,17 @@ function createCore({ sessions, bus, version, homeDir }) {
       const task = requireTask(taskId);
       if (!task.worktreePath || !task.workspacePath) return "task has no worktree";
       const dir = agentArtifactsPath(task.workspacePath, task.worktreePath);
-      if (!fs17.existsSync(dir)) return "artifacts directory does not exist yet";
+      if (!fs18.existsSync(dir)) return "artifacts directory does not exist yet";
       return getPlatform().openPath(dir);
     },
     "task:getSpecs": async (taskId) => {
       const task = requireTask(taskId);
-      const base = task.baseBranch ?? "main";
-      if (task.worktreePath) return readWorktreeSpecs(task.worktreePath, base);
+      const base2 = task.baseBranch ?? "main";
+      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 [];
       const changed = task.outcome?.files.filter((f) => f.status !== "D").map((f) => f.path);
-      return readBranchSpecs(task.projectPath, task.branch, base, changed, since);
+      return readBranchSpecs(task.projectPath, task.branch, base2, changed, since);
     },
     "board:getCliLaunchInfo": () => boardCliLaunchInfo(),
     "library:list": async () => listLibrary(await libraryRoot(), builtinSkillsDir()),
@@ -6322,7 +6966,7 @@ function createCore({ sessions, bus, version, homeDir }) {
       }
       await removeTaskWorktree(task);
       if (task.workspacePath) {
-        fs17.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
+        fs18.rmSync(taskAttachmentStagingPath(task.workspacePath, task.id), { recursive: true, force: true });
       }
       clearConversation(task.id);
       removeTask(task.id);
@@ -6375,9 +7019,9 @@ function createCore({ sessions, bus, version, homeDir }) {
     // Watch the containing directory, not the file: JsonStore renames a temp
     // file over the target and so replaces the inode on every save.
     watchStore() {
-      const file = path21.basename(getStorePath());
+      const file = path22.basename(getStorePath());
       let debounce = null;
-      storeWatcher = fs17.watch(path21.dirname(getStorePath()), (_event, filename) => {
+      storeWatcher = fs18.watch(path22.dirname(getStorePath()), (_event, filename) => {
         if (filename !== file) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -6389,6 +7033,9 @@ function createCore({ sessions, bus, version, homeDir }) {
       });
       return () => storeWatcher?.close();
     },
+    warmModelCatalog() {
+      models.warm();
+    },
     shutdown() {
       sessions.shutdown();
       cancelAllChatSends();
@@ -6410,9 +7057,9 @@ function createSessionBackend(sink, choice) {
 }
 
 // packages/core/src/web-server.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import http from "http";
-import path22 from "path";
+import path23 from "path";
 import { timingSafeEqual } from "crypto";
 import { WebSocketServer } from "ws";
 var TOKEN_COOKIE = "vf_token";
@@ -6465,14 +7112,14 @@ function resolveStatic(root, urlPath) {
     return null;
   }
   if (decoded.includes("\0")) return null;
-  const rel = path22.posix.normalize(decoded).replace(/^\/+/, "");
-  const base = path22.resolve(root);
-  const candidates = [rel, path22.posix.join(rel, "index.html"), `${rel}.html`];
+  const rel = path23.posix.normalize(decoded).replace(/^\/+/, "");
+  const base2 = path23.resolve(root);
+  const candidates = [rel, path23.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path22.resolve(base, c);
-    if (full !== base && !full.startsWith(base + path22.sep)) return null;
+    const full = path23.resolve(base2, c);
+    if (full !== base2 && !full.startsWith(base2 + path23.sep)) return null;
     try {
-      if (fs18.statSync(full).isFile()) return full;
+      if (fs19.statSync(full).isFile()) return full;
     } catch {
     }
   }
@@ -6533,7 +7180,7 @@ async function startWebServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const ext = path22.extname(file).toLowerCase();
+    const ext = path23.extname(file).toLowerCase();
     const immutable = url.pathname.startsWith("/_next/static/");
     res.writeHead(200, {
       "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream",
@@ -6546,7 +7193,7 @@ async function startWebServer(options) {
       res.end();
       return;
     }
-    fs18.createReadStream(file).pipe(res);
+    fs19.createReadStream(file).pipe(res);
   }
   const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
   function reject(socket, status, reason) {
@@ -6710,6 +7357,7 @@ async function startHost(options) {
     lock.port = server.port;
     updateLock(options.userDataDir, lock);
     const stopWatch = core.watchStore();
+    core.warmModelCatalog();
     const stop = () => stopping ??= (async () => {
       stopWatch();
       core.shutdown();
@@ -6726,7 +7374,7 @@ function loginUrl(lock, pathname = "/home/") {
   return `http://127.0.0.1:${lock.port}${pathname}?token=${encodeURIComponent(lock.token)}`;
 }
 function isWebDir(dir) {
-  return fs19.existsSync(path23.join(dir, "home", "index.html"));
+  return fs20.existsSync(path24.join(dir, "home", "index.html"));
 }
 
 // packages/cli/src/remote.ts
@@ -6843,8 +7491,8 @@ function connectToHost(lock) {
 }
 
 // packages/cli/src/doctor.ts
-import fs20 from "fs";
-import path24 from "path";
+import fs21 from "fs";
+import path25 from "path";
 import { execFile as execFile8 } from "child_process";
 import { promisify as promisify5 } from "util";
 init_env();
@@ -6984,10 +7632,10 @@ async function runDoctor(options) {
     });
   }
   try {
-    fs20.mkdirSync(options.userDataDir, { recursive: true });
-    const probe = path24.join(options.userDataDir, `.doctor-${process.pid}`);
-    fs20.writeFileSync(probe, "");
-    fs20.rmSync(probe);
+    fs21.mkdirSync(options.userDataDir, { recursive: true });
+    const probe = path25.join(options.userDataDir, `.doctor-${process.pid}`);
+    fs21.writeFileSync(probe, "");
+    fs21.rmSync(probe);
     checks.push({ id: "data", name: "\u8CC7\u6599\u76EE\u9304", level: "ok", detail: options.userDataDir });
   } catch (err) {
     checks.push({
@@ -7041,24 +7689,24 @@ Options:
 `.trim();
 function detectLayout() {
   const file = fileURLToPath(import.meta.url);
-  const here = path27.dirname(file);
-  const bundledWeb = path27.join(here, "web");
-  if (isWebDir(bundledWeb) || path27.basename(here) === "dist") {
+  const here = path28.dirname(file);
+  const bundledWeb = path28.join(here, "web");
+  if (isWebDir(bundledWeb) || path28.basename(here) === "dist") {
     return {
-      version: readVersion(path27.join(here, "..", "package.json")),
+      version: readVersion(path28.join(here, "..", "package.json")),
       webDir: isWebDir(bundledWeb) ? bundledWeb : null,
       sourceRoot: null,
       cliEntry: file
     };
   }
-  const root = path27.resolve(here, "..", "..", "..");
+  const root = path28.resolve(here, "..", "..", "..");
   const override = process.env.VIBEFLOW_WEB_DIR;
-  const webDir = override && isWebDir(override) ? override : isWebDir(path27.join(root, "app")) ? path27.join(root, "app") : null;
-  return { version: readVersion(path27.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
+  const webDir = override && isWebDir(override) ? override : isWebDir(path28.join(root, "app")) ? path28.join(root, "app") : null;
+  return { version: readVersion(path28.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
 }
 function readVersion(pkgPath) {
   try {
-    return JSON.parse(fs22.readFileSync(pkgPath, "utf8")).version;
+    return JSON.parse(fs23.readFileSync(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -7264,8 +7912,8 @@ async function cmdOpen(values, target, layout, userDataDir) {
     console.error("\u7528\u6CD5\uFF1Avibeflow open <path>");
     return 1;
   }
-  const dir = path27.resolve(target);
-  if (!fs22.existsSync(dir) || !fs22.statSync(dir).isDirectory()) {
+  const dir = path28.resolve(target);
+  if (!fs23.existsSync(dir) || !fs23.statSync(dir).isDirectory()) {
     console.error(`\u4E0D\u662F\u8CC7\u6599\u593E\uFF1A${dir}`);
     return 1;
   }