@kw-yeh/vibeflow 4.0.6 → 4.2.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 fs18 from "fs";
+import fs20 from "fs";
 import os6 from "os";
-import path22 from "path";
+import path24 from "path";
 import React, { useEffect, useRef, useState } from "react";
 import { Box, Text, render, useApp, useInput } from "ink";
 function newFormState(defaultAutoMode, agents) {
@@ -719,17 +719,17 @@ function editorCommand(env, platform) {
   return env.VISUAL?.trim() || env.EDITOR?.trim() || (platform === "win32" ? "notepad" : "vi");
 }
 function editInEditor(text) {
-  const dir = fs18.mkdtempSync(path22.join(os6.tmpdir(), "vibeflow-"));
-  const file = path22.join(dir, "description.md");
+  const dir = fs20.mkdtempSync(path24.join(os6.tmpdir(), "vibeflow-"));
+  const file = path24.join(dir, "description.md");
   try {
-    fs18.writeFileSync(file, text);
+    fs20.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: fs18.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
+    return { text: fs20.readFileSync(file, "utf8").replace(/\r?\n$/, "") };
   } finally {
-    fs18.rmSync(dir, { recursive: true, force: true });
+    fs20.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(path22.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir())));
+      if (value2) setProject(path24.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir())));
     } else if (editing === "attachments" && value2) {
-      const file = path22.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir()));
-      if (!fs18.existsSync(file) || !fs18.statSync(file).isFile()) {
+      const file = path24.resolve(value2.replace(/^~(?=$|\/)/, os6.homedir()));
+      if (!fs20.existsSync(file) || !fs20.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 ? path22.basename(s.projectPath) : "\u2014"}\uFF08\u4EFB\u52D9\u5DF2\u958B\u59CB\uFF0C\u9396\u5B9A\uFF09`;
+        if (projectLocked) return `${s.projectPath ? path24.basename(s.projectPath) : "\u2014"}\uFF08\u4EFB\u52D9\u5DF2\u958B\u59CB\uFF0C\u9396\u5B9A\uFF09`;
         if (!s.projectPath) return ctx.recent.length ? "\u2190/\u2192 \u9078\u64C7\u4F7F\u7528\u904E\u7684\u5C08\u6848\uFF0C\u6216 Enter \u8F38\u5165\u8DEF\u5F91" : "Enter \u8F38\u5165\u5C08\u6848\u8CC7\u6599\u593E\u7684\u7D55\u5C0D\u8DEF\u5F91";
         return `${s.projectPath}${missing ? "\uFF08\u8DEF\u5F91\u907A\u5931\uFF09" : ""}`;
       }
@@ -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) => path22.basename(a)).join("\u3001") : "\uFF08Enter \u8F38\u5165\u6A94\u6848\u8DEF\u5F91\u52A0\u5165\uFF09";
+        return s.attachments.length ? s.attachments.map((a) => path24.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");
@@ -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"}/${path22.basename(s.projectPath)}`;
+      if (info?.isRepo && s.projectPath) return `worktree \u6703\u5EFA\u5728 ${ctx.workstationPath || "~/Desktop"}/${path24.basename(s.projectPath)}`;
     }
     if (field === "branch") return info?.hasRemote ? "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\uFF1B\u82E5 remote \u5DF2\u6709\u9019\u500B\u5206\u652F\uFF0C\u5247\u76F4\u63A5\u53D6\u56DE\u4E26\u63A5\u7E8C\u4E0A\u9762\u7684\u5DE5\u4F5C\u3002" : "\u586B\u5BEB\u5F8C\u6703\u5EFA\u7ACB\u540C\u540D\u5206\u652F\u3002";
     if (field === "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`;
@@ -1029,7 +1029,7 @@ __export(src_exports, {
   showDiff: () => showDiff
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import path23 from "path";
+import path25 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) {
@@ -1291,7 +1291,7 @@ function showDiff(task) {
   });
 }
 function tmuxAttach(opts, sessionName) {
-  const conf = path23.join(opts.userDataDir, "tmux.conf");
+  const conf = path25.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 : "" } });
@@ -1421,8 +1421,8 @@ var init_src = __esm({
 });
 
 // packages/cli/src/main.ts
-import fs19 from "fs";
-import path24 from "path";
+import fs21 from "fs";
+import path26 from "path";
 import { fileURLToPath } from "url";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -1526,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);
@@ -1808,8 +1814,8 @@ function createBridge(t) {
      * in-app preview will not inline. Resolves to '' on success, else a reason.
      */
     openArtifactsDir: (taskId) => t.invoke("task:openArtifactsDir", taskId),
-    /** The task's decision record; null when it has no workspace folder. */
-    getDecisions: (taskId) => t.invoke("task:getDecisions", taskId),
+    /** Every spec.md the task's branch added or changed; empty when there is none. */
+    getSpecs: (taskId) => t.invoke("task:getSpecs", taskId),
     /** Store dir + CLI paths for launch injection, so an agent can write cards. */
     getBoardCliLaunchInfo: () => t.invoke("board:getCliLaunchInfo"),
     /** VibeFlow's own skill / prompt / script store. */
@@ -1821,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),
@@ -2691,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);
@@ -3530,8 +3574,8 @@ async function taskCommand(argv) {
 }
 
 // packages/cli/src/host.ts
-import fs16 from "fs";
-import path20 from "path";
+import fs18 from "fs";
+import path22 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // packages/core/src/events.ts
@@ -3557,190 +3601,701 @@ var EventBus = class {
   }
 };
 
-// packages/core/src/service.ts
-import fs14 from "fs";
-import os5 from "os";
-import path18 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-models.ts
-import { execFile as execFile5 } from "child_process";
+// packages/core/src/library.ts
+import { createHash } from "crypto";
 import fs10 from "fs";
 import os3 from "os";
 import path14 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 : path14.join(os3.homedir(), ".codex");
+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")
+  };
 }
-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;
+async function libraryRoot() {
+  return path14.join(getPlatform().userDataDir(), LIBRARY_DIR);
 }
-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
-    });
+function truncateUtf82(value, maxBytes) {
+  let result = "";
+  for (const character of value) {
+    if (Buffer.byteLength(result + character) > maxBytes) break;
+    result += character;
   }
-  if (models.length === 0) throw new Error("Codex model catalog lists no selectable models");
-  return models;
+  return result;
 }
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
+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";
 }
-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) };
-    }
+function entryKey(kind, name) {
+  return `${kind}/${name}`;
+}
+function indexPath(root) {
+  return path14.join(root, INDEX_FILE);
+}
+function readIndexFile(root) {
+  let raw;
+  try {
+    raw = fs10.readFileSync(indexPath(root), "utf8");
+  } catch {
+    return { version: 1, entries: {} };
   }
-  const cachePath = path14.join(opts.codexHome ?? defaultCodexHome(), "models_cache.json");
   try {
-    const raw = await fs10.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) }
-    };
+    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 };
+    }
+  } catch {
   }
+  return null;
 }
-
-// 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 readIndex(root) {
+  return readIndexFile(root) ?? { version: 1, entries: {} };
 }
-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 indexIsCorrupt(root) {
+  return readIndexFile(root) === 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 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 errorMessage2(err) {
-  if (err instanceof Error) return err.message;
-  return String(err);
+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;
 }
-async function getGitHubCliAuthStatus() {
+function readSkillDescription(skillMdPath) {
+  let content;
   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
-    };
+    content = fs10.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;
 }
-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
+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);
     }
-  );
-  return getGitHubCliAuthStatus();
+  };
+  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 cancelGitHubCliLogin() {
-  if (!activeLogin) return;
+function builtinStatus(full, name, recorded, builtinDir) {
   try {
-    activeLogin.kill();
+    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;
+      }
+    }
+    return { modified, updateAvailable };
   } catch {
+    return { modified: true, updateAvailable: false };
   }
-  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",
+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;
+    }
+    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
+      });
+    }
+  }
+  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 fs16 from "fs";
+import os5 from "os";
+import path20 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,
@@ -3790,53 +4345,100 @@ function startGitHubCliLogin(onEvent) {
 }
 
 // packages/core/src/board-cli.ts
-import fs11 from "fs";
-import path15 from "path";
+import fs13 from "fs";
+import path17 from "path";
 import { pathToFileURL } from "url";
 async function boardCliLaunchInfo() {
-  const storeDir = path15.dirname(getStorePath());
+  const storeDir = path17.dirname(getStorePath());
   const entry = getPlatform().cliEntry?.();
-  if (entry && fs11.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 = path15.join(root, "scripts", "vibeflow.mjs");
-  const loaderPath = path15.join(root, "test", "support", "register.mjs");
-  if (!fs11.existsSync(cliPath) || !fs11.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 fs12 from "fs";
-import path16 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 ? path16.basename(worktreePath) : branch.replace(/\//g, "-");
+  return worktreePath ? path18.basename(worktreePath) : branch.replace(/\//g, "-");
 }
 function decisionsPath(workspacePath, key) {
-  return path16.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
+  return path18.join(workspacePath, `${key}${DECISIONS_FILE_SUFFIX}`);
 }
-function readDecisions(workspacePath, key) {
-  const target = decisionsPath(workspacePath, key);
+function deleteDecisions(workspacePath, key) {
   try {
-    const stat = fs12.statSync(target);
-    if (!stat.isFile()) return { path: target, markdown: null };
-    const buf = fs12.readFileSync(target);
-    return {
-      path: target,
-      markdown: buf.subarray(0, MAX_DECISION_BYTES).toString("utf8"),
-      updatedAt: stat.mtimeMs,
-      ...buf.byteLength > MAX_DECISION_BYTES ? { truncated: true } : {}
-    };
+    fs14.rmSync(decisionsPath(workspacePath, key), { force: true });
   } catch {
-    return { path: target, markdown: null };
   }
 }
-function deleteDecisions(workspacePath, key) {
+
+// packages/core/src/specs.ts
+import fs15 from "fs";
+import path19 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;
+}
+function clip2(buf) {
+  return {
+    markdown: buf.subarray(0, MAX_SPEC_BYTES).toString("utf8"),
+    ...buf.byteLength > MAX_SPEC_BYTES ? { truncated: true } : {}
+  };
+}
+async function readWorktreeSpecs(worktreePath, baseBranch) {
+  const baseRef = await resolveBaseRef(worktreePath, baseBranch);
+  const entries = await collectDiffEntries(worktreePath, baseRef);
+  const specs = [];
+  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);
+      if (!stat.isFile()) continue;
+      specs.push({ path: entry.path, ...clip2(fs15.readFileSync(full)), updatedAt: stat.mtimeMs });
+    } catch {
+    }
+  }
+  return specs.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function readBranchSpecs(projectPath, branch, baseBranch, changedPaths) {
+  const ref = `refs/heads/${branch}`;
   try {
-    fs12.rmSync(decisionsPath(workspacePath, key), { force: true });
+    await git(projectPath, ["rev-parse", "--verify", ref]);
   } catch {
+    return [];
+  }
+  let paths = changedPaths;
+  if (!paths) {
+    const baseRef = await resolveBaseRef(projectPath, baseBranch);
+    const names = await git(projectPath, [
+      "diff",
+      "--name-only",
+      "--diff-filter=d",
+      `${baseRef}...${ref}`
+    ]).catch(() => "");
+    paths = names.split("\n").map((l) => l.trim());
+  }
+  const specs = [];
+  for (const p of paths.filter(isSpecPath)) {
+    try {
+      const content = await git(projectPath, ["show", `${ref}:${p}`]);
+      const ct = await git(projectPath, ["log", "-1", "--format=%ct", ref, "--", p]);
+      specs.push({
+        path: p,
+        ...clip2(Buffer.from(content, "utf8")),
+        ...ct ? { updatedAt: Number(ct) * 1e3 } : {}
+      });
+    } catch {
+    }
   }
+  return specs.sort((a, b) => a.path.localeCompare(b.path));
 }
 
 // packages/core/src/chat-session.ts
@@ -4042,432 +4644,89 @@ ${attachmentLines.join("\n")}` : text;
                 phaseType: "thinking",
                 phaseSummary: "Thinking\u2026",
                 phaseDetail: block.thinking,
-                done: true
-              });
-            } else if (block.type === "tool_use" && block.name) {
-              const toolId = block.id ?? "";
-              toolNames.set(toolId, block.name);
-              const { summary, detail } = summarizeToolUse(block.name, block.input ?? {});
-              pushPhase({
-                taskId,
-                id: `${taskId}-${seq++}`,
-                phaseType: "tool_use",
-                phaseSummary: summary,
-                phaseDetail: detail,
-                done: true
-              });
-            }
-          }
-        }
-        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 fs13 from "fs";
-import os4 from "os";
-import path17 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: path17.join(root, KIND_DIR.skill),
-    prompts: path17.join(root, KIND_DIR.prompt),
-    scripts: path17.join(root, KIND_DIR.script),
-    plugin: path17.join(root, "plugin"),
-    codexHome: path17.join(root, "codex-home")
-  };
-}
-async function libraryRoot() {
-  return path17.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 path17.join(root, INDEX_FILE);
-}
-function readIndex(root) {
-  try {
-    const parsed = JSON.parse(fs13.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) {
-  fs13.mkdirSync(root, { recursive: true });
-  fs13.writeFileSync(indexPath(root), `${JSON.stringify(index, null, 2)}
-`);
-}
-function ensureLibrary(root) {
-  const paths = libraryPaths(root);
-  for (const kind of LIBRARY_KINDS) {
-    fs13.mkdirSync(path17.join(root, KIND_DIR[kind]), { recursive: true });
-  }
-  return paths;
-}
-function readSkillDescription(skillMdPath) {
-  let content;
-  try {
-    content = fs13.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 path17.join(root, KIND_DIR[kind], name);
-}
-function listLibrary(root) {
-  const index = readIndex(root);
-  const entries = [];
-  for (const kind of LIBRARY_KINDS) {
-    const dir = path17.join(root, KIND_DIR[kind]);
-    let dirents;
-    try {
-      dirents = fs13.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const dirent of dirents) {
-      if (dirent.name.startsWith(".")) continue;
-      const wantsDirectory = kind === "skill";
-      let stat;
-      try {
-        stat = fs13.statSync(path17.join(dir, dirent.name));
+                done: true
+              });
+            } else if (block.type === "tool_use" && block.name) {
+              const toolId = block.id ?? "";
+              toolNames.set(toolId, block.name);
+              const { summary, detail } = summarizeToolUse(block.name, block.input ?? {});
+              pushPhase({
+                taskId,
+                id: `${taskId}-${seq++}`,
+                phaseType: "tool_use",
+                phaseSummary: summary,
+                phaseDetail: detail,
+                done: true
+              });
+            }
+          }
+        }
+        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 = path17.join(dir, name);
-      if (wantsDirectory && !fs13.existsSync(path17.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(path17.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 = path17.resolve(sourcePath);
-  const stat = fs13.statSync(resolved);
-  if (kind === "skill") {
-    if (!stat.isDirectory()) throw new Error("skill \u5FC5\u9808\u662F\u542B SKILL.md \u7684\u76EE\u9304");
-    if (!fs13.existsSync(path17.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(path17.basename(resolved));
-  const target = entryPath(root, kind, name);
-  fs13.rmSync(target, { recursive: true, force: true });
-  fs13.cpSync(resolved, target, { recursive: kind === "skill", dereference: true });
-  if (kind === "script") fs13.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 (fs13.existsSync(target)) throw new Error(`\u5DF2\u5B58\u5728\u540C\u540D\u9805\u76EE\uFF1A${name}`);
-  if (kind === "skill") {
-    fs13.mkdirSync(target, { recursive: true });
-    fs13.writeFileSync(path17.join(target, "SKILL.md"), content);
-  } else {
-    fs13.writeFileSync(target, content);
-    if (kind === "script") fs13.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 (!fs13.existsSync(target)) throw new Error(`\u627E\u4E0D\u5230\u9805\u76EE\uFF1A${name}`);
-  fs13.writeFileSync(kind === "skill" ? path17.join(target, "SKILL.md") : target, content);
-  return requireEntry(root, kind, name);
-}
-function readEntryContent(root, kind, name) {
-  const target = entryPath(root, kind, name);
-  return fs13.readFileSync(kind === "skill" ? path17.join(target, "SKILL.md") : target, "utf8");
-}
-function deleteEntry(root, kind, name) {
-  fs13.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 path17.join(worktreePath, ".claude", "skills");
-}
-function skillNamesIn(dir) {
-  try {
-    return fs13.readdirSync(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).map((d) => d.name).filter((name) => fs13.existsSync(path17.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);
-  fs13.rmSync(path17.join(paths.plugin, "skills"), { recursive: true, force: true });
-  fs13.mkdirSync(path17.join(paths.plugin, PLUGIN_MANIFEST_DIR), { recursive: true });
-  fs13.mkdirSync(path17.join(paths.plugin, "skills"), { recursive: true });
-  fs13.writeFileSync(
-    path17.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) {
-    fs13.cpSync(entry.path, path17.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 (!fs13.existsSync(target)) return false;
-  const source = path17.resolve(target);
-  const attempts = fs13.statSync(source).isDirectory() ? [
-    () => fs13.symlinkSync(source, linkPath, "junction"),
-    () => fs13.cpSync(source, linkPath, { recursive: true, dereference: true })
-  ] : [
-    () => fs13.symlinkSync(source, linkPath),
-    () => fs13.linkSync(source, linkPath),
-    () => fs13.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 {
-      fs13.rmSync(linkPath, { recursive: true, force: true });
-      attempt();
-      return true;
+      proc.kill("SIGTERM");
     } catch {
     }
-  }
-  return false;
-}
-function buildCodexHome(root, worktreePath, userCodexHome = path17.join(os4.homedir(), ".codex")) {
-  const paths = libraryPaths(root);
-  const skillsDir = path17.join(paths.codexHome, "skills");
-  fs13.rmSync(skillsDir, { recursive: true, force: true });
-  fs13.mkdirSync(skillsDir, { recursive: true });
-  for (const file of ["auth.json", "config.toml"]) {
-    linkOrSkip(path17.join(userCodexHome, file), path17.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(path17.join(projectDir, name), path17.join(skillsDir, name))) {
-        result.project.push(name);
-        claimed.set(name, "project");
-      }
-    }
-  }
-  const userDir = path17.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(path17.join(userDir, name), path17.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;
-    }
-    fs13.cpSync(entry.path, path17.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";
 var SCRATCH_DIR_NAME2 = "scratch";
@@ -4493,22 +4752,6 @@ function buildArtifactPrompt(artifactsDir = ARTIFACTS_FALLBACK_DIR2) {
     "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 DECISIONS_FILE_SUFFIX2 = ".DECISIONS.md";
-function taskDecisionsPath(worktreePath, workspacePath) {
-  if (!worktreePath || !workspacePath) return null;
-  return `${toShellPath(workspacePath)}/${pathBasename(worktreePath)}${DECISIONS_FILE_SUFFIX2}`;
-}
-function buildDecisionPrompt(decisionsPath2) {
-  return [
-    "\u6C7A\u7B56\u66F8\uFF08\u672C\u6B21 session \u5168\u7A0B\u9069\u7528\uFF09\uFF1A",
-    `1. \u672C\u4EFB\u52D9\u7684\u6C7A\u7B56\u66F8\u662F ${decisionsPath2}\uFF1B\u505A\u51FA\u65B0\u6C7A\u7B56\u3001\u6216\u8ABF\u6574\u65E2\u6709\u6C7A\u7B56\u6642\uFF0C\u7576\u4E0B\u5C31\u66F4\u65B0\u5B83\uFF08\u4E0D\u5B58\u5728\u8ACB\u5EFA\u7ACB\uFF09\u3002`,
-    "2. \u53EA\u5BEB\u300C\u9019\u6B21\u65B0\u589E\u4E86\u4EC0\u9EBC\u6C7A\u7B56\u3001\u8ABF\u6574\u4E86\u4EC0\u9EBC\u65E2\u6709\u6C7A\u7B56\u300D\u8207\u7406\u7531\u3002\u9700\u6C42\u8986\u8FF0\u3001\u9032\u5EA6\u56DE\u5831\u3001\u5BE6\u4F5C\u6D41\u6C34\u5E33\u3001\u672C\u4F86\u5C31\u6210\u7ACB\u7684\u6163\u4F8B\u90FD\u4E0D\u8981\u5BEB\u3002",
-    "3. \u6BCF\u5247\u6C7A\u7B56\u4E00\u500B `## <\u4E00\u53E5\u8A71\u8B1B\u5B8C\u7684\u6C7A\u7B56>` \u6BB5\u843D\uFF0C\u5E95\u4E0B 2-4 \u884C\u4EA4\u4EE3\uFF1A\u70BA\u4EC0\u9EBC\u9019\u6A23\u9078\u3001\u5426\u6C7A\u4E86\u4EC0\u9EBC\u66FF\u4EE3\u65B9\u6848\u3001\u8AB0\u4E4B\u5F8C\u6703\u88AB\u9019\u500B\u6C7A\u7B56\u7D81\u4F4F\u3002",
-    "4. \u8981\u8AAA\u660E\u6D41\u7A0B\u3001\u72C0\u614B\u8F49\u63DB\u6216\u6A21\u7D44\u95DC\u4FC2\u6642\uFF0C\u7528 mermaid fence \u756B\u5716\uFF0CVibeFlow \u6703\u76F4\u63A5\u6E32\u67D3\u3002",
-    "5. \u9019\u6B21\u6C92\u6709\u4EFB\u4F55\u6C7A\u7B56\u5C31\u4E0D\u8981\u5EFA\u7ACB\u9019\u500B\u6A94\u6848\uFF1B\u5BE7\u53EF\u7559\u767D\uFF0C\u4E0D\u8981\u6E4A\u5167\u5BB9\u3002",
-    "6. \u7528\u7E41\u9AD4\u4E2D\u6587\u66F8\u5BEB\uFF0C\u7A0B\u5F0F\u8B58\u5225\u5B57\u4FDD\u7559\u82F1\u6587\u3002"
-  ].join("\n");
-}
 var AUTO_PERMISSION_MODE = "auto";
 function claudePermissionFlag(autoMode) {
   return autoMode ? ` --permission-mode ${AUTO_PERMISSION_MODE}` : "";
@@ -4637,11 +4880,9 @@ function buildAgentCommand(task, systemPrompt, opts, workspacePath) {
   const model = taskModel(task);
   const artifactsDir = agentArtifactsDir(task.worktreePath, workspacePath) ?? ARTIFACTS_FALLBACK_DIR2;
   const builtInPrompt = buildArtifactPrompt(artifactsDir);
-  const decisionsPath2 = taskDecisionsPath(task.worktreePath, workspacePath);
-  const decisionPrompt = decisionsPath2 ? buildDecisionPrompt(decisionsPath2) : "";
   const libraryPrompt = opts?.library?.promptText?.trim();
   const customPrompt = resolveSystemPrompt(systemPrompt);
-  const sys = [builtInPrompt, decisionPrompt, libraryPrompt, customPrompt].filter(Boolean).join("\n\n");
+  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;
@@ -4750,13 +4991,13 @@ function createCore({ sessions, bus, version }) {
   }
   function claudeSessionFile(cwd, sessionId) {
     const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-    return path18.join(os5.homedir(), ".claude", "projects", munged, `${sessionId}.jsonl`);
+    return path20.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 ?? path18.dirname(task.worktreePath), task.worktreePath);
+    deleteArtifacts(task.workspacePath ?? path20.dirname(task.worktreePath), task.worktreePath);
     await deleteBranch(task.projectPath, branch);
   }
   const handlers = {
@@ -4795,8 +5036,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 = path18.resolve(str(projectPath, "projectPath"));
-      if (!fs14.existsSync(p) || !fs14.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
+      const p = path20.resolve(str(projectPath, "projectPath"));
+      if (!fs16.existsSync(p) || !fs16.statSync(p).isDirectory()) invalid(`not a directory: ${p}`);
       recordRecentProject(getStore(), p);
       return listRecentProjects(getStore());
     },
@@ -4828,7 +5069,7 @@ function createCore({ sessions, bus, version }) {
     },
     // Discard everything the last run left behind — the PTY session, the
     // sub-agent timeline, the conversation id, the code it changed, its artifacts
-    // and its decision record — so the next launch starts over as if the card
+    // and its legacy decision record — so the next launch starts over as if the card
     // were new. Launching again is the caller's decision.
     "vibeflow:resetTaskRun": async (taskId) => {
       const task = requireTask(taskId);
@@ -4836,7 +5077,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 ?? path18.dirname(task.worktreePath);
+      const workspacePath = task.workspacePath ?? path20.dirname(task.worktreePath);
       deleteArtifacts(workspacePath, task.worktreePath);
       deleteDecisions(workspacePath, decisionsKey(task.worktreePath, task.branch));
       resetSubAgents(task.worktreePath);
@@ -4875,9 +5116,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 = path18.basename(nextProject);
+        const projectName = path20.basename(nextProject);
         const workspacePath = projectWorkstationPath(resolveWorkstationPath(getSettings()), projectName);
-        await fs14.promises.mkdir(workspacePath, { recursive: true });
+        await fs16.promises.mkdir(workspacePath, { recursive: true });
         const result = await provisionWorktree(
           nextProject,
           workspacePath,
@@ -4965,7 +5206,7 @@ function createCore({ sessions, bus, version }) {
     "claude:sessionExists": (taskId) => {
       const task = requireTask(taskId);
       if (!task.worktreePath) return false;
-      return fs14.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
+      return fs16.existsSync(claudeSessionFile(task.worktreePath, executorSessionId(task.id, task.runId)));
     },
     "sessions:list": async () => {
       const keys = await sessions.list();
@@ -5012,16 +5253,19 @@ 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 (!fs14.existsSync(dir)) return "artifacts directory does not exist yet";
+      if (!fs16.existsSync(dir)) return "artifacts directory does not exist yet";
       return getPlatform().openPath(dir);
     },
-    "task:getDecisions": (taskId) => {
+    "task:getSpecs": async (taskId) => {
       const task = requireTask(taskId);
-      if (!task.workspacePath) return null;
-      return readDecisions(task.workspacePath, decisionsKey(task.worktreePath, task.branch));
+      const base = task.baseBranch ?? "main";
+      if (task.worktreePath) return readWorktreeSpecs(task.worktreePath, base);
+      if (!task.projectPath) return [];
+      const changed = task.outcome?.files.filter((f) => f.status !== "D").map((f) => f.path);
+      return readBranchSpecs(task.projectPath, task.branch, base, changed);
     },
     "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");
@@ -5060,6 +5304,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");
@@ -5165,9 +5414,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 = path18.basename(getStorePath());
+      const file = path20.basename(getStorePath());
       let debounce = null;
-      storeWatcher = fs14.watch(path18.dirname(getStorePath()), (_event, filename) => {
+      storeWatcher = fs16.watch(path20.dirname(getStorePath()), (_event, filename) => {
         if (filename !== file) return;
         if (debounce) clearTimeout(debounce);
         debounce = setTimeout(() => {
@@ -5199,9 +5448,9 @@ function createSessionBackend(sink, choice) {
 }
 
 // packages/core/src/web-server.ts
-import fs15 from "fs";
+import fs17 from "fs";
 import http from "http";
-import path19 from "path";
+import path21 from "path";
 import { timingSafeEqual } from "crypto";
 import { WebSocketServer } from "ws";
 var TOKEN_COOKIE = "vf_token";
@@ -5254,14 +5503,14 @@ function resolveStatic(root, urlPath) {
     return null;
   }
   if (decoded.includes("\0")) return null;
-  const rel = path19.posix.normalize(decoded).replace(/^\/+/, "");
-  const base = path19.resolve(root);
-  const candidates = [rel, path19.posix.join(rel, "index.html"), `${rel}.html`];
+  const rel = path21.posix.normalize(decoded).replace(/^\/+/, "");
+  const base = path21.resolve(root);
+  const candidates = [rel, path21.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path19.resolve(base, c);
-    if (full !== base && !full.startsWith(base + path19.sep)) return null;
+    const full = path21.resolve(base, c);
+    if (full !== base && !full.startsWith(base + path21.sep)) return null;
     try {
-      if (fs15.statSync(full).isFile()) return full;
+      if (fs17.statSync(full).isFile()) return full;
     } catch {
     }
   }
@@ -5322,7 +5571,7 @@ async function startWebServer(options) {
       send(res, 404, "Not found");
       return;
     }
-    const ext = path19.extname(file).toLowerCase();
+    const ext = path21.extname(file).toLowerCase();
     const immutable = url.pathname.startsWith("/_next/static/");
     res.writeHead(200, {
       "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream",
@@ -5335,7 +5584,7 @@ async function startWebServer(options) {
       res.end();
       return;
     }
-    fs15.createReadStream(file).pipe(res);
+    fs17.createReadStream(file).pipe(res);
   }
   const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_PAYLOAD });
   function reject(socket, status, reason) {
@@ -5460,6 +5709,7 @@ async function startHost(options) {
     return startHost(options);
   }
   try {
+    await syncBuiltinsAtStartup();
     const bus = new EventBus();
     const sessions = createSessionBackend(bus.sink(), {
       prefer: options.backend,
@@ -5506,7 +5756,7 @@ function loginUrl(lock, pathname = "/home/") {
   return `http://127.0.0.1:${lock.port}${pathname}?token=${encodeURIComponent(lock.token)}`;
 }
 function isWebDir(dir) {
-  return fs16.existsSync(path20.join(dir, "home", "index.html"));
+  return fs18.existsSync(path22.join(dir, "home", "index.html"));
 }
 
 // packages/cli/src/remote.ts
@@ -5623,8 +5873,8 @@ function connectToHost(lock) {
 }
 
 // packages/cli/src/doctor.ts
-import fs17 from "fs";
-import path21 from "path";
+import fs19 from "fs";
+import path23 from "path";
 import { execFile as execFile7 } from "child_process";
 import { promisify as promisify5 } from "util";
 init_env();
@@ -5764,10 +6014,10 @@ async function runDoctor(options) {
     });
   }
   try {
-    fs17.mkdirSync(options.userDataDir, { recursive: true });
-    const probe = path21.join(options.userDataDir, `.doctor-${process.pid}`);
-    fs17.writeFileSync(probe, "");
-    fs17.rmSync(probe);
+    fs19.mkdirSync(options.userDataDir, { recursive: true });
+    const probe = path23.join(options.userDataDir, `.doctor-${process.pid}`);
+    fs19.writeFileSync(probe, "");
+    fs19.rmSync(probe);
     checks.push({ id: "data", name: "\u8CC7\u6599\u76EE\u9304", level: "ok", detail: options.userDataDir });
   } catch (err) {
     checks.push({
@@ -5821,24 +6071,24 @@ Options:
 `.trim();
 function detectLayout() {
   const file = fileURLToPath(import.meta.url);
-  const here = path24.dirname(file);
-  const bundledWeb = path24.join(here, "web");
-  if (isWebDir(bundledWeb) || path24.basename(here) === "dist") {
+  const here = path26.dirname(file);
+  const bundledWeb = path26.join(here, "web");
+  if (isWebDir(bundledWeb) || path26.basename(here) === "dist") {
     return {
-      version: readVersion(path24.join(here, "..", "package.json")),
+      version: readVersion(path26.join(here, "..", "package.json")),
       webDir: isWebDir(bundledWeb) ? bundledWeb : null,
       sourceRoot: null,
       cliEntry: file
     };
   }
-  const root = path24.resolve(here, "..", "..", "..");
+  const root = path26.resolve(here, "..", "..", "..");
   const override = process.env.VIBEFLOW_WEB_DIR;
-  const webDir = override && isWebDir(override) ? override : isWebDir(path24.join(root, "app")) ? path24.join(root, "app") : null;
-  return { version: readVersion(path24.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
+  const webDir = override && isWebDir(override) ? override : isWebDir(path26.join(root, "app")) ? path26.join(root, "app") : null;
+  return { version: readVersion(path26.join(root, "package.json")), webDir, sourceRoot: root, cliEntry: null };
 }
 function readVersion(pkgPath) {
   try {
-    return JSON.parse(fs19.readFileSync(pkgPath, "utf8")).version;
+    return JSON.parse(fs21.readFileSync(pkgPath, "utf8")).version;
   } catch {
     return "0.0.0";
   }
@@ -6044,8 +6294,8 @@ async function cmdOpen(values, target, layout, userDataDir) {
     console.error("\u7528\u6CD5\uFF1Avibeflow open <path>");
     return 1;
   }
-  const dir = path24.resolve(target);
-  if (!fs19.existsSync(dir) || !fs19.statSync(dir).isDirectory()) {
+  const dir = path26.resolve(target);
+  if (!fs21.existsSync(dir) || !fs21.statSync(dir).isDirectory()) {
     console.error(`\u4E0D\u662F\u8CC7\u6599\u593E\uFF1A${dir}`);
     return 1;
   }