zdashboard 2.6.1 → 2.7.0

package/dist/cli.js

@@ -1,156 +1,41 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path11 from "path";
-import fs11 from "fs";
+import path12 from "path";
+import fs12 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { access, readdir } from "fs/promises";
 import { parseArgs as utilParseArgs } from "util";
 
 // src/server/detect.ts
-import fs2 from "fs";
-import path2 from "path";
-import { execFile } from "child_process";
-
-// src/server/bugs.ts
 import fs from "fs";
 import path from "path";
-import YAML from "yaml";
-
-// src/server/api/fetch.ts
-import ky from "ky";
-
-// src/server/errors.ts
-var HttpError = class extends Error {
-  constructor(status, message, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-    this.name = "HttpError";
-  }
-  status;
-  body;
-};
-var NetworkError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = "NetworkError";
-  }
-  cause;
-};
-
-// src/server/api/fetch.ts
-async function fetchJson(url, init) {
-  try {
-    const res = await ky(url, { ...init, timeout: 8e3, retry: 2 });
-    return await res.json();
-  } catch (e) {
-    if (e instanceof HttpError) throw e;
-    if (e instanceof Error && e.name === "TimeoutError") {
-      throw new NetworkError(`\u8BF7\u6C42\u8D85\u65F6: ${url}`);
-    }
-    if (e instanceof Error && e.name === "HTTPError") {
-      throw new HttpError(e.status ?? 500, e.message);
-    }
-    throw new NetworkError(`\u8BF7\u6C42\u5931\u8D25: ${url}`, e);
-  }
-}
-
-// src/server/bugs.ts
-var BUGS_CONFIG_CANDIDATES = [".zdev/config.yaml", ".zgoal/config.yaml"];
-function loadConfig(root) {
-  for (const rel of BUGS_CONFIG_CANDIDATES) {
-    const file = path.join(root, rel);
-    if (!fs.existsSync(file)) continue;
-    try {
-      const kv = YAML.parse(fs.readFileSync(file, "utf8"));
-      if (!kv || typeof kv !== "object") return null;
-      const record = kv;
-      const product = Number(record.product);
-      if (!record.url || !product) return null;
-      const str = (v) => typeof v === "string" ? v : v == null ? void 0 : String(v);
-      return {
-        url: String(record.url).replace(/\/+$/, ""),
-        account: str(record.account) ?? "",
-        password: str(record.password),
-        token: str(record.token),
-        product
-      };
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-var tokenCache = null;
-async function getToken(cfg) {
-  if (cfg.token) return cfg.token;
-  const key = `${cfg.url}|${cfg.account}|${cfg.password ?? ""}`;
-  if (tokenCache && tokenCache.key === key && Date.now() - tokenCache.at < 10 * 6e4) return tokenCache.token;
-  const json = await fetchJson(`${cfg.url}/api.php/v1/tokens`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ account: cfg.account, password: cfg.password })
-  });
-  const token = typeof json.token === "string" ? json.token : "";
-  if (!token) throw new Error("token \u83B7\u53D6\u5931\u8D25:\u68C0\u67E5 account / password");
-  tokenCache = { key, token, at: Date.now() };
-  return token;
-}
-function normBug(b, account) {
-  const assigned = b.assignedTo;
-  const assignedTo = typeof assigned === "string" ? assigned : assigned && typeof assigned === "object" && "realname" in assigned ? String(assigned.realname ?? "") : "";
-  const assignedAccount = typeof assigned === "string" ? assigned : assigned && typeof assigned === "object" ? String(assigned.account ?? "") : "";
-  const mine = !!account && (assignedAccount === account || assignedTo === account);
-  return {
-    id: Number(b.id),
-    title: String(b.title ?? ""),
-    severity: b.severity ?? 4,
-    pri: b.pri ?? 3,
-    status: String(b.status ?? ""),
-    assignedTo,
-    openedBy: typeof b.openedBy === "string" ? b.openedBy : void 0,
-    mine
-  };
-}
-async function fetchBugs(root) {
-  const cfg = loadConfig(root);
-  if (!cfg) {
-    const anyExists = BUGS_CONFIG_CANDIDATES.some((rel) => fs.existsSync(path.join(root, rel)));
-    return {
-      ok: false,
-      error: anyExists ? "\u914D\u7F6E\u5B58\u5728\u4F46\u65E0\u6548(\u7F3A url \u6216 product \u5B57\u6BB5)\u2014\u2014\u68C0\u67E5 .zdev/config.yaml" : ".zdev/config.yaml \u7F3A\u5931(\u7531 zgoal skill \u521B\u5EFA;\u5B58\u91CF .zgoal/config.yaml \u4EA6\u53EF)"
-    };
-  }
-  try {
-    const token = await getToken(cfg);
-    const json = await fetchJson(
-      `${cfg.url}/api.php/v1/products/${cfg.product}/bugs?page=1&limit=100`,
-      { headers: { Token: token } }
-    );
-    const raw = Array.isArray(json.bugs) ? json.bugs : [];
-    return { ok: true, url: cfg.url, total: Number(json.total ?? raw.length), bugs: raw.map((b) => normBug(b, cfg.account)) };
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    return { ok: false, error: `\u7985\u9053\u8BF7\u6C42\u5931\u8D25(${msg})\u2014\u2014\u68C0\u67E5 url / \u51ED\u636E / \u662F\u5426\u5F00\u542F RESTful API v1` };
-  }
-}
-
-// src/server/detect.ts
+import { execFile } from "child_process";
 function justAvailable(cwd) {
   return new Promise((resolve) => {
-    const child = execFile("just", ["--list", "--unsorted"], { cwd, timeout: 5e3 }, (err) => {
+    const child = execFile("just", ["--list", "--unsupported"], { cwd, timeout: 5e3 }, (err) => {
       resolve(!err);
     });
     if (child.killed) resolve(false);
   });
 }
+function hasBugsConfig(root) {
+  const dashboardPath = path.join(root, ".zdev", "dashboard.json");
+  if (!fs.existsSync(dashboardPath)) return false;
+  try {
+    const raw = fs.readFileSync(dashboardPath, "utf-8");
+    const rec = JSON.parse(raw);
+    const bugs = rec.plugins?.bugs;
+    if (bugs && typeof bugs === "object" && bugs.url && bugs.product) return true;
+  } catch {
+  }
+  return false;
+}
 async function detect(root) {
-  const hasOpenspec = fs2.existsSync(path2.join(root, "openspec"));
-  const hasDocs = fs2.existsSync(path2.join(root, "docs"));
+  const hasOpenspec = fs.existsSync(path.join(root, "openspec"));
+  const hasDocs = fs.existsSync(path.join(root, "docs"));
   const hasJust = await justAvailable(root);
-  const hasBugs = BUGS_CONFIG_CANDIDATES.some((rel) => fs2.existsSync(path2.join(root, rel)));
+  const hasBugs = hasBugsConfig(root);
   return { hasOpenspec, hasDocs, hasJust, hasBugs };
 }
 
@@ -159,15 +44,15 @@ import { Context } from "cordis";
 
 // src/core/server.ts
 import http from "http";
-import fs4 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import crypto from "crypto";
 import { fileURLToPath } from "url";
 
 // package.json
 var package_default = {
   name: "zdashboard",
-  version: "2.6.1",
+  version: "2.7.0",
   description: "ZCode skill dashboard platform \u2014 pluggable viewers for zdesign/zview/zreview/zgoal",
   type: "module",
   bin: {
@@ -257,20 +142,20 @@ var package_default = {
 import { Service } from "cordis";
 
 // src/core/instance.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path2 from "path";
 var RECORD_FILE = ".zdev/dashboard.json";
 var VERIFY_TIMEOUT_MS = 1500;
 var STOP_POLL_MS = 2e3;
 var STOP_POLL_INTERVAL_MS = 100;
 var STOP_FINAL_WAIT_MS = 100;
 function recordPath(root) {
-  return path3.join(root, RECORD_FILE);
+  return path2.join(root, RECORD_FILE);
 }
 function readRecord(root) {
   try {
     const fp = recordPath(root);
-    const raw = fs3.readFileSync(fp, "utf-8");
+    const raw = fs2.readFileSync(fp, "utf-8");
     const rec = JSON.parse(raw);
     if (typeof rec.pid === "number" && typeof rec.port === "number" && typeof rec.root === "string" && typeof rec.startedAt === "string") {
       return rec;
@@ -281,20 +166,44 @@ function readRecord(root) {
   }
 }
 function writeRecord(root, port) {
-  fs3.mkdirSync(path3.dirname(recordPath(root)), { recursive: true });
+  fs2.mkdirSync(path2.dirname(recordPath(root)), { recursive: true });
   const rec = {
     pid: process.pid,
     port,
     root,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs3.writeFileSync(recordPath(root), JSON.stringify(rec, null, 2) + "\n");
+  fs2.writeFileSync(recordPath(root), JSON.stringify(rec, null, 2) + "\n");
+}
+function readPluginsConfig(root) {
+  try {
+    const rec = readRecord(root);
+    if (rec?.plugins && typeof rec.plugins === "object") {
+      return rec.plugins;
+    }
+  } catch {
+  }
+  return {};
+}
+function writePluginsConfig(root, plugins) {
+  const fp = recordPath(root);
+  let rec;
+  try {
+    const raw = fs2.readFileSync(fp, "utf-8");
+    rec = JSON.parse(raw);
+  } catch {
+    rec = { pid: process.pid, port: 0, root, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  rec.plugins = plugins;
+  const tmp = fp + ".tmp";
+  fs2.writeFileSync(tmp, JSON.stringify(rec, null, 2) + "\n");
+  fs2.renameSync(tmp, fp);
 }
 function clearRecord(root) {
   try {
     const rec = readRecord(root);
     if (rec && rec.pid !== process.pid) return;
-    fs3.unlinkSync(recordPath(root));
+    fs2.unlinkSync(recordPath(root));
   } catch {
   }
 }
@@ -366,7 +275,7 @@ function openUrl(url) {
 // src/core/server.ts
 import { execFile as execFile3 } from "child_process";
 var VERSION = package_default.version;
-var __dirname = path4.dirname(fileURLToPath(import.meta.url));
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".htm": "text/html; charset=utf-8",
@@ -421,7 +330,7 @@ var MIME = {
   ".ttf": "font/woff",
   ".map": "application/json; charset=utf-8"
 };
-var INJECT = `<script>(function(){try{var es=new EventSource('/__reload');es.addEventListener('reload',function(){location.reload();});es.onerror=function(){es.close();};}catch(e){}document.addEventListener('click',function(e){var t=e.target;if(t&&t.closest){var a=t.closest('a[target]');if(a&&a.target!=='_self'){a.target='_self';}}},true);})();</script>`;
+var INJECT = `<script>(function(){try{var es=new EventSource('/__reload');es.addEventListener('files',function(){/* plugin \u5C40\u90E8\u5237\u65B0\u7531 useSSE \u6D88\u8D39,\u6B64\u5904\u4E0D\u518D\u6574\u9875 reload */});es.onerror=function(){/* EventSource \u539F\u751F\u91CD\u8FDE,\u9759\u9ED8\u5904\u7406 */};}catch(e){}document.addEventListener('click',function(e){var t=e.target;if(t&&t.closest){var a=t.closest('a[target]');if(a&&a.target!=='_self'){a.target='_self';}}},true);})();</script>`;
 var PLUGIN_STATIC_PREFIX = "/__plugin/";
 var ServerService = class extends Service {
   stopToken;
@@ -464,25 +373,36 @@ var ServerService = class extends Service {
     });
     this.start(config.port);
   }
-  route(path12, handler) {
-    this.routes.set(path12, handler);
-    this.ctx.effect(() => () => this.routes.delete(path12));
+  route(path13, handler) {
+    this.routes.set(path13, handler);
+    this.ctx.effect(() => () => this.routes.delete(path13));
   }
-  sse(path12, onConnect) {
-    this.sses.set(path12, onConnect);
-    this.ctx.effect(() => () => this.sses.delete(path12));
+  sse(path13, onConnect) {
+    this.sses.set(path13, onConnect);
+    this.ctx.effect(() => () => this.sses.delete(path13));
   }
   static(prefix, dir) {
     this.prefixStatic.set(prefix, dir);
     this.ctx.effect(() => () => this.prefixStatic.delete(prefix));
   }
+  pluginsConfig = {};
+  getPluginConfig(mode) {
+    return this.pluginsConfig[mode] ?? {};
+  }
+  refreshPluginsConfig() {
+    this.pluginsConfig = readPluginsConfig(this.root);
+  }
+  savePluginConfig(merged) {
+    this.pluginsConfig = merged;
+    writePluginsConfig(this.root, merged);
+  }
   serveFile(filePath, req, res, injectHtml) {
-    fs4.stat(filePath, (err, stat) => {
+    fs3.stat(filePath, (err, stat) => {
       if (err) {
         res.writeHead(404);
         return res.end("Not found");
       }
-      const ext = path4.extname(filePath).toLowerCase();
+      const ext = path3.extname(filePath).toLowerCase();
       const ct = MIME[ext] ?? "application/octet-stream";
       const rangeHeader = req.headers["range"];
       let range = null;
@@ -506,7 +426,7 @@ var ServerService = class extends Service {
           "Accept-Ranges": "bytes",
           "Cache-Control": "no-cache"
         });
-        const stream = fs4.createReadStream(filePath, { start, end });
+        const stream = fs3.createReadStream(filePath, { start, end });
         stream.on("error", () => {
           try {
             res.destroy();
@@ -516,7 +436,7 @@ var ServerService = class extends Service {
         stream.pipe(res);
         return;
       }
-      fs4.readFile(filePath, (err2, data) => {
+      fs3.readFile(filePath, (err2, data) => {
         if (err2) {
           res.writeHead(404);
           return res.end("Not found");
@@ -535,9 +455,9 @@ var ServerService = class extends Service {
     for (const [prefix, dir] of this.prefixStatic) {
       if (url.indexOf(prefix) === 0) {
         let rel = this.safeDecode(url.slice(prefix.length));
-        if (!rel || rel === "/" || !path4.extname(rel)) rel = path4.join(rel || "", "index.html");
-        const fp = path4.join(dir, rel);
-        if (fp.indexOf(dir + path4.sep) !== 0) {
+        if (!rel || rel === "/" || !path3.extname(rel)) rel = path3.join(rel || "", "index.html");
+        const fp = path3.join(dir, rel);
+        if (fp.indexOf(dir + path3.sep) !== 0) {
           res.writeHead(403);
           res.end("Forbidden");
           return false;
@@ -577,17 +497,17 @@ var ServerService = class extends Service {
       if (this.servePrefix(url, req, res)) return;
       if (url === "/" || url.indexOf("/__app/") === 0 || url.indexOf("/assets/") === 0) {
         let fp2 = this.appDir;
-        if (url !== "/") fp2 = path4.join(this.appDir, this.safeDecode(url));
-        if (url.indexOf("/__app/") === 0) fp2 = path4.join(this.appDir, url.slice(7));
-        if (fp2 !== this.appDir && fp2.indexOf(this.appDir + path4.sep) !== 0) {
+        if (url !== "/") fp2 = path3.join(this.appDir, this.safeDecode(url));
+        if (url.indexOf("/__app/") === 0) fp2 = path3.join(this.appDir, url.slice(7));
+        if (fp2 !== this.appDir && fp2.indexOf(this.appDir + path3.sep) !== 0) {
           res.writeHead(403);
           return res.end("Forbidden");
         }
-        if (url === "/") fp2 = path4.join(this.appDir, "index.html");
+        if (url === "/") fp2 = path3.join(this.appDir, "index.html");
         return this.serveFile(fp2, req, res, false);
       }
-      const fp = path4.join(this.root, this.safeDecode(url));
-      if (fp !== this.root && fp.indexOf(this.root + path4.sep) !== 0) {
+      const fp = path3.join(this.root, this.safeDecode(url));
+      if (fp !== this.root && fp.indexOf(this.root + path3.sep) !== 0) {
         res.writeHead(403);
         return res.end("Forbidden");
       }
@@ -671,9 +591,9 @@ var ServerService = class extends Service {
 };
 
 // src/core/reload.ts
-import fs5 from "fs";
+import fs4 from "fs";
 import { Service as Service2 } from "cordis";
-var WATCH_DEBOUNCE_MS = 150;
+var WATCH_DEBOUNCE_MS = 300;
 var ReloadService = class extends Service2 {
   static inject = ["server"];
   clients = /* @__PURE__ */ new Set();
@@ -687,13 +607,15 @@ var ReloadService = class extends Service2 {
       return () => this.clients.delete(res);
     });
     try {
-      this.watcher = fs5.watch(config.root, { recursive: true }, (eventType, filename) => {
+      this.watcher = fs4.watch(config.root, { recursive: true }, (eventType, filename) => {
         if (filename && /^(?:\.git|node_modules|dist|\.pnpm)(?:[/\\]|$)/.test(filename)) return;
+        if (filename && /\.(?:swp|tmp)$|~$|^\.DS_Store$|^Thumbs\.db$/i.test(filename)) return;
         if (this.timer) clearTimeout(this.timer);
         this.timer = setTimeout(() => {
           this.ctx.server.refreshGitInfo();
           this.broadcast("reload");
           this.broadcast("files");
+          this.timer = void 0;
         }, WATCH_DEBOUNCE_MS);
       });
     } catch {
@@ -732,25 +654,26 @@ data: ${JSON.stringify(data == null ? "" : data)}
 };
 
 // src/server/spec-scan.ts
-import fs7 from "fs";
-import path6 from "path";
-
-// src/server/walk.ts
 import fs6 from "fs";
 import path5 from "path";
+
+// src/server/walk.ts
+import fs5 from "fs";
+import path4 from "path";
 function walkDir(root, opts = {}) {
-  const { skip = /* @__PURE__ */ new Set(), maxDepth, onFile, onDir } = opts;
+  const { skip = /* @__PURE__ */ new Set(), maxDepth, showHidden, onFile, onDir } = opts;
   function walk(dir, rel, depth) {
     if (typeof maxDepth === "number" && depth > maxDepth) return;
     let ents;
     try {
-      ents = fs6.readdirSync(dir, { withFileTypes: true });
+      ents = fs5.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of ents) {
-      if (ent.name.startsWith(".") || skip.has(ent.name)) continue;
-      const abs = path5.join(dir, ent.name);
+      if (!showHidden && ent.name.startsWith(".")) continue;
+      if (skip.has(ent.name)) continue;
+      const abs = path4.join(dir, ent.name);
       const r = rel ? `${rel}/${ent.name}` : ent.name;
       if (ent.isDirectory()) {
         onDir?.(abs, r);
@@ -764,7 +687,7 @@ function walkDir(root, opts = {}) {
 }
 
 // src/server/spec-scan.ts
-function buildTree(paths) {
+function buildTree(paths, defaultExpandDepth = 2) {
   const root = [];
   const map = /* @__PURE__ */ new Map();
   for (const p of paths) {
@@ -775,10 +698,14 @@ function buildTree(paths) {
       const part = parts[i];
       current = current ? `${current}/${part}` : part;
       const isLast = i === parts.length - 1;
+      const depth = i;
       if (!map.has(current)) {
+        const isDir = !isLast;
+        const collapsed = isDir && typeof defaultExpandDepth === "number" && depth > defaultExpandDepth;
         const node = {
           name: part,
           kind: isLast ? "file" : "dir",
+          ...collapsed ? { defaultCollapsed: true } : {},
           ...isLast ? { path: p } : { children: [] }
         };
         map.set(current, node);
@@ -798,55 +725,60 @@ function buildTree(paths) {
   sortNodes(root);
   return root;
 }
-function scanTree(root, hasOpenspec, hasDocs) {
+function scanTree(root, hasOpenspec, hasDocs, opts) {
   const tree = [];
-  if (hasOpenspec && fs7.existsSync(path6.join(root, "openspec", "changes"))) {
-    const changesDir = path6.join(root, "openspec", "changes");
+  const defaultExpandDepth = typeof opts?.defaultExpandDepth === "number" ? opts.defaultExpandDepth : 2;
+  if (hasOpenspec && fs6.existsSync(path5.join(root, "openspec", "changes"))) {
+    const changesDir = path5.join(root, "openspec", "changes");
     const active = [];
     const archived = [];
-    for (const ent of fs7.readdirSync(changesDir, { withFileTypes: true })) {
+    for (const ent of fs6.readdirSync(changesDir, { withFileTypes: true })) {
       if (!ent.isDirectory() || ent.name.startsWith(".") || ent.name === "archive") continue;
       const relBase = `openspec/changes/${ent.name}`;
       const paths = [];
-      walkDir(path6.join(changesDir, ent.name), { maxDepth: 4, onFile: (_, rel) => paths.push(rel ? `${relBase}/${rel}` : relBase) });
-      const children = buildTree(paths).map((n) => ({ ...n, path: n.path ? `${relBase}/${n.path}` : void 0 }));
+      walkDir(path5.join(changesDir, ent.name), { maxDepth: 4, showHidden: opts?.showHidden, onFile: (_, rel) => paths.push(rel ? `${relBase}/${rel}` : relBase) });
+      const children = buildTree(paths, defaultExpandDepth).map((n) => ({ ...n, path: n.path ? `${relBase}/${n.path}` : void 0 }));
       active.push({ name: ent.name, kind: "dir", children });
     }
     active.sort((a, b) => a.name.localeCompare(b.name));
-    const archiveDir = path6.join(changesDir, "archive");
-    if (fs7.existsSync(archiveDir)) {
-      for (const ent of fs7.readdirSync(archiveDir, { withFileTypes: true })) {
+    const archiveDir = path5.join(changesDir, "archive");
+    if (fs6.existsSync(archiveDir)) {
+      for (const ent of fs6.readdirSync(archiveDir, { withFileTypes: true })) {
         if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
         const relBase = `openspec/changes/archive/${ent.name}`;
         const paths = [];
-        walkDir(path6.join(archiveDir, ent.name), { maxDepth: 4, onFile: (_, rel) => paths.push(rel ? `${relBase}/${rel}` : relBase) });
-        const children = buildTree(paths).map((n) => ({ ...n, path: n.path ? `${relBase}/${n.path}` : void 0 }));
+        walkDir(path5.join(archiveDir, ent.name), { maxDepth: 4, showHidden: opts?.showHidden, onFile: (_, rel) => paths.push(rel ? `${relBase}/${rel}` : relBase) });
+        const children = buildTree(paths, defaultExpandDepth).map((n) => ({ ...n, path: n.path ? `${relBase}/${n.path}` : void 0 }));
         archived.push({ name: ent.name, kind: "dir", children });
       }
       archived.sort((a, b) => b.name.localeCompare(a.name));
     }
     if (active.length) tree.push({ name: `changes (${active.length})`, kind: "dir", children: active });
     if (archived.length) tree.push({ name: `archive (${archived.length})`, kind: "dir", defaultCollapsed: true, children: archived });
-    const specsDir = path6.join(root, "openspec", "specs");
-    if (fs7.existsSync(specsDir)) {
+    const specsDir = path5.join(root, "openspec", "specs");
+    if (fs6.existsSync(specsDir)) {
       const paths = [];
-      walkDir(specsDir, { maxDepth: 4, onFile: (_, rel) => paths.push(`openspec/specs/${rel}`) });
-      const specs = buildTree(paths).map((n) => ({ ...n, path: n.path ? `openspec/specs/${n.path}` : void 0 }));
+      walkDir(specsDir, { maxDepth: 4, showHidden: opts?.showHidden, onFile: (_, rel) => paths.push(`openspec/specs/${rel}`) });
+      const specs = buildTree(paths, defaultExpandDepth).map((n) => ({ ...n, path: n.path ? `openspec/specs/${n.path}` : void 0 }));
       if (specs.length) tree.push({ name: "specs", kind: "dir", children: specs });
     }
   }
-  if (hasDocs && fs7.existsSync(path6.join(root, "docs"))) {
+  if (hasDocs && fs6.existsSync(path5.join(root, "docs"))) {
     const paths = [];
-    walkDir(path6.join(root, "docs"), { maxDepth: 4, onFile: (_, rel) => paths.push(`docs/${rel}`) });
-    const docs = buildTree(paths).map((n) => ({ ...n, path: n.path ? `docs/${n.path}` : void 0 }));
+    walkDir(path5.join(root, "docs"), { maxDepth: 4, showHidden: opts?.showHidden, onFile: (_, rel) => paths.push(`docs/${rel}`) });
+    const docs = buildTree(paths, defaultExpandDepth).map((n) => ({ ...n, path: n.path ? `docs/${n.path}` : void 0 }));
     if (docs.length) tree.push({ name: "docs", kind: "dir", children: docs });
   }
-  const skip = /* @__PURE__ */ new Set(["openspec", "docs", "node_modules", ".git", "dist", "playground"]);
+  const skip = /* @__PURE__ */ new Set(["openspec", "docs", "node_modules", ".git", "dist", "playground", ".zreview"]);
+  if (Array.isArray(opts?.hiddenDirs)) {
+    for (const d of opts.hiddenDirs) skip.add(d);
+  }
   const etc = [];
   try {
-    for (const ent of fs7.readdirSync(root, { withFileTypes: true })) {
-      if (ent.name.startsWith(".") || skip.has(ent.name)) continue;
-      const ext = path6.extname(ent.name).toLowerCase();
+    for (const ent of fs6.readdirSync(root, { withFileTypes: true })) {
+      if (!opts?.showHidden && ent.name.startsWith(".")) continue;
+      if (skip.has(ent.name)) continue;
+      const ext = path5.extname(ent.name).toLowerCase();
       if (ent.isFile() && (ext === ".md" || ext === ".markdown")) etc.push({ name: ent.name, kind: "file", path: ent.name });
     }
   } catch (e) {
@@ -859,7 +791,7 @@ function scanTree(root, hasOpenspec, hasDocs) {
 
 // src/core/tree.ts
 var apply = {
-  inject: ["server"],
+  inject: ["server", "dashboard"],
   apply(ctx, config) {
     let cached = null;
     const getDet = async () => {
@@ -874,7 +806,12 @@ var apply = {
       server.route("/__files", async (_req, res) => {
         try {
           const d = await getDet();
-          const tree = scanTree(config.root, d.hasOpenspec, d.hasDocs);
+          const viewCfg = ctx.dashboard.getConfig("view");
+          const tree = scanTree(config.root, d.hasOpenspec, d.hasDocs, {
+            hiddenDirs: Array.isArray(viewCfg?.hiddenDirs) ? viewCfg.hiddenDirs : void 0,
+            defaultExpandDepth: typeof viewCfg?.defaultExpandDepth === "number" ? viewCfg.defaultExpandDepth : void 0,
+            showHidden: typeof viewCfg?.showHidden === "boolean" ? viewCfg.showHidden : void 0
+          });
           res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
           res.end(JSON.stringify({ tree, ...d }));
         } catch {
@@ -966,16 +903,79 @@ var apply2 = {
 
 // src/core/manifest.ts
 import { Service as Service3 } from "cordis";
+
+// src/core/read-body.ts
+async function readBody2(req) {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk;
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", () => resolve(""));
+  });
+}
+
+// src/core/manifest.ts
 var DashboardService = class extends Service3 {
-  static inject = ["server"];
+  static inject = ["server", "reload"];
   plugins = /* @__PURE__ */ new Map();
+  reloadRef;
   constructor(ctx) {
     super(ctx, "dashboard");
     this.ctx.effect(() => () => this.plugins.clear());
+    this.reloadRef = ctx.reload;
     this.ctx.server.route("/__plugins", (_req, res) => {
       res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
       res.end(JSON.stringify({ plugins: Array.from(this.plugins.values()) }));
     });
+    this.ctx.server.route("/__plugins/config", async (req, res) => {
+      const out = {};
+      if (req.method === "GET") {
+        for (const m of this.plugins.values()) {
+          const stored = this.ctx.server.getPluginConfig(m.mode);
+          const schema = m.config ?? {};
+          const merged = {};
+          for (const [key, field] of Object.entries(schema)) {
+            merged[key] = key in stored ? stored[key] : field.default ?? "";
+          }
+          if (Object.keys(merged).length) out[m.mode] = merged;
+        }
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(out));
+        return;
+      }
+      if (req.method === "POST") {
+        if (req.headers["x-stop-token"] !== this.ctx.server.stopToken) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+        try {
+          const body = JSON.parse(await readBody2(req));
+          const merged = {};
+          for (const mode of Object.keys(body)) {
+            merged[mode] = body[mode] ?? {};
+          }
+          this.ctx.server.savePluginConfig(merged);
+          for (const mode of Object.keys(body)) {
+            try {
+              this.reloadRef.broadcast("config", { plugin: mode });
+            } catch {
+            }
+          }
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+          res.end('{"ok":true}');
+        } catch (e) {
+          console.error("[config] POST error", e);
+          res.writeHead(400);
+          res.end('{"error":"bad request"}');
+        }
+        return;
+      }
+      res.writeHead(405);
+      res.end('{"error":"method not allowed"}');
+    });
   }
   register(manifest) {
     this.plugins.set(manifest.mode, manifest);
@@ -987,6 +987,9 @@ var DashboardService = class extends Service3 {
   get(mode) {
     return this.plugins.get(mode);
   }
+  getConfig(mode) {
+    return this.ctx.server.getPluginConfig(mode);
+  }
 };
 
 // src/server/just-runner.ts
@@ -1128,18 +1131,6 @@ var JustRunner = class {
   }
 };
 
-// src/core/read-body.ts
-async function readBody(req) {
-  return new Promise((resolve) => {
-    let data = "";
-    req.on("data", (chunk) => {
-      data += chunk;
-    });
-    req.on("end", () => resolve(data));
-    req.on("error", () => resolve(""));
-  });
-}
-
 // src/plugins/just/index.ts
 var apply3 = {
   inject: ["server", "dashboard"],
@@ -1173,7 +1164,7 @@ var apply3 = {
           res.end("forbidden");
           return;
         }
-        const body = await readBody(req);
+        const body = await readBody2(req);
         let recipe;
         try {
           recipe = JSON.parse(body || "{}").recipe;
@@ -1222,6 +1213,96 @@ var apply3 = {
   }
 };
 
+// src/server/api/fetch.ts
+import ky from "ky";
+
+// src/server/errors.ts
+var HttpError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "HttpError";
+  }
+  status;
+  body;
+};
+var NetworkError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "NetworkError";
+  }
+  cause;
+};
+
+// src/server/api/fetch.ts
+async function fetchJson(url, init) {
+  try {
+    const res = await ky(url, { ...init, timeout: 8e3, retry: 2 });
+    return await res.json();
+  } catch (e) {
+    if (e instanceof HttpError) throw e;
+    if (e instanceof Error && e.name === "TimeoutError") {
+      throw new NetworkError(`\u8BF7\u6C42\u8D85\u65F6: ${url}`);
+    }
+    if (e instanceof Error && e.name === "HTTPError") {
+      throw new HttpError(e.status ?? 500, e.message);
+    }
+    throw new NetworkError(`\u8BF7\u6C42\u5931\u8D25: ${url}`, e);
+  }
+}
+
+// src/server/bugs.ts
+var tokenCache = null;
+async function getToken(cfg) {
+  if (cfg.token) return cfg.token;
+  const key = `${cfg.url}|${cfg.account}`;
+  if (tokenCache && tokenCache.key === key && Date.now() - tokenCache.at < 10 * 6e4) return tokenCache.token;
+  const json = await fetchJson(`${cfg.url}/api.php/v1/tokens`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ account: cfg.account, password: "" })
+  });
+  const token = typeof json.token === "string" ? json.token : "";
+  if (!token) throw new Error("token \u83B7\u53D6\u5931\u8D25:\u68C0\u67E5 account / password");
+  tokenCache = { key, token, at: Date.now() };
+  return token;
+}
+function normBug(b, account) {
+  const assigned = b.assignedTo;
+  const assignedTo = typeof assigned === "string" ? assigned : assigned && typeof assigned === "object" && "realname" in assigned ? String(assigned.realname ?? "") : "";
+  const assignedAccount = typeof assigned === "string" ? assigned : assigned && typeof assigned === "object" ? String(assigned.account ?? "") : "";
+  const mine = !!account && (assignedAccount === account || assignedTo === account);
+  return {
+    id: Number(b.id),
+    title: String(b.title ?? ""),
+    severity: b.severity ?? 4,
+    pri: b.pri ?? 3,
+    status: String(b.status ?? ""),
+    assignedTo,
+    openedBy: typeof b.openedBy === "string" ? b.openedBy : void 0,
+    mine
+  };
+}
+async function fetchBugs(config) {
+  if (!config.url || !config.product) {
+    return { ok: false, error: "\u914D\u7F6E\u65E0\u6548\uFF1A\u8BF7\u8BBE\u7F6E\u670D\u52A1\u5668 URL \u548C\u4EA7\u54C1 ID" };
+  }
+  try {
+    const token = await getToken(config);
+    const json = await fetchJson(
+      `${config.url}/api.php/v1/products/${config.product}/bugs?page=1&limit=100`,
+      { headers: { Token: token } }
+    );
+    const raw = Array.isArray(json.bugs) ? json.bugs : [];
+    return { ok: true, url: config.url, total: Number(json.total ?? raw.length), bugs: raw.map((b) => normBug(b, config.account)) };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: `\u7985\u9053\u8BF7\u6C42\u5931\u8D25(${msg})\u2014\u2014\u68C0\u67E5 url / \u51ED\u636E / \u662F\u5426\u5F00\u542F RESTful API v1` };
+  }
+}
+
 // src/plugins/bugs/index.ts
 var apply4 = {
   inject: ["server", "dashboard"],
@@ -1229,11 +1310,28 @@ var apply4 = {
     const root = config.root;
     ctx.inject(["server"], () => {
       if (!ctx.server?.route) return;
-      ctx.dashboard.register({ mode: "bugs", label: "\u7985\u9053 Bugs", icon: "\u{1F3AF}", description: "\u53EA\u8BFB bug \u5217\u8868" });
+      ctx.dashboard.register({
+        mode: "bugs",
+        label: "\u7985\u9053 Bugs",
+        icon: "\u{1F3AF}",
+        description: "\u53EA\u8BFB bug \u5217\u8868",
+        config: {
+          url: { type: "string", label: "\u670D\u52A1\u5668 URL", default: "" },
+          account: { type: "string", label: "\u8D26\u53F7", default: "" },
+          token: { type: "string", label: "Token", default: "" },
+          product: { type: "number", label: "\u4EA7\u54C1 ID", default: 0 }
+        }
+      });
       ctx.server.route("/__bugs", async (_req, res) => {
         res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
         try {
-          const result = await fetchBugs(root);
+          const bugConfig = ctx.dashboard.getConfig("bugs");
+          const result = await fetchBugs({
+            url: String(bugConfig?.url ?? ""),
+            account: String(bugConfig?.account ?? ""),
+            token: String(bugConfig?.token ?? ""),
+            product: Number(bugConfig?.product ?? 0)
+          });
           res.end(JSON.stringify(result));
         } catch (e) {
           res.end(JSON.stringify({ ok: false, error: e instanceof Error ? e.message : "unknown error" }));
@@ -1244,65 +1342,151 @@ var apply4 = {
 };
 
 // src/server/review-store.ts
-import fs8 from "fs";
-import path7 from "path";
-import YAML2 from "yaml";
-var REVIEW_CANDIDATES = [".zdev/review.yaml", "review.yaml"];
+import fs7 from "fs";
+import path6 from "path";
+import YAML from "yaml";
+var REVIEW_DIR = ".zreview";
+var REVIEW_FILE = path6.join(REVIEW_DIR, "review.yaml");
+var DOCS_DIR = path6.join(REVIEW_DIR, "docs");
+var DIAGRAMS_DIR = path6.join(REVIEW_DIR, "diagrams");
 var ReviewStore = class {
   root;
-  file;
   onChange;
   constructor(root, onChange) {
     this.root = root;
     this.onChange = onChange;
-    const existing = REVIEW_CANDIDATES.find((rel) => fs8.existsSync(path7.join(root, rel)));
-    this.file = path7.join(root, existing ?? REVIEW_CANDIDATES[0]);
   }
   exists() {
-    return fs8.existsSync(this.file);
+    return fs7.existsSync(path6.join(this.root, REVIEW_FILE));
   }
   read() {
+    const fullPath = path6.join(this.root, REVIEW_FILE);
+    if (!fs7.existsSync(fullPath)) {
+      return { status: "draft", summary: "", documents: [], codebases: [], diagrams: [], items: [] };
+    }
     try {
-      const parsed = YAML2.parse(fs8.readFileSync(this.file, "utf8"));
-      if (!parsed || !Array.isArray(parsed.items)) return { status: "draft", items: [] };
-      return parsed;
+      const parsed = YAML.parse(fs7.readFileSync(fullPath, "utf8"));
+      if (!parsed || !Array.isArray(parsed.items)) {
+        return { status: "draft", summary: parsed?.summary ?? "", documents: parsed?.documents ?? [], codebases: parsed?.codebases ?? [], diagrams: parsed?.diagrams ?? [], items: [] };
+      }
+      return {
+        status: parsed.status ?? "draft",
+        summary: parsed.summary ?? "",
+        documents: parsed.documents ?? [],
+        codebases: parsed.codebases ?? [],
+        diagrams: parsed.diagrams ?? [],
+        items: parsed.items
+      };
     } catch {
-      return { status: "draft", items: [] };
+      return { status: "draft", summary: "", documents: [], codebases: [], diagrams: [], items: [] };
     }
   }
   write(data) {
-    fs8.mkdirSync(path7.dirname(this.file), { recursive: true });
-    fs8.writeFileSync(this.file, YAML2.stringify(data), "utf8");
+    fs7.mkdirSync(path6.join(this.root, REVIEW_DIR), { recursive: true });
+    fs7.writeFileSync(path6.join(this.root, REVIEW_FILE), YAML.stringify(data), "utf8");
     this.onChange?.();
   }
   updateItem(id, patch) {
     const data = this.read();
-    const item = data.items.find((i) => i.id === id);
+    const item = this.findItem(data.items, id);
     if (!item) throw new Error(`item ${id} not found`);
     if (patch.answer !== void 0) item.answer = patch.answer;
     if (patch.state !== void 0) item.state = patch.state;
+    if (patch.priority !== void 0) item.priority = patch.priority;
+    if (patch.title !== void 0) item.title = patch.title;
     if (patch.state === "answered" && !patch.answer && !item.answer) item.answer = "";
     this.write(data);
     return data;
   }
+  addChild(parentId, title, priority = "medium") {
+    const data = this.read();
+    const parent = this.findItem(data.items, parentId);
+    if (!parent) throw new Error(`parent ${parentId} not found`);
+    if (!parent.children) parent.children = [];
+    const newId = `${parentId}-${parent.children.length + 1}`;
+    parent.children.push({
+      id: newId,
+      type: "decomposition",
+      state: "open",
+      title,
+      priority
+    });
+    this.write(data);
+    return data;
+  }
+  removeItem(id) {
+    const data = this.read();
+    const removed = this.removeItemFromList(data.items, id);
+    if (!removed) throw new Error(`item ${id} not found`);
+    this.write(data);
+    return data;
+  }
   setStatus(status) {
     const data = this.read();
-    if (status === "passed" && data.items.some((i) => i.state === "open")) {
+    if (status === "passed" && this.hasOpenItems(data.items)) {
       throw new Error("\u5B58\u5728\u672A\u5904\u7406\u7684\u8BC4\u5BA1\u9879(open),\u4E0D\u80FD\u901A\u8FC7");
     }
     data.status = status;
     this.write(data);
     return data;
   }
-  docs() {
+  listDocs() {
+    const docsDir = path6.join(this.root, DOCS_DIR);
+    if (!fs7.existsSync(docsDir)) return [];
     try {
-      const zdevDir = path7.join(this.root, ".zdev");
-      if (!fs8.existsSync(zdevDir) || !fs8.statSync(zdevDir).isDirectory()) return [];
-      return fs8.readdirSync(zdevDir).filter((f) => /\.(md|markdown)$/i.test(f) && fs8.statSync(path7.join(zdevDir, f)).isFile()).sort();
+      return fs7.readdirSync(docsDir).filter((f) => /\.(md|markdown|txt)$/i.test(f)).sort();
     } catch {
       return [];
     }
   }
+  readDoc(name) {
+    const fullPath = path6.join(this.root, DOCS_DIR, name);
+    if (!fs7.existsSync(fullPath)) throw new Error(`doc ${name} not found`);
+    return fs7.readFileSync(fullPath, "utf8");
+  }
+  listDiagrams() {
+    const dir = path6.join(this.root, DIAGRAMS_DIR);
+    if (!fs7.existsSync(dir)) return [];
+    try {
+      return fs7.readdirSync(dir).filter((f) => /\.html$/i.test(f)).sort();
+    } catch {
+      return [];
+    }
+  }
+  readDiagram(name) {
+    const fullPath = path6.join(this.root, DIAGRAMS_DIR, name);
+    if (!fs7.existsSync(fullPath)) throw new Error(`diagram ${name} not found`);
+    return fs7.readFileSync(fullPath, "utf8");
+  }
+  findItem(items, id) {
+    for (const item of items) {
+      if (item.id === id) return item;
+      if (item.children) {
+        const found = this.findItem(item.children, id);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  removeItemFromList(items, id) {
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].id === id) {
+        items.splice(i, 1);
+        return true;
+      }
+      if (items[i].children && this.removeItemFromList(items[i].children, id)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  hasOpenItems(items) {
+    for (const item of items) {
+      if (item.state === "open") return true;
+      if (item.children && this.hasOpenItems(item.children)) return true;
+    }
+    return false;
+  }
 };
 
 // src/plugins/review/index.ts
@@ -1312,7 +1496,7 @@ var apply5 = {
     const root = config.root;
     ctx.inject(["server"], () => {
       if (!ctx.server?.route) return;
-      ctx.dashboard.register({ mode: "review", label: "\u6587\u6863\u8BC4\u5BA1", icon: "\u2705", description: "review.yaml \u9010\u9879\u5BF9\u9F50" });
+      ctx.dashboard.register({ mode: "review", label: "\u6587\u6863\u8BC4\u5BA1", icon: "\u2705", description: "\u591A\u6587\u6863\u9700\u6C42\u8BC4\u5BA1\u4E0E\u62C6\u89E3 \xB7 zreview" });
       const reviewStore = new ReviewStore(root, () => {
         ctx.reload.broadcast("files");
       });
@@ -1327,8 +1511,45 @@ var apply5 = {
           return;
         }
         try {
-          const body = JSON.parse(await readBody(req) || "{}");
-          const data = reviewStore.updateItem(body.id, { answer: body.answer, state: body.state });
+          const body = JSON.parse(await readBody2(req) || "{}");
+          const data = reviewStore.updateItem(body.id, {
+            answer: body.answer,
+            state: body.state,
+            priority: body.priority,
+            title: body.title
+          });
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify(data));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "unknown error" }));
+        }
+      });
+      ctx.server.route("/__review/item/add-child", async (req, res) => {
+        if (req.headers["x-stop-token"] !== ctx.server.stopToken) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+        try {
+          const body = JSON.parse(await readBody2(req) || "{}");
+          const data = reviewStore.addChild(body.parentId, body.title, body.priority);
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify(data));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "unknown error" }));
+        }
+      });
+      ctx.server.route("/__review/item/remove", async (req, res) => {
+        if (req.headers["x-stop-token"] !== ctx.server.stopToken) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+        try {
+          const body = JSON.parse(await readBody2(req) || "{}");
+          const data = reviewStore.removeItem(body.id);
           res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
           res.end(JSON.stringify(data));
         } catch (e) {
@@ -1343,7 +1564,7 @@ var apply5 = {
           return;
         }
         try {
-          const body = JSON.parse(await readBody(req) || "{}");
+          const body = JSON.parse(await readBody2(req) || "{}");
           const data = reviewStore.setStatus(body.status);
           res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
           res.end(JSON.stringify(data));
@@ -1354,15 +1575,27 @@ var apply5 = {
       });
       ctx.server.route("/__docs", async (_req, res) => {
         res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
-        res.end(JSON.stringify(reviewStore.docs()));
+        res.end(JSON.stringify(reviewStore.listDocs()));
+      });
+      ctx.server.route("/__docs/:name", async (req, res) => {
+        try {
+          const name = req.params?.name;
+          if (!name) throw new Error("missing doc name");
+          const content = reviewStore.readDoc(name);
+          res.writeHead(200, { "Content-Type": "text/markdown; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(content);
+        } catch (e) {
+          res.writeHead(404, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "not found" }));
+        }
       });
     });
   }
 };
 
 // src/plugins/apply/scan.ts
-import fs9 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path7 from "path";
 
 // src/plugins/apply/parse-tasks.ts
 var TASK_RE = /^\s*-\s*\[([ xX])\]\s*(.*)$/;
@@ -1380,16 +1613,16 @@ function countTasks(md) {
 // src/plugins/apply/scan.ts
 function readText(p) {
   try {
-    return fs9.readFileSync(p, "utf8");
+    return fs8.readFileSync(p, "utf8");
   } catch {
     return "";
   }
 }
 function worktreeDir(root, name) {
-  return path8.join(root, ".zworktree", name);
+  return path7.join(root, ".zworktree", name);
 }
 function changeDir(root, name) {
-  return path8.join(root, "openspec", "changes", name);
+  return path7.join(root, "openspec", "changes", name);
 }
 function parseDependsOn(proposal) {
   const deps = [];
@@ -1403,42 +1636,42 @@ function parseDependsOn(proposal) {
   return deps;
 }
 function scanApplyChanges(root) {
-  const changesDir = path8.join(root, "openspec", "changes");
-  if (!fs9.existsSync(changesDir)) return [];
+  const changesDir = path7.join(root, "openspec", "changes");
+  if (!fs8.existsSync(changesDir)) return [];
   const out = [];
-  for (const ent of fs9.readdirSync(changesDir, { withFileTypes: true })) {
+  for (const ent of fs8.readdirSync(changesDir, { withFileTypes: true })) {
     if (!ent.isDirectory() || ent.name.startsWith(".") || ent.name === "archive") continue;
     const wt = worktreeDir(root, ent.name);
-    const tasks = readText(path8.join(wt, "openspec", "changes", ent.name, "tasks.md"));
+    const tasks = readText(path7.join(wt, "openspec", "changes", ent.name, "tasks.md"));
     if (!tasks) {
-      const fallback = readText(path8.join(changesDir, ent.name, "tasks.md"));
+      const fallback = readText(path7.join(changesDir, ent.name, "tasks.md"));
       if (fallback) {
         const { total, done } = countTasks(fallback);
-        const wtChange = path8.join(wt, "openspec", "changes", ent.name);
-        const mainChange = path8.join(changesDir, ent.name);
+        const wtChange = path7.join(wt, "openspec", "changes", ent.name);
+        const mainChange = path7.join(changesDir, ent.name);
         out.push({
           name: ent.name,
           path: `openspec/changes/${ent.name}`,
           total,
           done,
-          hasProposal: fs9.existsSync(path8.join(wtChange, "proposal.md")) || fs9.existsSync(path8.join(mainChange, "proposal.md")),
-          hasDesign: fs9.existsSync(path8.join(wtChange, "design.md")) || fs9.existsSync(path8.join(mainChange, "design.md")),
+          hasProposal: fs8.existsSync(path7.join(wtChange, "proposal.md")) || fs8.existsSync(path7.join(mainChange, "proposal.md")),
+          hasDesign: fs8.existsSync(path7.join(wtChange, "design.md")) || fs8.existsSync(path7.join(mainChange, "design.md")),
           // worktree 目录存在即算执行中（tasks.md 可能尚未落盘）
-          inWorktree: fs9.existsSync(wtChange)
+          inWorktree: fs8.existsSync(wtChange)
         });
       }
     } else {
       const { total, done } = countTasks(tasks);
-      const wtChange = path8.join(wt, "openspec", "changes", ent.name);
-      const mainChange = path8.join(changesDir, ent.name);
+      const wtChange = path7.join(wt, "openspec", "changes", ent.name);
+      const mainChange = path7.join(changesDir, ent.name);
       out.push({
         name: ent.name,
         path: `openspec/changes/${ent.name}`,
         total,
         done,
         // 任一侧存在即算（详情读取是 worktree 优先、主目录兜底，列表标记保持一致）
-        hasProposal: fs9.existsSync(path8.join(wtChange, "proposal.md")) || fs9.existsSync(path8.join(mainChange, "proposal.md")),
-        hasDesign: fs9.existsSync(path8.join(wtChange, "design.md")) || fs9.existsSync(path8.join(mainChange, "design.md")),
+        hasProposal: fs8.existsSync(path7.join(wtChange, "proposal.md")) || fs8.existsSync(path7.join(mainChange, "proposal.md")),
+        hasDesign: fs8.existsSync(path7.join(wtChange, "design.md")) || fs8.existsSync(path7.join(mainChange, "design.md")),
         inWorktree: true
       });
     }
@@ -1449,14 +1682,14 @@ function scanApplyChanges(root) {
 function readApplyChange(root, name) {
   const wt = worktreeDir(root, name);
   const mainChangeDir = changeDir(root, name);
-  const proposalFrom = fs9.existsSync(path8.join(wt, "openspec", "changes", name, "proposal.md")) ? path8.join(wt, "openspec", "changes", name, "proposal.md") : path8.join(mainChangeDir, "proposal.md");
-  const designFrom = fs9.existsSync(path8.join(wt, "openspec", "changes", name, "design.md")) ? path8.join(wt, "openspec", "changes", name, "design.md") : path8.join(mainChangeDir, "design.md");
-  const tasksFrom = fs9.existsSync(path8.join(wt, "openspec", "changes", name, "tasks.md")) ? path8.join(wt, "openspec", "changes", name, "tasks.md") : path8.join(mainChangeDir, "tasks.md");
+  const proposalFrom = fs8.existsSync(path7.join(wt, "openspec", "changes", name, "proposal.md")) ? path7.join(wt, "openspec", "changes", name, "proposal.md") : path7.join(mainChangeDir, "proposal.md");
+  const designFrom = fs8.existsSync(path7.join(wt, "openspec", "changes", name, "design.md")) ? path7.join(wt, "openspec", "changes", name, "design.md") : path7.join(mainChangeDir, "design.md");
+  const tasksFrom = fs8.existsSync(path7.join(wt, "openspec", "changes", name, "tasks.md")) ? path7.join(wt, "openspec", "changes", name, "tasks.md") : path7.join(mainChangeDir, "tasks.md");
   const proposal = readText(proposalFrom);
   const design = readText(designFrom);
   const tasks = readText(tasksFrom);
   const { total, done } = countTasks(tasks);
-  const inWorktree = fs9.existsSync(path8.join(wt, "openspec", "changes", name));
+  const inWorktree = fs8.existsSync(path7.join(wt, "openspec", "changes", name));
   const dependsOn = parseDependsOn(proposal);
   const hasTestStrategy = /^##\s+测试策略\s*$/m.test(design);
   return {
@@ -1513,8 +1746,12 @@ var apply6 = {
   }
 };
 
-// src/server/design-assets.ts
+// src/plugins/design/index.ts
 import path9 from "path";
+import fs9 from "fs";
+
+// src/server/design-assets.ts
+import path8 from "path";
 var PAGE_EXTS = [".html", ".htm"];
 var ICON_EXTS = [".svg", ".png", ".ico", ".jpg", ".jpeg", ".gif", ".webp"];
 var VIDEO_EXTS = [".mp4", ".webm", ".mov", ".ogg", ".ogv"];
@@ -1537,30 +1774,62 @@ function categorize(rel, ext) {
   }
   return null;
 }
-function scanAssets(root) {
+function scanAssets(root, subDir = "") {
   const out = {};
   const keys = ["page", "component", "icon", "token", "md", "video", "audio", "pdf", "font"];
   for (const k of keys) out[k] = [];
   const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage", ".next", ".cache"]);
-  walkDir(root, { skip: SKIP, onFile: (abs, rel) => {
-    const ext = path9.extname(abs).toLowerCase();
+  const scanRoot = subDir ? path8.join(root, subDir) : root;
+  walkDir(scanRoot, { skip: SKIP, onFile: (abs, rel) => {
+    const ext = path8.extname(abs).toLowerCase();
     const t = categorize(rel, ext);
-    if (t) out[t].push({ path: rel, name: path9.basename(abs), ext, type: t });
+    if (t) out[t].push({ path: rel, name: path8.basename(abs), ext, type: t });
   } });
   return out;
 }
 
 // src/plugins/design/index.ts
+var ASSET_KEYS = ["page", "component", "icon", "token", "md", "video", "audio", "pdf", "font"];
+function mergeScanResults(a, b) {
+  const out = {};
+  for (const k of ASSET_KEYS) {
+    out[k] = [...a[k], ...b[k]];
+  }
+  return out;
+}
 var apply7 = {
   inject: ["server", "dashboard"],
   apply(ctx, config) {
     const root = config.root;
     ctx.inject(["server"], () => {
       if (!ctx.server?.route) return;
-      ctx.dashboard.register({ mode: "design", label: "\u8BBE\u8BA1\u8D44\u4EA7", icon: "\u{1F3A8}", description: "\u9875\u9762/\u7EC4\u4EF6/\u56FE\u6807/Token \u5206\u7C7B\u9884\u89C8" });
+      ctx.dashboard.register({
+        mode: "design",
+        label: "\u8BBE\u8BA1\u8D44\u4EA7",
+        icon: "\u{1F3A8}",
+        description: "\u9875\u9762/\u7EC4\u4EF6/\u56FE\u6807/Token \u5206\u7C7B\u9884\u89C8",
+        config: {
+          folders: { type: "string[]", label: "\u626B\u63CF\u6587\u4EF6\u5939", default: [] }
+        }
+      });
       ctx.server.route("/__design/assets", async (_req, res) => {
         res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
-        res.end(JSON.stringify(scanAssets(root)));
+        const designConfig = ctx.dashboard.getConfig("design");
+        const folders = Array.isArray(designConfig?.folders) ? designConfig.folders : [];
+        if (folders.length === 0) {
+          res.end(JSON.stringify(scanAssets(root)));
+          return;
+        }
+        let merged = {};
+        for (const k of ASSET_KEYS) merged[k] = [];
+        for (const folder of folders) {
+          const folderPath = path9.resolve(root, folder);
+          if (fs9.existsSync(folderPath) && fs9.statSync(folderPath).isDirectory()) {
+            const result = scanAssets(folderPath);
+            merged = mergeScanResults(merged, result);
+          }
+        }
+        res.end(JSON.stringify(merged));
       });
     });
   }
@@ -1570,7 +1839,17 @@ var apply7 = {
 var apply8 = {
   inject: ["dashboard"],
   apply(ctx) {
-    ctx.dashboard.register({ mode: "view", label: "\u9879\u76EE\u6D4F\u89C8", icon: "\u{1F441}\uFE0F", description: "openspec / docs / \u6587\u6863\u9884\u89C8" });
+    ctx.dashboard.register({
+      mode: "view",
+      label: "\u9879\u76EE\u6D4F\u89C8",
+      icon: "\u{1F441}\uFE0F",
+      description: "openspec / docs / \u6587\u6863\u9884\u89C8",
+      config: {
+        hiddenDirs: { type: "string[]", label: "\u9690\u85CF\u76EE\u5F55", default: [".git", "node_modules", "dist", "build"] },
+        defaultExpandDepth: { type: "number", label: "\u9ED8\u8BA4\u5C55\u5F00\u6DF1\u5EA6", default: 2 },
+        showHidden: { type: "boolean", label: "\u663E\u793A\u9690\u85CF\u6587\u4EF6", default: false }
+      }
+    });
   }
 };
 
@@ -1641,8 +1920,250 @@ var apply9 = {
   }
 };
 
+// src/server/apply-batch-store.ts
+import fs11 from "fs";
+import path11 from "path";
+var DEFAULT_STATE = {
+  version: "1",
+  status: "idle",
+  changes: [],
+  batches: [],
+  currentBatchIndex: -1,
+  parallelism: 2,
+  logs: [],
+  conflicts: []
+};
+var ApplyBatchStore = class {
+  root;
+  statePath;
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(root, onBroadcast) {
+    this.root = root;
+    this.statePath = path11.join(root, ".zapply", "batch-state.json");
+    this.state = this.load();
+  }
+  load() {
+    try {
+      if (fs11.existsSync(this.statePath)) {
+        return JSON.parse(fs11.readFileSync(this.statePath, "utf8"));
+      }
+    } catch {
+    }
+    return { ...DEFAULT_STATE, createdAt: (/* @__PURE__ */ new Date()).toISOString(), updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  save() {
+    this.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    fs11.mkdirSync(path11.dirname(this.statePath), { recursive: true });
+    fs11.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+    this.listeners.forEach((fn) => fn());
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  read() {
+    return this.state;
+  }
+  updateStatus(status) {
+    this.state.status = status;
+    this.save();
+  }
+  updateChanges(changes) {
+    this.state.changes = changes;
+    this.save();
+  }
+  updateBatches(batches) {
+    this.state.batches = batches;
+    this.save();
+  }
+  updateParallelism(parallelism) {
+    this.state.parallelism = Math.max(1, Math.min(8, parallelism));
+    this.save();
+  }
+  addLog(log) {
+    this.state.logs.push(log);
+    if (this.state.logs.length > 1e3) {
+      this.state.logs = this.state.logs.slice(-1e3);
+    }
+    this.save();
+  }
+  updateConflicts(conflicts) {
+    this.state.conflicts = conflicts;
+    this.save();
+  }
+  updateChange(name, patch) {
+    const idx = this.state.changes.findIndex((c) => c.name === name);
+    if (idx !== -1) {
+      this.state.changes[idx] = { ...this.state.changes[idx], ...patch };
+      this.save();
+    }
+  }
+  updateCheckpoint(name, checkpoint) {
+    const idx = this.state.changes.findIndex((c) => c.name === name);
+    if (idx !== -1) {
+      this.state.changes[idx].checkpoint = checkpoint;
+      this.save();
+    }
+  }
+  reset() {
+    this.state = { ...DEFAULT_STATE, createdAt: (/* @__PURE__ */ new Date()).toISOString(), updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    this.save();
+  }
+};
+
+// src/plugins/apply-batch/index.ts
+var apply10 = {
+  inject: ["server", "dashboard", "reload"],
+  apply(ctx, config) {
+    const root = config.root;
+    ctx.inject(["server"], () => {
+      if (!ctx.server?.route) return;
+      ctx.dashboard.register({
+        mode: "apply-batch",
+        label: "\u6279\u91CF\u6267\u884C",
+        icon: "\u26A1",
+        description: "zapply \u6279\u91CF\u5E76\u884C\u6267\u884C\u9A7E\u9A76\u8231"
+      });
+      const store = new ApplyBatchStore(root, () => {
+        try {
+          ctx.reload.broadcast("files");
+        } catch {
+        }
+      });
+      ctx.server.route("/__apply-batch", async (_req, res) => {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(store.read()));
+      });
+      ctx.server.route("/__apply-batch/status", async (req, res) => {
+        try {
+          const body = JSON.parse(await readBody(req) || "{}");
+          store.updateStatus(body.status);
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify(store.read()));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "unknown error" }));
+        }
+      });
+      ctx.server.route("/__apply-batch/changes", async (_req, res) => {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(store.read().changes));
+      });
+      ctx.server.route("/__apply-batch/graph", async (_req, res) => {
+        const state = store.read();
+        const graph = {
+          changes: state.changes.map((c) => ({
+            name: c.name,
+            status: c.status,
+            dependencies: c.dependencies,
+            batchIndex: c.batchIndex
+          })),
+          batches: state.batches,
+          conflicts: state.conflicts
+        };
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(graph));
+      });
+      ctx.server.route("/__apply-batch/logs", async (_req, res) => {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(store.read().logs.slice(-100)));
+      });
+      ctx.server.route("/__apply-batch/approve", async (req, res) => {
+        try {
+          const body = JSON.parse(await readBody(req) || "{}");
+          store.updateStatus("running");
+          store.updateParallelism(body.parallelism ?? 2);
+          if (body.skipChanges?.length) {
+            for (const name of body.skipChanges) {
+              store.updateChange(name, { status: "skipped" });
+            }
+          }
+          store.addLog({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "info",
+            message: `\u7528\u6237\u786E\u8BA4\u6267\u884C\u8BA1\u5212\uFF0C\u5E76\u884C\u5EA6=${body.parallelism ?? 2}`
+          });
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify(store.read()));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "unknown error" }));
+        }
+      });
+      ctx.server.route("/__apply-batch/adjust", async (req, res) => {
+        try {
+          const body = JSON.parse(await readBody(req) || "{}");
+          if (body.parallelism) store.updateParallelism(body.parallelism);
+          if (body.skipChanges?.length) {
+            for (const name of body.skipChanges) {
+              store.updateChange(name, { status: "skipped" });
+            }
+          }
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify(store.read()));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "unknown error" }));
+        }
+      });
+      ctx.server.route("/__apply-batch/retry", async (req, res) => {
+        try {
+          const body = JSON.parse(await readBody(req) || "{}");
+          const name = body.name;
+          if (!name) throw new Error("missing name");
+          const change = store.read().changes.find((c) => c.name === name);
+          if (!change) throw new Error("change not found");
+          store.updateChange(name, {
+            status: "pending",
+            error: void 0,
+            retryCount: (change.retryCount ?? 0) + 1
+          });
+          store.addLog({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "info",
+            message: `\u91CD\u8BD5 change: ${name}`,
+            changeName: name
+          });
+          res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+          res.end(JSON.stringify(store.read()));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(JSON.stringify({ error: e instanceof Error ? e.message : "unknown error" }));
+        }
+      });
+      ctx.server.route("/__apply-batch/pause", async (req, res) => {
+        store.updateStatus("paused");
+        store.addLog({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "warn",
+          message: "\u7528\u6237\u6682\u505C\u6279\u91CF\u6267\u884C"
+        });
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(store.read()));
+      });
+      ctx.server.route("/__apply-batch/resume", async (req, res) => {
+        store.updateStatus("running");
+        store.addLog({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "info",
+          message: "\u7528\u6237\u6062\u590D\u6279\u91CF\u6267\u884C"
+        });
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(store.read()));
+      });
+      ctx.server.route("/__apply-batch/reset", async (req, res) => {
+        store.reset();
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(JSON.stringify(store.read()));
+      });
+    });
+  }
+};
+
 // src/cli.ts
-var __dirname2 = path11.dirname(fileURLToPath2(import.meta.url));
+import YAML2 from "yaml";
+var __dirname2 = path12.dirname(fileURLToPath2(import.meta.url));
 var DEFAULT_PORT = 4190;
 function parseArgs() {
   const args = process.argv.slice(2);
@@ -1677,6 +2198,62 @@ async function pathExists(p) {
     return false;
   }
 }
+function migrateLegacyBugsConfig(root) {
+  const zgoalConfigYaml = path12.join(root, ".zgoal", "config.yaml");
+  const zdevConfigYaml = path12.join(root, ".zdev", "config.yaml");
+  if (fs12.existsSync(zgoalConfigYaml)) {
+    try {
+      fs12.unlinkSync(zgoalConfigYaml);
+    } catch {
+    }
+  }
+  if (!fs12.existsSync(zdevConfigYaml)) return;
+  const pluginsConfig = readPluginsConfig(root);
+  if ("bugs" in pluginsConfig) {
+    try {
+      fs12.unlinkSync(zdevConfigYaml);
+    } catch {
+    }
+    return;
+  }
+  let yamlContent;
+  try {
+    yamlContent = fs12.readFileSync(zdevConfigYaml, "utf8");
+  } catch {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = YAML2.parse(yamlContent);
+  } catch {
+    console.warn("[zdashboard] \u65E0\u6548\u7684 .zdev/config.yaml\uFF0C\u5DF2\u5FFD\u7565\u5E76\u5220\u9664");
+    try {
+      fs12.unlinkSync(zdevConfigYaml);
+    } catch {
+    }
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || !parsed.url || !parsed.product) {
+    console.warn("[zdashboard] .zdev/config.yaml \u7F3A\u5C11\u5FC5\u8981\u5B57\u6BB5\uFF0C\u5DF2\u5FFD\u7565\u5E76\u5220\u9664");
+    try {
+      fs12.unlinkSync(zdevConfigYaml);
+    } catch {
+    }
+    return;
+  }
+  const bugsConfig = {
+    url: String(parsed.url).replace(/\/+$/, ""),
+    account: typeof parsed.account === "string" ? parsed.account : "",
+    token: typeof parsed.token === "string" ? parsed.token : typeof parsed.password === "string" ? parsed.password : "",
+    product: Number(parsed.product)
+  };
+  pluginsConfig.bugs = bugsConfig;
+  writePluginsConfig(root, pluginsConfig);
+  try {
+    fs12.unlinkSync(zdevConfigYaml);
+  } catch {
+  }
+}
 async function loadExternal(ctx, dir, root) {
   if (!dir) return;
   let tsxLoaded = false;
@@ -1692,7 +2269,7 @@ async function loadExternal(ctx, dir, root) {
       if (!ent.isDirectory()) continue;
       const candidates = tsxLoaded ? ["index.ts", "index.js", "index.mjs"] : ["index.js", "index.mjs"];
       for (const name of candidates) {
-        const p = path11.join(dir, ent.name, name);
+        const p = path12.join(dir, ent.name, name);
         if (await pathExists(p)) {
           try {
             const mod = await import(p);
@@ -1707,8 +2284,8 @@ async function loadExternal(ctx, dir, root) {
               const m = ctx.dashboard.get(ent.name);
               if (m && m.mode === ent.name) {
                 const patch = { external: true };
-                const webDir = path11.join(dir, ent.name, "web");
-                if (await pathExists(path11.join(webDir, "index.html"))) {
+                const webDir = path12.join(dir, ent.name, "web");
+                if (await pathExists(path12.join(webDir, "index.html"))) {
                   ctx.server.static(`${PLUGIN_STATIC_PREFIX}${ent.name}/`, webDir);
                   if (!m.viewerUrl) patch.viewerUrl = `${PLUGIN_STATIC_PREFIX}${ent.name}/`;
                 }
@@ -1727,7 +2304,7 @@ async function loadExternal(ctx, dir, root) {
 }
 async function main() {
   const args = parseArgs();
-  const root = path11.resolve(args.dir);
+  const root = path12.resolve(args.dir);
   const existing = await findReusable(root);
   if (existing && !args.restart) {
     const u = `http://localhost:${existing.port}` + (args.page ? `#${args.page}` : "");
@@ -1741,11 +2318,12 @@ async function main() {
     console.log(`[zdashboard] --restart\uFF1A\u505C\u6B62\u65E7\u5B9E\u4F8B pid=${oldRecord.pid}`);
     await stopInstance(oldRecord);
   }
-  const appDir = path11.resolve(__dirname2, "web");
+  const appDir = path12.resolve(__dirname2, "web");
   const startPort = oldRecord && !args.portExplicit ? oldRecord.port : args.port;
-  const zdevDir = path11.join(root, ".zdev");
-  const dataDir = fs11.existsSync(zdevDir) ? ".zdev/" : "";
+  const zdevDir = path12.join(root, ".zdev");
+  const dataDir = fs12.existsSync(zdevDir) ? ".zdev/" : "";
   const det = await detect(root);
+  migrateLegacyBugsConfig(root);
   const ctx = new Context();
   ctx.plugin(ServerService, {
     root,
@@ -1767,6 +2345,7 @@ async function main() {
     { name: "bugs", apply: apply4 },
     { name: "review", apply: apply5 },
     { name: "apply", apply: apply6 },
+    { name: "apply-batch", apply: apply10 },
     { name: "design", apply: apply7 },
     { name: "view", apply: apply8 }
   ];
@@ -1778,7 +2357,7 @@ async function main() {
     }
   }
   if (args.plugins) {
-    await loadExternal(ctx, path11.resolve(args.plugins), root);
+    await loadExternal(ctx, path12.resolve(args.plugins), root);
   }
   const shutdown = () => {
     try {