@kw-yeh/vibeflow 4.0.5 → 4.1.0

package/dist/vibeflow.mjs

@@ -598,9 +598,9 @@ var init_attachments = __esm({
 
 // packages/tui/src/task-form.ts
 import { spawnSync } from "child_process";
-import fs17 from "fs";
-import os5 from "os";
-import path21 from "path";
+import fs19 from "fs";
+import os6 from "os";
+import path23 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render, useApp, useInput } from "ink";
 function newFormState(defaultAutoMode, agents) {
@@ -667,7 +667,7 @@ function visibleFields(s, ctx) {
   return fields;
 }
 function modelOptions(ctx, agentCli, current) {
-  const listed = ctx.connections[agentCli]?.models ?? [];
+  const listed = ctx.models[agentCli] ?? [];
   const options = ["", ...listed];
   if (current && !listed.includes(current)) options.push(current);
   return options;
@@ -719,17 +719,17 @@ function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs17.mkdtempSync(path21.join(os5.tmpdir(), "vibeflow-"));
-  const file = path21.join(dir, "description.md");
+  const dir = fs19.mkdtempSync(path23.join(os6.tmpdir(), "vibeflow-"));
+  const file = path23.join(dir, "description.md");
   try {
-    fs17.writeFileSync(file, text);
+    fs19.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: fs17.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
+    return { text: fs19.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
   } finally {
-    fs17.rmSync(dir, { recursive: true, force: true });
+    fs19.rmSync(dir, { recursive: true, force: true });
   }
 }
 function cycle(list, current, step) {
@@ -797,10 +797,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(path21.resolve(value2.replace(/^~(?=$|\/)/, os5.homedir())));
+      if (value2) setProject(path23.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path21.resolve(value2.replace(/^~(?=$|\/)/, os5.homedir()));
-      if (!fs17.existsSync(file) || !fs17.statSync(file).isFile()) {
+      const file = path23.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir()));
+      if (!fs19.existsSync(file) || !fs19.statSync(file).isFile()) {
         setMessage(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
         return;
       }
@@ -870,7 +870,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       case "title":
         return s.title || "\uFF08\u4F8B\u5982\uFF1A\u5BE6\u4F5C\u767B\u5165\u9801\u9762\uFF09";
       case "project": {
-        if (projectLocked) return `${s.projectPath ? path21.basename(s.projectPath) : "\u2014"}\uFF08\u4EFB\u52D9\u5DF2\u958B\u59CB\uFF0C\u9396\u5B9A\uFF09`;
+        if (projectLocked) return `${s.projectPath ? path23.basename(s.projectPath) : "\u2014"}\uFF08\u4EFB\u52D9\u5DF2\u958B\u59CB\uFF0C\u9396\u5B9A\uFF09`;
         if (!s.projectPath) return ctx.recent.length ? "\u2190/\u2192 \u9078\u64C7\u4F7F\u7528\u904E\u7684\u5C08\u6848\uFF0C\u6216 Enter \u8F38\u5165\u8DEF\u5F91" : "Enter \u8F38\u5165\u5C08\u6848\u8CC7\u6599\u593E\u7684\u7D55\u5C0D\u8DEF\u5F91";
         return `${s.projectPath}${missing ? "\uFF08\u8DEF\u5F91\u907A\u5931\uFF09" : ""}`;
       }
@@ -881,7 +881,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       case "branch":
         return s.branch || "\uFF08\u7559\u7A7A\u5247\u81EA\u52D5\u547D\u540D\uFF0C\u4F8B\u5982 feature/login-fix\uFF09";
       case "attachments":
-        return s.attachments.length ? s.attachments.map((a) => path21.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
+        return s.attachments.length ? s.attachments.map((a) => path23.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");
@@ -899,7 +899,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
         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` : "\u5C1A\u672A\u9023\u7DDA\u6216\u7121\u6CD5\u53D6\u5F97 model list\uFF0C\u5C07\u4F7F\u7528\u9810\u8A2D 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 "submit":
         return busy ?? (s.mode === "new" ? "\uFF3B \u5EFA\u7ACB\u4EFB\u52D9 \uFF3D" : "\uFF3B \u5132\u5B58\u8B8A\u66F4 \uFF3D");
     }
@@ -912,7 +912,7 @@ function FormView({ api, ctx, initial, initialFocus, initialMessage, pristine, o
       if (info && !info.isRepo) return "\u9019\u500B\u8CC7\u6599\u593E\u4E0D\u662F Git repository\u3002\u8ACB\u6539\u9078\u4E00\u500B Git \u5C08\u6848\uFF0C\u6216\u5728\u4E0B\u65B9\u521D\u59CB\u5316\u3002";
       if (s.mode === "edit" && projectChanged(s)) return "\u66F4\u63DB\u5C08\u6848\u6703\u5728\u65B0\u5C08\u6848\u91CD\u5EFA worktree\uFF08\u6B64\u4EFB\u52D9\u5C1A\u672A\u958B\u59CB\uFF0C\u7121\u8B8A\u66F4\u6703\u907A\u5931\uFF09\u3002";
       if (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"}/${path21.basename(s.projectPath)}`;
+      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path23.basename(s.projectPath)}`;
     }
     if (field === "branch") return info?.hasRemote ? "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\uFF1B\u82E5 remote \u5DF2\u6709\u9019\u500B\u5206\u652F\uFF0C\u5247\u76F4\u63A5\u53D6\u56DE\u4E26\u63A5\u7E8C\u4E0A\u9762\u7684\u5DE5\u4F5C\u3002" : "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u3002";
     if (field === "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`;
@@ -967,11 +967,17 @@ async function loadFormContext(api) {
     api.listRecentProjects(),
     Promise.race([api.detectAgents(), timeout]).catch(() => null)
   ]).finally(() => clearTimeout(timer));
+  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 {
     ctx: {
       recent,
       agents,
-      connections: state.settings.agentConnections ?? {},
+      models: Object.fromEntries(lists),
       workstationPath: state.settings.workstationPath?.trim() ?? ""
     },
     autoMode: state.settings.autoMode
@@ -1023,7 +1029,7 @@ __export(src_exports, {
   showDiff: () => showDiff
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import path22 from "path";
+import path24 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) {
@@ -1285,7 +1291,7 @@ function showDiff(task) {
   });
 }
 function tmuxAttach(opts, sessionName) {
-  const conf = path22.join(opts.userDataDir, "tmux.conf");
+  const conf = path24.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 : "" } });
@@ -1415,8 +1421,8 @@ var init_src = __esm({
 });
 
 // packages/cli/src/main.ts
-import fs18 from "fs";
-import path23 from "path";
+import fs20 from "fs";
+import path25 from "path";
 import { fileURLToPath } from "url";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -1520,6 +1526,12 @@ function createNodePlatform(options = {}) {
     userDataDir: () => userData,
     sourceRoot: () => root,
     cliEntry: () => options.cliEntry ?? null,
+    builtinSkillsDir: () => {
+      if (options.builtinSkillsDir !== void 0) return options.builtinSkillsDir;
+      if (options.cliEntry) return path2.join(path2.dirname(options.cliEntry), "builtin-skills");
+      if (root) return path2.join(root, "packages", "core", "builtin-skills");
+      return null;
+    },
     openExternal: async (url) => {
       const err = await openWithOs(url);
       if (err) throw new Error(err);
@@ -1681,6 +1693,11 @@ function migrateStore(store) {
   if (!store.has("recentProjects")) {
     store.set("recentProjects", recentProjectsFromBoard(store.get("board")));
   }
+  const settings = store.get("settings");
+  if (settings && "agentConnections" in settings) {
+    const { agentConnections: _dropped, ...rest } = settings;
+    store.set("settings", rest);
+  }
   if (persistedVersion < STATE_VERSION) {
     store.set("version", STATE_VERSION);
   }
@@ -1760,8 +1777,6 @@ function createBridge(t) {
     },
     setBoard: (board) => t.invoke("vibeflow:setBoard", board),
     setSettings: (patch) => t.invoke("vibeflow:setSettings", patch),
-    connectAgent: (agentId2, apiKey) => t.invoke("settings:connectAgent", { agentId: agentId2, apiKey }),
-    refreshAgentModels: (agentId2) => t.invoke("settings:refreshAgentModels", agentId2),
     getGithubAuthStatus: () => t.invoke("settings:githubAuthStatus"),
     startGithubAuthLogin: () => t.invoke("settings:startGithubAuthLogin"),
     cancelGithubAuthLogin: () => t.invoke("settings:cancelGithubAuthLogin"),
@@ -1776,6 +1791,8 @@ function createBridge(t) {
     initRepository: (projectPath) => t.invoke("git:initRepository", projectPath),
     /** Agent CLIs (claude / codex) actually installed on PATH. */
     detectAgents: () => t.invoke("env:detectAgents"),
+    /** Models the agent's own CLI offers; `refresh` asks the CLI instead of its cache. */
+    listAgentModels: (agentId2, refresh = false) => t.invoke("agents:listModels", { agentId: agentId2, refresh }),
     createTask: (payload) => t.invoke("vibeflow:createTask", payload),
     updateTask: (payload) => t.invoke("vibeflow:updateTask", payload),
     /** Clear prior execution state and prepare a fresh run of this task. */
@@ -1810,6 +1827,10 @@ function createBridge(t) {
     setLibraryEntryDescription: (payload) => t.invoke("library:setDescription", payload),
     setLibraryEntryEnabled: (payload) => t.invoke("library:setEnabled", payload),
     deleteLibraryEntry: (payload) => t.invoke("library:delete", payload),
+    /** Overwrite or bring back a shipped skill with the version this install carries. */
+    restoreBuiltinSkill: (payload) => t.invoke("library:restoreBuiltin", payload),
+    /** Shipped skills the user deleted, offered for restore. */
+    listRemovedBuiltinSkills: () => t.invoke("library:removedBuiltins"),
     approve: (taskId, message) => t.invoke("git:approve", { taskId, message }),
     /** Use the task's agent CLI to generate a commit message for branch changes. */
     generateCommitMessage: (taskId) => t.invoke("git:generateCommitMessage", taskId),
@@ -2680,7 +2701,41 @@ async function copyIgnoredEntry(projectPath, worktreePath, entry) {
   const src = path12.join(projectPath, entry);
   const dest = path12.join(worktreePath, entry);
   await fs8.mkdir(path12.dirname(dest), { recursive: true });
-  await fs8.cp(src, dest, { recursive: true });
+  await fs8.cp(src, dest, {
+    recursive: true,
+    filter: async (from, to) => {
+      if (!(await fs8.lstat(from)).isSymbolicLink()) return true;
+      await copyIgnoredLink(projectPath, worktreePath, from, to);
+      return false;
+    }
+  });
+}
+async function copyIgnoredLink(projectPath, worktreePath, from, to) {
+  const raw = (await fs8.readlink(from)).replace(/^\\\\\?\\/, "");
+  const resolved = path12.resolve(path12.dirname(from), raw);
+  const inProject = path12.relative(projectPath, resolved);
+  const insideProject = inProject !== "" && !inProject.startsWith("..") && !path12.isAbsolute(inProject);
+  const target = insideProject ? path12.join(worktreePath, inProject) : resolved;
+  let isDirectory;
+  try {
+    isDirectory = (await fs8.stat(resolved)).isDirectory();
+  } catch {
+    return;
+  }
+  await fs8.mkdir(path12.dirname(to), { recursive: true });
+  if (process.platform !== "win32") {
+    await fs8.symlink(path12.isAbsolute(raw) ? target : raw, to);
+    return;
+  }
+  if (isDirectory) {
+    await fs8.symlink(target, to, "junction");
+    return;
+  }
+  try {
+    await fs8.symlink(target, to, "file");
+  } catch {
+    await fs8.copyFile(resolved, to);
+  }
 }
 async function copySmallIgnoredFiles(projectPath, worktreePath) {
   const entries = await listIgnoredCopyEntries(projectPath);
@@ -3519,8 +3574,8 @@ async function taskCommand(argv) {
 }
 
 // packages/cli/src/host.ts
-import fs15 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path21 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // packages/core/src/events.ts
@@ -3546,178 +3601,725 @@ var EventBus = class {
   }
 };
 
-// packages/core/src/service.ts
-import fs13 from "fs";
-import os4 from "os";
-import path17 from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+// packages/core/src/library-builtins.ts
+import fs11 from "fs";
+import path15 from "path";
 
-// packages/core/src/agent-connections.ts
-function modelIdFromUnknown(value) {
-  if (!value || typeof value !== "object") return null;
-  const id = value.id;
-  return typeof id === "string" && id.trim() ? id.trim() : null;
-}
-function sortModels(ids) {
-  return Array.from(new Set(ids)).sort((a, b) => a.localeCompare(b));
-}
-function providerAuthError(status) {
-  if (status === 401 || status === 403) {
-    return "API key \u7121\u6548\u6216\u6C92\u6709\u6B0A\u9650\uFF0C\u8ACB\u78BA\u8A8D\u5F8C\u91CD\u65B0\u8F38\u5165\u3002";
-  }
-  return `\u53D6\u5F97 model list \u5931\u6557\uFF08HTTP ${status}\uFF09\u3002`;
-}
-async function fetchAgentModels(agentId2, apiKey) {
-  const key = apiKey.trim();
-  if (!key) throw new Error("\u8ACB\u8F38\u5165 API key\u3002");
-  const response = agentId2 === "claude" ? await fetch("https://api.anthropic.com/v1/models", {
-    headers: {
-      "x-api-key": key,
-      "anthropic-version": "2023-06-01"
-    }
-  }) : await fetch("https://api.openai.com/v1/models", {
-    headers: {
-      Authorization: `Bearer ${key}`
-    }
-  });
-  if (!response.ok) {
-    throw new Error(providerAuthError(response.status));
-  }
-  const body = await response.json();
-  const data = Array.isArray(body.data) ? body.data : [];
-  return sortModels(data.map(modelIdFromUnknown).filter((id) => Boolean(id)));
+// packages/core/src/library.ts
+import { createHash } from "crypto";
+import fs10 from "fs";
+import os3 from "os";
+import path14 from "path";
+var LIBRARY_DIR = "library";
+var LIBRARY_KINDS = ["skill", "prompt", "script"];
+var KIND_DIR = {
+  skill: "skills",
+  prompt: "prompts",
+  script: "scripts"
+};
+var INDEX_FILE = "index.json";
+var MAX_NAME_BYTES = 100;
+function libraryPaths(root) {
+  return {
+    root,
+    skills: path14.join(root, KIND_DIR.skill),
+    prompts: path14.join(root, KIND_DIR.prompt),
+    scripts: path14.join(root, KIND_DIR.script),
+    plugin: path14.join(root, "plugin"),
+    codexHome: path14.join(root, "codex-home")
+  };
 }
-
-// packages/core/src/github-auth.ts
-init_env();
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify3 } from "util";
-import * as nodePty3 from "node-pty";
-var pexec3 = promisify3(execFile5);
-var GITHUB_HOST = "github.com";
-var DEVICE_URL = "https://github.com/login/device";
-var activeLogin = null;
-function stripAnsi(value) {
-  return value.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\x07/g, "");
+async function libraryRoot() {
+  return path14.join(getPlatform().userDataDir(), LIBRARY_DIR);
 }
-function normalizeCode(code2) {
-  return code2.replace(/\s+/g, "").toUpperCase();
+function truncateUtf82(value, maxBytes) {
+  let result = "";
+  for (const character of value) {
+    if (Buffer.byteLength(result + character) > maxBytes) break;
+    result += character;
+  }
+  return result;
 }
-function extractDeviceCode(output) {
-  const cleaned = stripAnsi(output);
-  const explicit = cleaned.match(/one-time code:\s*([A-Z0-9-]+)/i);
-  if (explicit?.[1]) return normalizeCode(explicit[1]);
-  const fallback = cleaned.match(/\b([A-Z0-9]{4}-[A-Z0-9]{4})\b/i);
-  return fallback?.[1] ? normalizeCode(fallback[1]) : null;
+function safeLibraryName(name) {
+  const basename2 = name.replace(/\\/g, "/").split("/").pop() ?? "";
+  const cleaned = truncateUtf82(
+    basename2.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
+    MAX_NAME_BYTES
+  );
+  return cleaned && cleaned !== "." && cleaned !== ".." ? cleaned : "untitled";
 }
-function statusFromBody(body) {
-  const accounts = body.hosts?.[GITHUB_HOST] ?? [];
-  const active = accounts.find((account) => account.active) ?? accounts[0];
-  if (!active) return { installed: true, authenticated: false };
-  return {
-    installed: true,
-    authenticated: Boolean(active.login) && !active.error,
-    login: active.login,
-    gitProtocol: active.gitProtocol,
-    error: active.error
-  };
+function entryKey(kind, name) {
+  return `${kind}/${name}`;
 }
-function errorMessage(err) {
-  if (err instanceof Error) return err.message;
-  return String(err);
+function indexPath(root) {
+  return path14.join(root, INDEX_FILE);
 }
-async function getGitHubCliAuthStatus() {
+function readIndexFile(root) {
+  let raw;
   try {
-    const { stdout } = await pexec3(
-      "gh",
-      ["auth", "status", "--hostname", GITHUB_HOST, "--json", "hosts"],
-      {
-        env: execEnv(),
-        timeout: 1e4,
-        windowsHide: true
-      }
-    );
-    const body = JSON.parse(stdout.toString());
-    return statusFromBody(body);
-  } catch (err) {
-    const maybeStdout = err.stdout;
-    if (maybeStdout) {
-      try {
-        const body = JSON.parse(maybeStdout.toString());
-        return statusFromBody(body);
-      } catch {
-      }
+    raw = fs10.readFileSync(indexPath(root), "utf8");
+  } catch {
+    return { version: 1, entries: {} };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && "entries" in parsed) {
+      const entries = parsed.entries;
+      if (entries && typeof entries === "object") return { version: 1, entries };
     }
-    const message = errorMessage(err);
-    return {
-      installed: !/ENOENT|not found/i.test(message),
-      authenticated: false,
-      error: message
-    };
+  } catch {
   }
+  return null;
 }
-async function logoutGitHubCli() {
-  const status = await getGitHubCliAuthStatus();
-  if (!status.installed) throw new Error("\u627E\u4E0D\u5230 GitHub CLI\uFF08gh\uFF09\u3002");
-  if (!status.login) return status;
-  await pexec3(
-    "gh",
-    ["auth", "logout", "--hostname", GITHUB_HOST, "--user", status.login],
-    {
-      env: execEnv(),
-      timeout: 1e4,
-      windowsHide: true
-    }
-  );
-  return getGitHubCliAuthStatus();
+function readIndex(root) {
+  return readIndexFile(root) ?? { version: 1, entries: {} };
 }
-function cancelGitHubCliLogin() {
-  if (!activeLogin) return;
+function indexIsCorrupt(root) {
+  return readIndexFile(root) === null;
+}
+function writeIndex(root, index) {
+  fs10.mkdirSync(root, { recursive: true });
+  const file = indexPath(root);
+  if (indexIsCorrupt(root)) fs10.renameSync(file, `${file}.corrupt-${Date.now()}`);
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs10.writeFileSync(tmp, `${JSON.stringify(index, null, 2)}
+`);
+  fs10.renameSync(tmp, file);
+}
+function ensureLibrary(root) {
+  const paths = libraryPaths(root);
+  for (const kind of LIBRARY_KINDS) {
+    fs10.mkdirSync(path14.join(root, KIND_DIR[kind]), { recursive: true });
+  }
+  return paths;
+}
+function readSkillDescription(skillMdPath) {
+  let content;
   try {
-    activeLogin.kill();
+    content = fs10.readFileSync(skillMdPath, "utf8");
   } catch {
+    return void 0;
   }
-  activeLogin = null;
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return void 0;
+  for (let i = 1; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (line.trim() === "---") break;
+    const match = /^description:\s*(.+)$/.exec(line);
+    if (match) return match[1].trim().replace(/^["']|["']$/g, "");
+  }
+  return void 0;
 }
-function startGitHubCliLogin(onEvent) {
-  cancelGitHubCliLogin();
-  onEvent({ type: "starting" });
-  let output = "";
-  let sentBrowserChoice = false;
-  let emittedCode = null;
-  let continuedAfterCode = false;
-  let completed = false;
-  let proc;
+function entryPath(root, kind, name) {
+  return path14.join(root, KIND_DIR[kind], name);
+}
+var HASH_IGNORED = /* @__PURE__ */ new Set(["__pycache__", ".DS_Store"]);
+function hashSkillDir(dir) {
+  const files = [];
+  const walk = (rel) => {
+    for (const dirent of fs10.readdirSync(path14.join(dir, rel), { withFileTypes: true })) {
+      if (HASH_IGNORED.has(dirent.name)) continue;
+      const child = rel ? `${rel}/${dirent.name}` : dirent.name;
+      if (fs10.statSync(path14.join(dir, child)).isDirectory()) walk(child);
+      else files.push(child);
+    }
+  };
+  walk("");
+  const hash = createHash("sha256");
+  for (const rel of files.sort()) {
+    hash.update(rel).update("\0").update(fs10.readFileSync(path14.join(dir, rel))).update("\0");
+  }
+  return hash.digest("hex");
+}
+function builtinStatus(full, name, recorded, builtinDir) {
   try {
-    proc = nodePty3.spawn(
-      "gh",
-      ["auth", "login", "--hostname", GITHUB_HOST, "--git-protocol", "https"],
-      {
-        name: "xterm-256color",
-        cwd: process.cwd(),
-        env: { ...execEnv(), BROWSER: "true", TERM: "xterm-256color" },
-        cols: 100,
-        rows: 24
+    const modified = hashSkillDir(full) !== recorded;
+    let updateAvailable = false;
+    if (modified && builtinDir) {
+      const shipped = path14.join(builtinDir, name);
+      if (fs10.existsSync(path14.join(shipped, "SKILL.md"))) {
+        updateAvailable = hashSkillDir(shipped) !== recorded;
       }
-    );
-  } catch (err) {
-    onEvent({ type: "error", error: errorMessage(err) });
-    return;
+    }
+    return { modified, updateAvailable };
+  } catch {
+    return { modified: true, updateAvailable: false };
   }
-  activeLogin = proc;
-  proc.onData((data) => {
-    output += data;
-    const cleaned = stripAnsi(output);
-    if (!sentBrowserChoice && cleaned.includes("Login with a web browser")) {
-      sentBrowserChoice = true;
-      proc.write("\r");
+}
+function listLibrary(root, builtinDir) {
+  const index = readIndex(root);
+  const entries = [];
+  for (const kind of LIBRARY_KINDS) {
+    const dir = path14.join(root, KIND_DIR[kind]);
+    let dirents;
+    try {
+      dirents = fs10.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
     }
-    const code2 = extractDeviceCode(output);
-    if (code2 && code2 !== emittedCode) {
-      emittedCode = code2;
-      onEvent({ type: "code", code: code2, url: DEVICE_URL });
+    for (const dirent of dirents) {
+      if (dirent.name.startsWith(".")) continue;
+      const wantsDirectory = kind === "skill";
+      let stat;
+      try {
+        stat = fs10.statSync(path14.join(dir, dirent.name));
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory() !== wantsDirectory) continue;
+      const name = dirent.name;
+      const full = path14.join(dir, name);
+      if (wantsDirectory && !fs10.existsSync(path14.join(full, "SKILL.md"))) continue;
+      const key = entryKey(kind, name);
+      const record = index.entries[key] ?? {};
+      entries.push({
+        key,
+        kind,
+        name,
+        path: full,
+        description: wantsDirectory ? readSkillDescription(path14.join(full, "SKILL.md")) : record.description,
+        sourcePath: record.sourcePath,
+        importedAt: record.importedAt,
+        enabled: record.enabled !== false,
+        builtin: wantsDirectory && record.builtinHash && builtinDir !== void 0 ? builtinStatus(full, name, record.builtinHash, builtinDir) : void 0
+      });
     }
-    if (code2 && !continuedAfterCode) {
+  }
+  return entries.sort((a, b) => a.key.localeCompare(b.key));
+}
+function annotate(root, key, patch) {
+  const index = readIndex(root);
+  index.entries[key] = { ...index.entries[key], ...patch };
+  writeIndex(root, index);
+}
+function importEntry(root, kind, sourcePath) {
+  ensureLibrary(root);
+  const resolved = path14.resolve(sourcePath);
+  const stat = fs10.statSync(resolved);
+  if (kind === "skill") {
+    if (!stat.isDirectory()) throw new Error("skill \u5FC5\u9808\u662F\u542B SKILL.md \u7684\u76EE\u9304");
+    if (!fs10.existsSync(path14.join(resolved, "SKILL.md"))) {
+      throw new Error("\u76EE\u9304\u5167\u627E\u4E0D\u5230 SKILL.md");
+    }
+  } else if (!stat.isFile()) {
+    throw new Error(`${kind} \u5FC5\u9808\u662F\u55AE\u4E00\u6A94\u6848`);
+  }
+  const name = safeLibraryName(path14.basename(resolved));
+  const target = entryPath(root, kind, name);
+  fs10.rmSync(target, { recursive: true, force: true });
+  fs10.cpSync(resolved, target, { recursive: kind === "skill", dereference: true });
+  if (kind === "script") fs10.chmodSync(target, 493);
+  const key = entryKey(kind, name);
+  const index = readIndex(root);
+  const { builtinHash: _hash, builtinDeleted: _deleted, ...kept } = index.entries[key] ?? {};
+  index.entries[key] = { ...kept, sourcePath: resolved, importedAt: Date.now(), enabled: true };
+  writeIndex(root, index);
+  return requireEntry(root, kind, name);
+}
+function createEntry(root, kind, rawName, content, description) {
+  ensureLibrary(root);
+  const name = safeLibraryName(rawName);
+  const target = entryPath(root, kind, name);
+  if (fs10.existsSync(target)) throw new Error(`\u5DF2\u5B58\u5728\u540C\u540D\u9805\u76EE\uFF1A${name}`);
+  if (kind === "skill") {
+    fs10.mkdirSync(target, { recursive: true });
+    fs10.writeFileSync(path14.join(target, "SKILL.md"), content);
+  } else {
+    fs10.writeFileSync(target, content);
+    if (kind === "script") fs10.chmodSync(target, 493);
+  }
+  annotate(root, entryKey(kind, name), {
+    importedAt: Date.now(),
+    enabled: true,
+    description
+  });
+  return requireEntry(root, kind, name);
+}
+function setEntryDescription(root, kind, name, description) {
+  annotate(root, entryKey(kind, name), { description });
+}
+function updateEntry(root, kind, name, content) {
+  const target = entryPath(root, kind, name);
+  if (!fs10.existsSync(target)) throw new Error(`\u627E\u4E0D\u5230\u9805\u76EE\uFF1A${name}`);
+  fs10.writeFileSync(kind === "skill" ? path14.join(target, "SKILL.md") : target, content);
+  return requireEntry(root, kind, name);
+}
+function readEntryContent(root, kind, name) {
+  const target = entryPath(root, kind, name);
+  return fs10.readFileSync(kind === "skill" ? path14.join(target, "SKILL.md") : target, "utf8");
+}
+function markBuiltinDeleted(root, key) {
+  const index = readIndex(root);
+  index.entries[key] = { builtinDeleted: true };
+  writeIndex(root, index);
+}
+function deleteEntry(root, kind, name) {
+  fs10.rmSync(entryPath(root, kind, name), { recursive: true, force: true });
+  const key = entryKey(kind, name);
+  const record = readIndex(root).entries[key];
+  if (record?.builtinHash || record?.builtinDeleted) {
+    markBuiltinDeleted(root, key);
+    return;
+  }
+  const index = readIndex(root);
+  delete index.entries[key];
+  writeIndex(root, index);
+}
+function setEntryEnabled(root, kind, name, enabled) {
+  annotate(root, entryKey(kind, name), { enabled });
+}
+function requireEntry(root, kind, name) {
+  const found2 = listLibrary(root).find((e) => e.key === entryKey(kind, name));
+  if (!found2) throw new Error(`\u9805\u76EE\u5BEB\u5165\u5F8C\u8B80\u4E0D\u56DE\u4F86\uFF1A${kind}/${name}`);
+  return found2;
+}
+function projectSkillsDir(worktreePath) {
+  return path14.join(worktreePath, ".claude", "skills");
+}
+function skillNamesIn(dir) {
+  try {
+    return fs10.readdirSync(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).map((d) => d.name).filter((name) => fs10.existsSync(path14.join(dir, name, "SKILL.md"))).sort();
+  } catch {
+    return [];
+  }
+}
+var PLUGIN_MANIFEST_DIR = ".claude-plugin";
+function buildPluginDir(root) {
+  const paths = libraryPaths(root);
+  const enabled = listLibrary(root).filter((e) => e.kind === "skill" && e.enabled);
+  fs10.rmSync(path14.join(paths.plugin, "skills"), { recursive: true, force: true });
+  fs10.mkdirSync(path14.join(paths.plugin, PLUGIN_MANIFEST_DIR), { recursive: true });
+  fs10.mkdirSync(path14.join(paths.plugin, "skills"), { recursive: true });
+  fs10.writeFileSync(
+    path14.join(paths.plugin, PLUGIN_MANIFEST_DIR, "plugin.json"),
+    `${JSON.stringify(
+      {
+        name: "vibeflow-library",
+        version: "1.0.0",
+        description: "Skills delivered by VibeFlow for this task."
+      },
+      null,
+      2
+    )}
+`
+  );
+  for (const entry of enabled) {
+    fs10.cpSync(entry.path, path14.join(paths.plugin, "skills", entry.name), {
+      recursive: true,
+      dereference: true
+    });
+  }
+  return { pluginDir: paths.plugin, skills: enabled.map((e) => e.name) };
+}
+function linkOrSkip(target, linkPath) {
+  if (!fs10.existsSync(target)) return false;
+  const source = path14.resolve(target);
+  const attempts = fs10.statSync(source).isDirectory() ? [
+    () => fs10.symlinkSync(source, linkPath, "junction"),
+    () => fs10.cpSync(source, linkPath, { recursive: true, dereference: true })
+  ] : [
+    () => fs10.symlinkSync(source, linkPath),
+    () => fs10.linkSync(source, linkPath),
+    () => fs10.copyFileSync(source, linkPath)
+  ];
+  for (const attempt of attempts) {
+    try {
+      fs10.rmSync(linkPath, { recursive: true, force: true });
+      attempt();
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function buildCodexHome(root, worktreePath, userCodexHome = path14.join(os3.homedir(), ".codex")) {
+  const paths = libraryPaths(root);
+  const skillsDir = path14.join(paths.codexHome, "skills");
+  fs10.rmSync(skillsDir, { recursive: true, force: true });
+  fs10.mkdirSync(skillsDir, { recursive: true });
+  for (const file of ["auth.json", "config.toml"]) {
+    linkOrSkip(path14.join(userCodexHome, file), path14.join(paths.codexHome, file));
+  }
+  const result = {
+    codexHome: paths.codexHome,
+    project: [],
+    user: [],
+    library: [],
+    shadowed: []
+  };
+  const claimed = /* @__PURE__ */ new Map();
+  const projectDir = worktreePath ? projectSkillsDir(worktreePath) : void 0;
+  if (projectDir) {
+    for (const name of skillNamesIn(projectDir)) {
+      if (linkOrSkip(path14.join(projectDir, name), path14.join(skillsDir, name))) {
+        result.project.push(name);
+        claimed.set(name, "project");
+      }
+    }
+  }
+  const userDir = path14.join(userCodexHome, "skills");
+  for (const name of skillNamesIn(userDir)) {
+    const owner = claimed.get(name);
+    if (owner) {
+      result.shadowed.push({ name, keptFrom: owner, dropped: "user" });
+      continue;
+    }
+    if (linkOrSkip(path14.join(userDir, name), path14.join(skillsDir, name))) {
+      result.user.push(name);
+      claimed.set(name, "user");
+    }
+  }
+  for (const entry of listLibrary(root)) {
+    if (entry.kind !== "skill" || !entry.enabled) continue;
+    const owner = claimed.get(entry.name);
+    if (owner) {
+      result.shadowed.push({ name: entry.name, keptFrom: owner, dropped: "library" });
+      continue;
+    }
+    fs10.cpSync(entry.path, path14.join(skillsDir, entry.name), {
+      recursive: true,
+      dereference: true
+    });
+    result.library.push(entry.name);
+  }
+  return result;
+}
+function libraryLaunchInfoAt(root, worktreePath, userCodexHome) {
+  const entries = listLibrary(root).filter((e) => e.enabled);
+  if (entries.length === 0) return null;
+  const { pluginDir } = buildPluginDir(root);
+  const { codexHome } = buildCodexHome(root, worktreePath, userCodexHome);
+  const scripts = entries.filter((e) => e.kind === "script").map((e) => ({ name: e.name, path: e.path, description: e.description }));
+  const promptBodies = entries.filter((e) => e.kind === "prompt").map((e) => readEntryContent(root, "prompt", e.name).trim()).filter(Boolean);
+  const lines = [...promptBodies];
+  if (scripts.length > 0) {
+    lines.push(
+      "\u53EF\u7528\u7684\u5DE5\u5177\u8173\u672C\uFF08\u9700\u8981\u6642\u81EA\u884C\u57F7\u884C\uFF0C\u4E0D\u9700\u8981\u5C31\u5225\u8DD1\uFF09\uFF1A",
+      ...scripts.map((s) => `- ${s.path}${s.description ? ` \u2014 ${s.description}` : ""}`)
+    );
+  }
+  return {
+    pluginDir,
+    codexHome,
+    libraryDir: root,
+    scripts,
+    promptText: lines.join("\n\n")
+  };
+}
+async function libraryLaunchInfo(worktreePath) {
+  return libraryLaunchInfoAt(await libraryRoot(), worktreePath);
+}
+
+// packages/core/src/library-builtins.ts
+function builtinSkillsDir() {
+  return getPlatform().builtinSkillsDir?.() ?? null;
+}
+function installBuiltin(root, builtinDir, name) {
+  const target = entryPath(root, "skill", name);
+  const staging = entryPath(root, "skill", `.${name}.installing`);
+  fs11.rmSync(staging, { recursive: true, force: true });
+  try {
+    fs11.cpSync(path15.join(builtinDir, name), staging, {
+      recursive: true,
+      dereference: true,
+      filter: (src) => path15.basename(src) !== "__pycache__"
+    });
+    fs11.rmSync(target, { recursive: true, force: true });
+    fs11.renameSync(staging, target);
+  } finally {
+    fs11.rmSync(staging, { recursive: true, force: true });
+  }
+  return hashSkillDir(target);
+}
+function syncBuiltinSkills(root, builtinDir) {
+  const result = { installed: [], updated: [] };
+  if (!builtinDir) return result;
+  const names = skillNamesIn(builtinDir);
+  if (names.length === 0) return result;
+  if (indexIsCorrupt(root)) {
+    console.error("Library index.json is unreadable; skipping built-in skill sync");
+    return result;
+  }
+  ensureLibrary(root);
+  for (const name of names) {
+    try {
+      syncOne(root, builtinDir, name, result);
+    } catch (err) {
+      console.error(`Failed to sync built-in skill "${name}":`, err);
+    }
+  }
+  return result;
+}
+function syncOne(root, builtinDir, name, result) {
+  const key = entryKey("skill", name);
+  const record = readIndex(root).entries[key] ?? {};
+  if (record.builtinDeleted) return;
+  const target = entryPath(root, "skill", name);
+  if (!record.builtinHash) {
+    if (fs11.existsSync(target)) return;
+    annotate(root, key, {
+      builtinHash: installBuiltin(root, builtinDir, name),
+      enabled: true,
+      importedAt: Date.now()
+    });
+    result.installed.push(name);
+    return;
+  }
+  if (!fs11.existsSync(path15.join(target, "SKILL.md"))) {
+    markBuiltinDeleted(root, key);
+    return;
+  }
+  if (hashSkillDir(path15.join(builtinDir, name)) === record.builtinHash) return;
+  if (hashSkillDir(target) !== record.builtinHash) return;
+  annotate(root, key, { builtinHash: installBuiltin(root, builtinDir, name) });
+  result.updated.push(name);
+}
+function restoreBuiltinSkill(root, builtinDir, name) {
+  if (!builtinDir || safeLibraryName(name) !== name || !skillNamesIn(builtinDir).includes(name)) {
+    throw new Error(`\u4E0D\u662F\u5167\u5EFA skill\uFF1A${name}`);
+  }
+  const key = entryKey("skill", name);
+  if (fs11.existsSync(entryPath(root, "skill", name)) && !readIndex(root).entries[key]?.builtinHash) {
+    throw new Error(`\u5DF2\u6709\u540C\u540D\u7684\u81EA\u8A02\u9805\u76EE\uFF1A${name}`);
+  }
+  ensureLibrary(root);
+  const builtinHash = installBuiltin(root, builtinDir, name);
+  const index = readIndex(root);
+  const record = { ...index.entries[key], builtinHash, enabled: true, importedAt: Date.now() };
+  delete record.builtinDeleted;
+  delete record.sourcePath;
+  index.entries[key] = record;
+  writeIndex(root, index);
+  const entry = listLibrary(root, builtinDir).find((e) => e.key === key);
+  if (!entry) throw new Error(`\u9084\u539F\u5931\u6557\uFF1A${name}`);
+  return entry;
+}
+function removedBuiltinSkills(root, builtinDir) {
+  if (!builtinDir) return [];
+  const index = readIndex(root);
+  return skillNamesIn(builtinDir).filter(
+    (name) => index.entries[entryKey("skill", name)]?.builtinDeleted === true && !fs11.existsSync(entryPath(root, "skill", name))
+  );
+}
+async function syncBuiltinsAtStartup() {
+  try {
+    const { installed, updated } = syncBuiltinSkills(await libraryRoot(), builtinSkillsDir());
+    if (installed.length || updated.length) {
+      console.log(`Built-in skills \u2014 installed: ${installed.join(", ") || "-"}; updated: ${updated.join(", ") || "-"}`);
+    }
+  } catch (err) {
+    console.error("Failed to sync built-in skills:", err);
+  }
+}
+
+// packages/core/src/service.ts
+import fs15 from "fs";
+import os5 from "os";
+import path19 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+
+// packages/core/src/agent-models.ts
+import { execFile as execFile5 } from "child_process";
+import fs12 from "fs";
+import os4 from "os";
+import path16 from "path";
+import { promisify as promisify3 } from "util";
+init_env();
+var pexec3 = promisify3(execFile5);
+var CODEX_MODELS_TIMEOUT_MS = 2e4;
+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;
+}
+function parseCodexCatalog(raw) {
+  const body = JSON.parse(raw);
+  if (!Array.isArray(body.models)) throw new Error("Codex model catalog has no models array");
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  for (const entry of body.models) {
+    if (!entry || typeof entry !== "object") continue;
+    const { slug, display_name: displayName, visibility } = entry;
+    if (typeof slug !== "string" || !slug.trim() || visibility === "hide") continue;
+    const id = slug.trim();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    models.push({
+      id,
+      label: typeof displayName === "string" && displayName.trim() ? displayName.trim() : id
+    });
+  }
+  if (models.length === 0) throw new Error("Codex model catalog lists no selectable models");
+  return models;
+}
+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");
+  try {
+    const raw = await fs12.promises.readFile(cachePath, "utf8");
+    return { models: parseCodexCatalog(raw), source: "codex-cache" };
+  } catch (err) {
+    const missing = err.code === "ENOENT";
+    return {
+      models: builtinModels(id),
+      source: "builtin",
+      ...missing ? {} : { error: errorMessage(err) }
+    };
+  }
+}
+
+// packages/core/src/github-auth.ts
+init_env();
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify4 } from "util";
+import * as nodePty3 from "node-pty";
+var pexec4 = promisify4(execFile6);
+var GITHUB_HOST = "github.com";
+var DEVICE_URL = "https://github.com/login/device";
+var activeLogin = null;
+function stripAnsi(value) {
+  return value.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\x07/g, "");
+}
+function normalizeCode(code2) {
+  return code2.replace(/\s+/g, "").toUpperCase();
+}
+function extractDeviceCode(output) {
+  const cleaned = stripAnsi(output);
+  const explicit = cleaned.match(/one-time code:\s*([A-Z0-9-]+)/i);
+  if (explicit?.[1]) return normalizeCode(explicit[1]);
+  const fallback = cleaned.match(/\b([A-Z0-9]{4}-[A-Z0-9]{4})\b/i);
+  return fallback?.[1] ? normalizeCode(fallback[1]) : null;
+}
+function statusFromBody(body) {
+  const accounts = body.hosts?.[GITHUB_HOST] ?? [];
+  const active = accounts.find((account) => account.active) ?? accounts[0];
+  if (!active) return { installed: true, authenticated: false };
+  return {
+    installed: true,
+    authenticated: Boolean(active.login) && !active.error,
+    login: active.login,
+    gitProtocol: active.gitProtocol,
+    error: active.error
+  };
+}
+function errorMessage2(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+async function getGitHubCliAuthStatus() {
+  try {
+    const { stdout } = await pexec4(
+      "gh",
+      ["auth", "status", "--hostname", GITHUB_HOST, "--json", "hosts"],
+      {
+        env: execEnv(),
+        timeout: 1e4,
+        windowsHide: true
+      }
+    );
+    const body = JSON.parse(stdout.toString());
+    return statusFromBody(body);
+  } catch (err) {
+    const maybeStdout = err.stdout;
+    if (maybeStdout) {
+      try {
+        const body = JSON.parse(maybeStdout.toString());
+        return statusFromBody(body);
+      } catch {
+      }
+    }
+    const message = errorMessage2(err);
+    return {
+      installed: !/ENOENT|not found/i.test(message),
+      authenticated: false,
+      error: message
+    };
+  }
+}
+async function logoutGitHubCli() {
+  const status = await getGitHubCliAuthStatus();
+  if (!status.installed) throw new Error("\u627E\u4E0D\u5230 GitHub CLI\uFF08gh\uFF09\u3002");
+  if (!status.login) return status;
+  await pexec4(
+    "gh",
+    ["auth", "logout", "--hostname", GITHUB_HOST, "--user", status.login],
+    {
+      env: execEnv(),
+      timeout: 1e4,
+      windowsHide: true
+    }
+  );
+  return getGitHubCliAuthStatus();
+}
+function cancelGitHubCliLogin() {
+  if (!activeLogin) return;
+  try {
+    activeLogin.kill();
+  } catch {
+  }
+  activeLogin = null;
+}
+function startGitHubCliLogin(onEvent) {
+  cancelGitHubCliLogin();
+  onEvent({ type: "starting" });
+  let output = "";
+  let sentBrowserChoice = false;
+  let emittedCode = null;
+  let continuedAfterCode = false;
+  let completed = false;
+  let proc;
+  try {
+    proc = nodePty3.spawn(
+      "gh",
+      ["auth", "login", "--hostname", GITHUB_HOST, "--git-protocol", "https"],
+      {
+        name: "xterm-256color",
+        cwd: process.cwd(),
+        env: { ...execEnv(), BROWSER: "true", TERM: "xterm-256color" },
+        cols: 100,
+        rows: 24
+      }
+    );
+  } catch (err) {
+    onEvent({ type: "error", error: errorMessage2(err) });
+    return;
+  }
+  activeLogin = proc;
+  proc.onData((data) => {
+    output += data;
+    const cleaned = stripAnsi(output);
+    if (!sentBrowserChoice && cleaned.includes("Login with a web browser")) {
+      sentBrowserChoice = true;
+      proc.write("\r");
+    }
+    const code2 = extractDeviceCode(output);
+    if (code2 && code2 !== emittedCode) {
+      emittedCode = code2;
+      onEvent({ type: "code", code: code2, url: DEVICE_URL });
+    }
+    if (code2 && !continuedAfterCode) {
       continuedAfterCode = true;
       proc.write("\r");
     }
@@ -3743,38 +4345,38 @@ function startGitHubCliLogin(onEvent) {
 }
 
 // packages/core/src/board-cli.ts
-import fs10 from "fs";
-import path14 from "path";
+import fs13 from "fs";
+import path17 from "path";
 import { pathToFileURL } from "url";
 async function boardCliLaunchInfo() {
-  const storeDir = path14.dirname(getStorePath());
+  const storeDir = path17.dirname(getStorePath());
   const entry = getPlatform().cliEntry?.();
-  if (entry && fs10.existsSync(entry)) return { storeDir, cliPath: entry };
+  if (entry && fs13.existsSync(entry)) return { storeDir, cliPath: entry };
   const root = getPlatform().sourceRoot();
   if (!root) return { storeDir };
-  const cliPath = path14.join(root, "scripts", "vibeflow.mjs");
-  const loaderPath = path14.join(root, "test", "support", "register.mjs");
-  if (!fs10.existsSync(cliPath) || !fs10.existsSync(loaderPath)) 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 };
   return { storeDir, cliPath, loaderPath: pathToFileURL(loaderPath).href };
 }
 
 // packages/core/src/decisions.ts
-import fs11 from "fs";
-import path15 from "path";
+import fs14 from "fs";
+import path18 from "path";
 var DECISIONS_FILE_SUFFIX = ".DECISIONS.md";
 var MAX_DECISION_BYTES = 256 * 1024;
 function decisionsKey(worktreePath, branch) {
-  return worktreePath ? path15.basename(worktreePath) : branch.replace(/\//g, "-");
+  return worktreePath ? path18.basename(worktreePath) : branch.replace(/\//g, "-");
 }
 function decisionsPath(workspacePath, key) {
-  return path15.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
+  return path18.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
 }
 function readDecisions(workspacePath, key) {
   const target = decisionsPath(workspacePath, key);
   try {
-    const stat = fs11.statSync(target);
+    const stat = fs14.statSync(target);
     if (!stat.isFile()) return { path: target, markdown: null };
-    const buf = fs11.readFileSync(target);
+    const buf = fs14.readFileSync(target);
     return {
       path: target,
       markdown: buf.subarray(0, MAX_DECISION_BYTES).toString("utf8"),
@@ -3787,7 +4389,7 @@ function readDecisions(workspacePath, key) {
 }
 function deleteDecisions(workspacePath, key) {
   try {
-    fs11.rmSync(decisionsPath(workspacePath, key), { force: true });
+    fs14.rmSync(decisionsPath(workspacePath, key), { force: true });
   } catch {
   }
 }
@@ -4012,414 +4614,71 @@ ${attachmentLines.join("\n")}` : text;
             }
           }
         }
-        if (event.type === "user" && event.message?.content) {
-          for (const block of event.message.content) {
-            if (block.type === "tool_result") {
-              const toolName = toolNames.get(block.tool_use_id ?? "") ?? "Tool";
-              const raw2 = block.content;
-              const detail = typeof raw2 === "string" ? raw2 : Array.isArray(raw2) ? raw2.map((c) => c.text ?? "").join("\n") : "";
-              pushPhase({
-                taskId,
-                id: `${taskId}-${seq++}`,
-                phaseType: "tool_result",
-                phaseSummary: `Got result from \`${toolName}\``,
-                phaseDetail: detail,
-                done: true
-              });
-            }
-          }
-        }
-        if (event.type === "result" && event.result) {
-          const remaining = event.result.slice(accumulated.length);
-          if (remaining) push({ taskId, delta: remaining, done: false });
-          accumulated = event.result;
-        }
-      } catch {
-      }
-    }
-  });
-  proc.stderr.on("data", (raw) => {
-    const msg = raw.toString().trim();
-    if (msg) push({ taskId, delta: "", done: false, error: msg });
-  });
-  proc.on("close", (code2) => {
-    const assistantText = accumulated || "\uFF08\u7121\u56DE\u61C9\uFF09";
-    appendMessage(taskId, {
-      id: randomUUID3().slice(0, 8),
-      role: "assistant",
-      text: assistantText,
-      ts: Date.now()
-    });
-    const error = code2 !== 0 ? `Process exited with code ${code2}` : void 0;
-    push({ taskId, delta: assistantText, done: true, error });
-  });
-  return () => {
-    try {
-      proc.kill("SIGTERM");
-    } catch {
-    }
-  };
-}
-var activeProcs = /* @__PURE__ */ new Map();
-function cancelChatSend(taskId) {
-  activeProcs.get(taskId)?.();
-  activeProcs.delete(taskId);
-}
-function cancelAllChatSends() {
-  activeProcs.forEach((kill) => kill());
-  activeProcs.clear();
-}
-function startChatSend(opts, sender) {
-  cancelChatSend(opts.taskId);
-  const kill = sendChatMessage(opts, sender);
-  activeProcs.set(opts.taskId, kill);
-}
-
-// packages/core/src/service.ts
-init_attachments();
-
-// packages/core/src/library.ts
-import fs12 from "fs";
-import os3 from "os";
-import path16 from "path";
-var LIBRARY_DIR = "library";
-var LIBRARY_KINDS = ["skill", "prompt", "script"];
-var KIND_DIR = {
-  skill: "skills",
-  prompt: "prompts",
-  script: "scripts"
-};
-var INDEX_FILE = "index.json";
-var MAX_NAME_BYTES = 100;
-function libraryPaths(root) {
-  return {
-    root,
-    skills: path16.join(root, KIND_DIR.skill),
-    prompts: path16.join(root, KIND_DIR.prompt),
-    scripts: path16.join(root, KIND_DIR.script),
-    plugin: path16.join(root, "plugin"),
-    codexHome: path16.join(root, "codex-home")
-  };
-}
-async function libraryRoot() {
-  return path16.join(getPlatform().userDataDir(), LIBRARY_DIR);
-}
-function truncateUtf82(value, maxBytes) {
-  let result = "";
-  for (const character of value) {
-    if (Buffer.byteLength(result + character) > maxBytes) break;
-    result += character;
-  }
-  return result;
-}
-function safeLibraryName(name) {
-  const basename2 = name.replace(/\\/g, "/").split("/").pop() ?? "";
-  const cleaned = truncateUtf82(
-    basename2.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
-    MAX_NAME_BYTES
-  );
-  return cleaned && cleaned !== "." && cleaned !== ".." ? cleaned : "untitled";
-}
-function entryKey(kind, name) {
-  return `${kind}/${name}`;
-}
-function indexPath(root) {
-  return path16.join(root, INDEX_FILE);
-}
-function readIndex(root) {
-  try {
-    const parsed = JSON.parse(fs12.readFileSync(indexPath(root), "utf8"));
-    if (parsed && typeof parsed === "object" && "entries" in parsed) {
-      const entries = parsed.entries;
-      if (entries && typeof entries === "object") return { version: 1, entries };
-    }
-  } catch {
-  }
-  return { version: 1, entries: {} };
-}
-function writeIndex(root, index) {
-  fs12.mkdirSync(root, { recursive: true });
-  fs12.writeFileSync(indexPath(root), `${JSON.stringify(index, null, 2)}
-`);
-}
-function ensureLibrary(root) {
-  const paths = libraryPaths(root);
-  for (const kind of LIBRARY_KINDS) {
-    fs12.mkdirSync(path16.join(root, KIND_DIR[kind]), { recursive: true });
-  }
-  return paths;
-}
-function readSkillDescription(skillMdPath) {
-  let content;
-  try {
-    content = fs12.readFileSync(skillMdPath, "utf8");
-  } catch {
-    return void 0;
-  }
-  const lines = content.split(/\r?\n/);
-  if (lines[0]?.trim() !== "---") return void 0;
-  for (let i = 1; i < lines.length; i += 1) {
-    const line = lines[i];
-    if (line.trim() === "---") break;
-    const match = /^description:\s*(.+)$/.exec(line);
-    if (match) return match[1].trim().replace(/^["']|["']$/g, "");
-  }
-  return void 0;
-}
-function entryPath(root, kind, name) {
-  return path16.join(root, KIND_DIR[kind], name);
-}
-function listLibrary(root) {
-  const index = readIndex(root);
-  const entries = [];
-  for (const kind of LIBRARY_KINDS) {
-    const dir = path16.join(root, KIND_DIR[kind]);
-    let dirents;
-    try {
-      dirents = fs12.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const dirent of dirents) {
-      if (dirent.name.startsWith(".")) continue;
-      const wantsDirectory = kind === "skill";
-      let stat;
-      try {
-        stat = fs12.statSync(path16.join(dir, dirent.name));
+        if (event.type === "user" && event.message?.content) {
+          for (const block of event.message.content) {
+            if (block.type === "tool_result") {
+              const toolName = toolNames.get(block.tool_use_id ?? "") ?? "Tool";
+              const raw2 = block.content;
+              const detail = typeof raw2 === "string" ? raw2 : Array.isArray(raw2) ? raw2.map((c) => c.text ?? "").join("\n") : "";
+              pushPhase({
+                taskId,
+                id: `${taskId}-${seq++}`,
+                phaseType: "tool_result",
+                phaseSummary: `Got result from \`${toolName}\``,
+                phaseDetail: detail,
+                done: true
+              });
+            }
+          }
+        }
+        if (event.type === "result" && event.result) {
+          const remaining = event.result.slice(accumulated.length);
+          if (remaining) push({ taskId, delta: remaining, done: false });
+          accumulated = event.result;
+        }
       } catch {
-        continue;
       }
-      if (stat.isDirectory() !== wantsDirectory) continue;
-      const name = dirent.name;
-      const full = path16.join(dir, name);
-      if (wantsDirectory && !fs12.existsSync(path16.join(full, "SKILL.md"))) continue;
-      const key = entryKey(kind, name);
-      const record = index.entries[key] ?? {};
-      entries.push({
-        key,
-        kind,
-        name,
-        path: full,
-        description: wantsDirectory ? readSkillDescription(path16.join(full, "SKILL.md")) : record.description,
-        sourcePath: record.sourcePath,
-        importedAt: record.importedAt,
-        enabled: record.enabled !== false
-      });
-    }
-  }
-  return entries.sort((a, b) => a.key.localeCompare(b.key));
-}
-function annotate(root, key, patch) {
-  const index = readIndex(root);
-  index.entries[key] = { ...index.entries[key], ...patch };
-  writeIndex(root, index);
-}
-function importEntry(root, kind, sourcePath) {
-  ensureLibrary(root);
-  const resolved = path16.resolve(sourcePath);
-  const stat = fs12.statSync(resolved);
-  if (kind === "skill") {
-    if (!stat.isDirectory()) throw new Error("skill \u5FC5\u9808\u662F\u542B SKILL.md \u7684\u76EE\u9304");
-    if (!fs12.existsSync(path16.join(resolved, "SKILL.md"))) {
-      throw new Error("\u76EE\u9304\u5167\u627E\u4E0D\u5230 SKILL.md");
     }
-  } else if (!stat.isFile()) {
-    throw new Error(`${kind} \u5FC5\u9808\u662F\u55AE\u4E00\u6A94\u6848`);
-  }
-  const name = safeLibraryName(path16.basename(resolved));
-  const target = entryPath(root, kind, name);
-  fs12.rmSync(target, { recursive: true, force: true });
-  fs12.cpSync(resolved, target, { recursive: kind === "skill", dereference: true });
-  if (kind === "script") fs12.chmodSync(target, 493);
-  annotate(root, entryKey(kind, name), {
-    sourcePath: resolved,
-    importedAt: Date.now(),
-    enabled: true
   });
-  return requireEntry(root, kind, name);
-}
-function createEntry(root, kind, rawName, content, description) {
-  ensureLibrary(root);
-  const name = safeLibraryName(rawName);
-  const target = entryPath(root, kind, name);
-  if (fs12.existsSync(target)) throw new Error(`\u5DF2\u5B58\u5728\u540C\u540D\u9805\u76EE\uFF1A${name}`);
-  if (kind === "skill") {
-    fs12.mkdirSync(target, { recursive: true });
-    fs12.writeFileSync(path16.join(target, "SKILL.md"), content);
-  } else {
-    fs12.writeFileSync(target, content);
-    if (kind === "script") fs12.chmodSync(target, 493);
-  }
-  annotate(root, entryKey(kind, name), {
-    importedAt: Date.now(),
-    enabled: true,
-    description
+  proc.stderr.on("data", (raw) => {
+    const msg = raw.toString().trim();
+    if (msg) push({ taskId, delta: "", done: false, error: msg });
   });
-  return requireEntry(root, kind, name);
-}
-function setEntryDescription(root, kind, name, description) {
-  annotate(root, entryKey(kind, name), { description });
-}
-function updateEntry(root, kind, name, content) {
-  const target = entryPath(root, kind, name);
-  if (!fs12.existsSync(target)) throw new Error(`\u627E\u4E0D\u5230\u9805\u76EE\uFF1A${name}`);
-  fs12.writeFileSync(kind === "skill" ? path16.join(target, "SKILL.md") : target, content);
-  return requireEntry(root, kind, name);
-}
-function readEntryContent(root, kind, name) {
-  const target = entryPath(root, kind, name);
-  return fs12.readFileSync(kind === "skill" ? path16.join(target, "SKILL.md") : target, "utf8");
-}
-function deleteEntry(root, kind, name) {
-  fs12.rmSync(entryPath(root, kind, name), { recursive: true, force: true });
-  const index = readIndex(root);
-  delete index.entries[entryKey(kind, name)];
-  writeIndex(root, index);
-}
-function setEntryEnabled(root, kind, name, enabled) {
-  annotate(root, entryKey(kind, name), { enabled });
-}
-function requireEntry(root, kind, name) {
-  const found2 = listLibrary(root).find((e) => e.key === entryKey(kind, name));
-  if (!found2) throw new Error(`\u9805\u76EE\u5BEB\u5165\u5F8C\u8B80\u4E0D\u56DE\u4F86\uFF1A${kind}/${name}`);
-  return found2;
-}
-function projectSkillsDir(worktreePath) {
-  return path16.join(worktreePath, ".claude", "skills");
-}
-function skillNamesIn(dir) {
-  try {
-    return fs12.readdirSync(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).map((d) => d.name).filter((name) => fs12.existsSync(path16.join(dir, name, "SKILL.md"))).sort();
-  } catch {
-    return [];
-  }
-}
-var PLUGIN_MANIFEST_DIR = ".claude-plugin";
-function buildPluginDir(root) {
-  const paths = libraryPaths(root);
-  const enabled = listLibrary(root).filter((e) => e.kind === "skill" && e.enabled);
-  fs12.rmSync(path16.join(paths.plugin, "skills"), { recursive: true, force: true });
-  fs12.mkdirSync(path16.join(paths.plugin, PLUGIN_MANIFEST_DIR), { recursive: true });
-  fs12.mkdirSync(path16.join(paths.plugin, "skills"), { recursive: true });
-  fs12.writeFileSync(
-    path16.join(paths.plugin, PLUGIN_MANIFEST_DIR, "plugin.json"),
-    `${JSON.stringify(
-      {
-        name: "vibeflow-library",
-        version: "1.0.0",
-        description: "Skills delivered by VibeFlow for this task."
-      },
-      null,
-      2
-    )}
-`
-  );
-  for (const entry of enabled) {
-    fs12.cpSync(entry.path, path16.join(paths.plugin, "skills", entry.name), {
-      recursive: true,
-      dereference: true
+  proc.on("close", (code2) => {
+    const assistantText = accumulated || "\uFF08\u7121\u56DE\u61C9\uFF09";
+    appendMessage(taskId, {
+      id: randomUUID3().slice(0, 8),
+      role: "assistant",
+      text: assistantText,
+      ts: Date.now()
     });
-  }
-  return { pluginDir: paths.plugin, skills: enabled.map((e) => e.name) };
-}
-function linkOrSkip(target, linkPath) {
-  if (!fs12.existsSync(target)) return false;
-  const source = path16.resolve(target);
-  const attempts = fs12.statSync(source).isDirectory() ? [
-    () => fs12.symlinkSync(source, linkPath, "junction"),
-    () => fs12.cpSync(source, linkPath, { recursive: true, dereference: true })
-  ] : [
-    () => fs12.symlinkSync(source, linkPath),
-    () => fs12.linkSync(source, linkPath),
-    () => fs12.copyFileSync(source, linkPath)
-  ];
-  for (const attempt of attempts) {
+    const error = code2 !== 0 ? `Process exited with code ${code2}` : void 0;
+    push({ taskId, delta: assistantText, done: true, error });
+  });
+  return () => {
     try {
-      fs12.rmSync(linkPath, { recursive: true, force: true });
-      attempt();
-      return true;
+      proc.kill("SIGTERM");
     } catch {
     }
-  }
-  return false;
-}
-function buildCodexHome(root, worktreePath, userCodexHome = path16.join(os3.homedir(), ".codex")) {
-  const paths = libraryPaths(root);
-  const skillsDir = path16.join(paths.codexHome, "skills");
-  fs12.rmSync(skillsDir, { recursive: true, force: true });
-  fs12.mkdirSync(skillsDir, { recursive: true });
-  for (const file of ["auth.json", "config.toml"]) {
-    linkOrSkip(path16.join(userCodexHome, file), path16.join(paths.codexHome, file));
-  }
-  const result = {
-    codexHome: paths.codexHome,
-    project: [],
-    user: [],
-    library: [],
-    shadowed: []
   };
-  const claimed = /* @__PURE__ */ new Map();
-  const projectDir = worktreePath ? projectSkillsDir(worktreePath) : void 0;
-  if (projectDir) {
-    for (const name of skillNamesIn(projectDir)) {
-      if (linkOrSkip(path16.join(projectDir, name), path16.join(skillsDir, name))) {
-        result.project.push(name);
-        claimed.set(name, "project");
-      }
-    }
-  }
-  const userDir = path16.join(userCodexHome, "skills");
-  for (const name of skillNamesIn(userDir)) {
-    const owner = claimed.get(name);
-    if (owner) {
-      result.shadowed.push({ name, keptFrom: owner, dropped: "user" });
-      continue;
-    }
-    if (linkOrSkip(path16.join(userDir, name), path16.join(skillsDir, name))) {
-      result.user.push(name);
-      claimed.set(name, "user");
-    }
-  }
-  for (const entry of listLibrary(root)) {
-    if (entry.kind !== "skill" || !entry.enabled) continue;
-    const owner = claimed.get(entry.name);
-    if (owner) {
-      result.shadowed.push({ name: entry.name, keptFrom: owner, dropped: "library" });
-      continue;
-    }
-    fs12.cpSync(entry.path, path16.join(skillsDir, entry.name), {
-      recursive: true,
-      dereference: true
-    });
-    result.library.push(entry.name);
-  }
-  return result;
 }
-function libraryLaunchInfoAt(root, worktreePath, userCodexHome) {
-  const entries = listLibrary(root).filter((e) => e.enabled);
-  if (entries.length === 0) return null;
-  const { pluginDir } = buildPluginDir(root);
-  const { codexHome } = buildCodexHome(root, worktreePath, userCodexHome);
-  const scripts = entries.filter((e) => e.kind === "script").map((e) => ({ name: e.name, path: e.path, description: e.description }));
-  const promptBodies = entries.filter((e) => e.kind === "prompt").map((e) => readEntryContent(root, "prompt", e.name).trim()).filter(Boolean);
-  const lines = [...promptBodies];
-  if (scripts.length > 0) {
-    lines.push(
-      "\u53EF\u7528\u7684\u5DE5\u5177\u8173\u672C\uFF08\u9700\u8981\u6642\u81EA\u884C\u57F7\u884C\uFF0C\u4E0D\u9700\u8981\u5C31\u5225\u8DD1\uFF09\uFF1A",
-      ...scripts.map((s) => `- ${s.path}${s.description ? ` \u2014 ${s.description}` : ""}`)
-    );
-  }
-  return {
-    pluginDir,
-    codexHome,
-    libraryDir: root,
-    scripts,
-    promptText: lines.join("\n\n")
-  };
+var activeProcs = /* @__PURE__ */ new Map();
+function cancelChatSend(taskId) {
+  activeProcs.get(taskId)?.();
+  activeProcs.delete(taskId);
 }
-async function libraryLaunchInfo(worktreePath) {
-  return libraryLaunchInfoAt(await libraryRoot(), worktreePath);
+function cancelAllChatSends() {
+  activeProcs.forEach((kill) => kill());
+  activeProcs.clear();
 }
+function startChatSend(opts, sender) {
+  cancelChatSend(opts.taskId);
+  const kill = sendChatMessage(opts, sender);
+  activeProcs.set(opts.taskId, kill);
+}
+
+// packages/core/src/service.ts
+init_attachments();
 
 // packages/core/src/launch.ts
 var ARTIFACTS_DIR_SUFFIX2 = ".artifacts";
@@ -4703,13 +4962,13 @@ function createCore({ sessions, bus, version }) {
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path17.join(os4.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path19.join(os5.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
   }
   async function removeTaskWorktree(task) {
     if (!task.projectPath || !task.worktreePath) return;
     const branch = task.branch || fallbackBranchName(task.id);
     await removeWorktree(task.projectPath, task.worktreePath);
-    deleteArtifacts(task.workspacePath ?? path17.dirname(task.worktreePath), task.worktreePath);
+    deleteArtifacts(task.workspacePath ?? path19.dirname(task.worktreePath), task.worktreePath);
     await deleteBranch(task.projectPath, branch);
   }
   const handlers = {
@@ -4720,66 +4979,7 @@ function createCore({ sessions, bus, version }) {
       return getState();
     },
     "vibeflow:setSettings": (patch) => {
-      const p = obj(patch, "patch");
-      const { agentConnections: _ignored, ...rest } = p;
-      setSettings(rest);
-      return getState();
-    },
-    "settings:connectAgent": async (payload) => {
-      const { agentId: rawId, apiKey } = obj(payload, "payload");
-      const id = agentId(rawId);
-      const key = str(apiKey, "apiKey");
-      const models = await fetchAgentModels(id, key);
-      const state = getState();
-      setSettings({
-        agentConnections: {
-          ...state.settings.agentConnections ?? {},
-          [id]: {
-            connected: true,
-            apiKey: key.trim(),
-            models,
-            error: void 0,
-            updatedAt: Date.now()
-          }
-        }
-      });
-      return getState();
-    },
-    "settings:refreshAgentModels": async (rawId) => {
-      const id = agentId(rawId);
-      const connections = getState().settings.agentConnections ?? {};
-      const existing = connections[id];
-      if (!existing?.apiKey) {
-        setSettings({
-          agentConnections: {
-            ...connections,
-            [id]: { connected: false, models: [], error: "\u5C1A\u672A\u7D81\u5B9A API key\u3002", updatedAt: Date.now() }
-          }
-        });
-        return getState();
-      }
-      try {
-        const models = await fetchAgentModels(id, existing.apiKey);
-        setSettings({
-          agentConnections: {
-            ...connections,
-            [id]: { ...existing, connected: true, models, error: void 0, updatedAt: Date.now() }
-          }
-        });
-      } catch (err) {
-        setSettings({
-          agentConnections: {
-            ...connections,
-            [id]: {
-              ...existing,
-              connected: false,
-              models: [],
-              error: err instanceof Error ? err.message : String(err),
-              updatedAt: Date.now()
-            }
-          }
-        });
-      }
+      setSettings(obj(patch, "patch"));
       return getState();
     },
     "settings:githubAuthStatus": () => getGitHubCliAuthStatus(),
@@ -4791,6 +4991,10 @@ function createCore({ sessions, bus, version }) {
     },
     "settings:logoutGithubAuth": () => logoutGitHubCli(),
     "env:detectAgents": () => detectAgents(),
+    "agents:listModels": (payload) => {
+      const { agentId: rawId, refresh } = obj(payload, "payload");
+      return listAgentModels(agentId(rawId), { refresh: refresh === true });
+    },
     // 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.
     "git:getInfo": (projectPath) => getGitInfo(str(projectPath ?? "", "projectPath")),
@@ -4803,8 +5007,8 @@ function createCore({ sessions, bus, version }) {
     "projects:listRecent": () => listRecentProjects(getStore()),
     // `vibeflow open <path>` while a host runs: only the host writes the store.
     "projects:record": (projectPath) => {
-      const p = path17.resolve(str(projectPath, "projectPath"));
-      if (!fs13.existsSync(p) || !fs13.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
+      const p = path19.resolve(str(projectPath, "projectPath"));
+      if (!fs15.existsSync(p) || !fs15.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
       recordRecentProject(getStore(), p);
       return listRecentProjects(getStore());
     },
@@ -4844,7 +5048,7 @@ function createCore({ sessions, bus, version }) {
       if (!task.baseBranch) throw new Error("\u4EFB\u52D9\u6C92\u6709\u8A18\u9304 base branch\uFF0C\u7121\u6CD5\u9084\u539F worktree");
       await teardownTask(task.id);
       await resetWorktreeToBase(task.worktreePath, task.baseBranch);
-      const workspacePath = task.workspacePath ?? path17.dirname(task.worktreePath);
+      const workspacePath = task.workspacePath ?? path19.dirname(task.worktreePath);
       deleteArtifacts(workspacePath, task.worktreePath);
       deleteDecisions(workspacePath, decisionsKey(task.worktreePath, task.branch));
       resetSubAgents(task.worktreePath);
@@ -4883,9 +5087,9 @@ function createCore({ sessions, bus, version }) {
         if (!info.isRepo) throw new Error("\u76EE\u6A19\u8CC7\u6599\u593E\u4E0D\u662F git repository");
         await teardownTask(existing.id);
         await removeTaskWorktree(existing);
-        const projectName = path17.basename(nextProject);
+        const projectName = path19.basename(nextProject);
         const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
-        await fs13.promises.mkdir(workspacePath, { recursive: true });
+        await fs15.promises.mkdir(workspacePath, { recursive: true });
         const result = await provisionWorktree(
           nextProject,
           workspacePath,
@@ -4973,7 +5177,7 @@ function createCore({ sessions, bus, version }) {
     "claude:sessionExists": (taskId) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return false;
-      return fs13.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
+      return fs15.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
     },
     "sessions:list": async () => {
       const keys = await sessions.list();
@@ -4992,9 +5196,9 @@ function createCore({ sessions, bus, version }) {
     "git:getDiffEntries": (taskId, opts) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return [];
-      const fetch2 = opts && typeof opts === "object" ? opts.fetch : void 0;
+      const fetch = opts && typeof opts === "object" ? opts.fetch : void 0;
       return getWorktreeDiffEntries(task.worktreePath, task.baseBranch ?? "HEAD", {
-        fetch: typeof fetch2 === "boolean" ? fetch2 : void 0
+        fetch: typeof fetch === "boolean" ? fetch : void 0
       });
     },
     "git:getDiffFile": (taskId, filePath) => {
@@ -5020,7 +5224,7 @@ function createCore({ sessions, bus, version }) {
       const task = requireTask(taskId);
       if (!task.worktreePath || !task.workspacePath) return "task has no worktree";
       const dir = agentArtifactsPath(task.workspacePath, task.worktreePath);
-      if (!fs13.existsSync(dir)) return "artifacts directory does not exist yet";
+      if (!fs15.existsSync(dir)) return "artifacts directory does not exist yet";
       return getPlatform().openPath(dir);
     },
     "task:getDecisions": (taskId) => {
@@ -5029,7 +5233,7 @@ function createCore({ sessions, bus, version }) {
       return readDecisions(task.workspacePath, decisionsKey(task.worktreePath, task.branch));
     },
     "board:getCliLaunchInfo": () => boardCliLaunchInfo(),
-    "library:list": async () => listLibrary(await libraryRoot()),
+    "library:list": async () => listLibrary(await libraryRoot(), builtinSkillsDir()),
     // The source path was picked by the user (native picker or typed path).
     "library:import": async (payload) => {
       const p = obj(payload, "payload");
@@ -5068,6 +5272,11 @@ function createCore({ sessions, bus, version }) {
       deleteEntry(await libraryRoot(), libraryKind(p.kind), str(p.name, "name"));
       return true;
     },
+    "library:restoreBuiltin": async (payload) => {
+      const p = obj(payload, "payload");
+      return restoreBuiltinSkill(await libraryRoot(), builtinSkillsDir(), str(p.name, "name"));
+    },
+    "library:removedBuiltins": async () => removedBuiltinSkills(await libraryRoot(), builtinSkillsDir()),
     // Approve: commit everything in the worktree and push the branch upstream.
     "git:approve": async (payload) => {
       const p = obj(payload, "payload");
@@ -5173,9 +5382,9 @@ function createCore({ sessions, bus, version }) {
     // Watch the containing directory, not the file: JsonStore renames a temp
     // file over the target and so replaces the inode on every save.
     watchStore() {
-      const file = path17.basename(getStorePath());
+      const file = path19.basename(getStorePath());
       let debounce = null;
-      storeWatcher = fs13.watch(path17.dirname(getStorePath()), (_event, filename) => {
+      storeWatcher = fs15.watch(path19.dirname(getStorePath()), (_event, filename) => {
         if (filename !== file) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -5207,9 +5416,9 @@ function createSessionBackend(sink, choice) {
 }
 
 // packages/core/src/web-server.ts
-import fs14 from "fs";
+import fs16 from "fs";
 import http from "http";
-import path18 from "path";
+import path20 from "path";
 import { timingSafeEqual } from "crypto";
 import { WebSocketServer } from "ws";
 var TOKEN_COOKIE = "vf_token";
@@ -5262,14 +5471,14 @@ function resolveStatic(root, urlPath) {
     return null;
   }
   if (decoded.includes("\0")) return null;
-  const rel = path18.posix.normalize(decoded).replace(/^\/+/, "");
-  const base = path18.resolve(root);
-  const candidates = [rel, path18.posix.join(rel, "index.html"), `${rel}.html`];
+  const rel = path20.posix.normalize(decoded).replace(/^\/+/, "");
+  const base = path20.resolve(root);
+  const candidates = [rel, path20.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path18.resolve(base, c);
-    if (full !== base && !full.startsWith(base + path18.sep)) return null;
+    const full = path20.resolve(base, c);
+    if (full !== base && !full.startsWith(base + path20.sep)) return null;
     try {
-      if (fs14.statSync(full).isFile()) return full;
+      if (fs16.statSync(full).isFile()) return full;
     } catch {
     }
   }
@@ -5330,7 +5539,7 @@ async function startWebServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const ext = path18.extname(file).toLowerCase();
+    const ext = path20.extname(file).toLowerCase();
     const immutable = url.pathname.startsWith("/_next/static/");
     res.writeHead(200, {
       "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream",
@@ -5343,7 +5552,7 @@ async function startWebServer(options) {
       res.end();
       return;
     }
-    fs14.createReadStream(file).pipe(res);
+    fs16.createReadStream(file).pipe(res);
   }
   const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
   function reject(socket, status, reason) {
@@ -5468,6 +5677,7 @@ async function startHost(options) {
     return startHost(options);
   }
   try {
+    await syncBuiltinsAtStartup();
     const bus = new EventBus();
     const sessions = createSessionBackend(bus.sink(), {
       prefer: options.backend,
@@ -5514,7 +5724,7 @@ function loginUrl(lock, pathname = "/home/") {
   return `http://127.0.0.1:${lock.port}${pathname}?token=${encodeURIComponent(lock.token)}`;
 }
 function isWebDir(dir) {
-  return fs15.existsSync(path19.join(dir, "home", "index.html"));
+  return fs17.existsSync(path21.join(dir, "home", "index.html"));
 }
 
 // packages/cli/src/remote.ts
@@ -5631,14 +5841,14 @@ function connectToHost(lock) {
 }
 
 // packages/cli/src/doctor.ts
-import fs16 from "fs";
-import path20 from "path";
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify4 } from "util";
+import fs18 from "fs";
+import path22 from "path";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify5 } from "util";
 init_env();
 init_git_bash();
 init_tmux_backend();
-var pexec4 = promisify4(execFile6);
+var pexec5 = promisify5(execFile7);
 function parseVersion(text) {
   const m = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(text);
   return m ? [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)] : [];
@@ -5652,7 +5862,7 @@ function versionAtLeast(have, want) {
 }
 async function run(cmd, args) {
   try {
-    const { stdout } = await pexec4(cmd, args, { env: execEnv(), timeout: 1e4, windowsHide: true });
+    const { stdout } = await pexec5(cmd, args, { env: execEnv(), timeout: 1e4, windowsHide: true });
     return String(stdout).trim();
   } catch {
     return null;
@@ -5772,10 +5982,10 @@ async function runDoctor(options) {
     });
   }
   try {
-    fs16.mkdirSync(options.userDataDir, { recursive: true });
-    const probe = path20.join(options.userDataDir, `.doctor-${process.pid}`);
-    fs16.writeFileSync(probe, "");
-    fs16.rmSync(probe);
+    fs18.mkdirSync(options.userDataDir, { recursive: true });
+    const probe = path22.join(options.userDataDir, `.doctor-${process.pid}`);
+    fs18.writeFileSync(probe, "");
+    fs18.rmSync(probe);
     checks.push({ id: "data", name: "\u8CC7\u6599\u76EE\u9304", level: "ok", detail: options.userDataDir });
   } catch (err) {
     checks.push({
@@ -5829,24 +6039,24 @@ Options:
 `.trim();
 function detectLayout() {
   const file = fileURLToPath(import.meta.url);
-  const here = path23.dirname(file);
-  const bundledWeb = path23.join(here, "web");
-  if (isWebDir(bundledWeb) || path23.basename(here) === "dist") {
+  const here = path25.dirname(file);
+  const bundledWeb = path25.join(here, "web");
+  if (isWebDir(bundledWeb) || path25.basename(here) === "dist") {
     return {
-      version: readVersion(path23.join(here, "..", "package.json")),
+      version: readVersion(path25.join(here, "..", "package.json")),
       webDir: isWebDir(bundledWeb) ? bundledWeb : null,
       sourceRoot: null,
       cliEntry: file
     };
   }
-  const root = path23.resolve(here, "..", "..", "..");
+  const root = path25.resolve(here, "..", "..", "..");
   const override = process.env.VIBEFLOW_WEB_DIR;
-  const webDir = override && isWebDir(override) ? override : isWebDir(path23.join(root, "app")) ? path23.join(root, "app") : null;
-  return { version: readVersion(path23.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
+  const webDir = override && isWebDir(override) ? override : isWebDir(path25.join(root, "app")) ? path25.join(root, "app") : null;
+  return { version: readVersion(path25.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
 }
 function readVersion(pkgPath) {
   try {
-    return JSON.parse(fs18.readFileSync(pkgPath, "utf8")).version;
+    return JSON.parse(fs20.readFileSync(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -6052,8 +6262,8 @@ async function cmdOpen(values, target, layout, userDataDir) {
     console.error("\u7528\u6CD5\uFF1Avibeflow open <path>");
     return 1;
   }
-  const dir = path23.resolve(target);
-  if (!fs18.existsSync(dir) || !fs18.statSync(dir).isDirectory()) {
+  const dir = path25.resolve(target);
+  if (!fs20.existsSync(dir) || !fs20.statSync(dir).isDirectory()) {
     console.error(`\u4E0D\u662F\u8CC7\u6599\u593E\uFF1A${dir}`);
     return 1;
   }