@lyra-ai/toolkit 0.2.2 → 0.2.4

package/src/status.mjs

@@ -5,14 +5,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { load as loadConfig, UPLOADED_PATH } from './shared/config.mjs';
 
 const HOME = os.homedir();
 const PLUGIN_DIR = path.join(HOME, '.claude', 'plugins', 'toolkit');
-const TOOLKIT_DIR = path.join(HOME, '.toolkit');
 
 export function status() {
   const pluginExists = fs.existsSync(path.join(PLUGIN_DIR, '.claude-plugin', 'plugin.json'));
-  const configExists = fs.existsSync(path.join(TOOLKIT_DIR, 'config.json'));
+  const config = loadConfig();
+  const configExists = !!config.registry || !!config.uid;
 
   console.log('Toolkit Status');
   console.log('════════════════════════════════════════');
@@ -29,28 +30,26 @@ export function status() {
     console.log(`  版本:        ${pj.version}`);
   }
 
-  // 配置
+  // 配置(走 shared/config.mjs)
   if (configExists) {
-    const config = JSON.parse(fs.readFileSync(path.join(TOOLKIT_DIR, 'config.json'), 'utf-8'));
     console.log(`  平台地址:    ${config.registry}${config.contexts?.metrics || '/ai-metrics'}/`);
     console.log(`  身份 UID:    ${config.uid?.slice(0, 12)}...`);
   }
 
   // 上传状态
-  const uploadedPath = path.join(TOOLKIT_DIR, 'uploaded.json');
   try {
-    const up = JSON.parse(fs.readFileSync(uploadedPath, 'utf-8'));
-    console.log(`  已传会话:    ${up.uploaded_sids?.length || 0} 个`);
-    console.log(`  上次上传:    ${up.last_flush || '从未'}`);
+    const up = JSON.parse(fs.readFileSync(UPLOADED_PATH, 'utf-8'));
+    console.log(`  已同步:      ${up.uploaded_sids?.length || 0} 个会话`);
+    console.log(`  上次同步:    ${up.last_flush || '从未'}`);
   } catch {
-    console.log('  上传状态:    未初始化');
+    console.log('  同步状态:    未初始化');
   }
 
   // 待传会话计数
   const projectsDir = path.join(HOME, '.claude', 'projects');
   let pending = 0;
   if (fs.existsSync(projectsDir) && configExists) {
-    const up = JSON.parse(fs.readFileSync(uploadedPath, 'utf-8'));
+    const up = JSON.parse(fs.readFileSync(UPLOADED_PATH, 'utf-8'));
     const uploadedSet = new Set(up.uploaded_sids || []);
     for (const projDir of fs.readdirSync(projectsDir)) {
       const pp = path.join(projectsDir, projDir);
@@ -62,6 +61,6 @@ export function status() {
       } catch {}
     }
   }
-  console.log(`  待传会话:    ${pending} 个`);
+  console.log(`  待同步:      ${pending} 个会话`);
   console.log('════════════════════════════════════════');
 }

package/src/zentao.mjs

@@ -46,23 +46,25 @@ const HELP = `zentao-cli —— 面向 AI agent 的禅道 CLI
 命令:
   project list [--status active|closed|all] [--limit N] [--offset N] [--pretty]
   product list [--status active|closed|all] [--limit N] [--offset N] [--pretty]
+  build list  [--project <ID|名称前缀>] [--limit N] [--offset N] [--pretty]   # 列出项目版本（builds）
   bug list    [--title <kw>] [--status S] [--severity 1-4] [--priority 1-4]
               [--assigned-to U] [--opened-by U] [--mine]
               [--product <ID|名称前缀>] [--project ID] [--start YYYY-MM-DD] [--end YYYY-MM-DD]
               [--order id_desc|openedDate_desc|severity_desc|priority_desc|...]
               [--limit N] [--offset N] [--pretty]
-              # 本地缓存检索（需先 bug sync）；bug search 等价别名；--product 支持名称前缀
+              # 仅在本地工作集内检索（需先 bug sync）；bug search 等价别名
   bug get     <bugId> [--pretty|--raw]
   bug create  --title T [--product ID] [--severity 1-4] [--priority 1-4]
-              [--assigned-to U] [--type code] [--steps ...] [--pretty]
+              [--assigned-to U] [--type code] [--build B] [--steps ...] [--pretty]
   bug resolve <bugId> --resolution <r> [--build B] [--comment ...]
               r ∈ {${RESOLUTIONS.join(',')}}
   bug assign  <bugId> --to <user>
-  bug sync    [--product <ID|名称前缀>] [--status <browseType>] [--mine]   # 同步产品 bug 到本地索引（默认 unclosed）
+  bug confirm <bugId> [--comment ...] [--assigned-to U] [--priority 1-4] [--type T]   # 确认 Bug
+  bug sync    [--product <ID|名称前缀>] [--status <browseType>] [--mine]   # 同步产品 bug 到本地工作集（整体替换，默认 unclosed）
   bug browse-types                                            # 列出 sync --status 的合法 browseType
   config                列出所有配置（密码脱敏）
   config get   <key>    取单个配置值（ZENTAO_PASSWORD 需 --raw 才显原文）
-  config set   <key> <v> 写入 ~/.zentao-cli/.env
+  config set   <key> <v> 写入 ~/.toolkit/config.json（同时写 .env 兼容）
   config unset <key>    删除配置项
   config path           输出配置文件路径
   init                  向导式初始化配置（交互提示填 URL/用户/密码等）
@@ -71,8 +73,8 @@ const HELP = `zentao-cli —— 面向 AI agent 的禅道 CLI
   ping        验证连通性 + 凭据
 
 通用: --pretty(人读) --raw(原始 JSON) 默认输出规整 JSON
-配置: ZENTAO_URL / ZENTAO_USERNAME / ZENTAO_PASSWORD（必需），见 .env.example
-支持: ZENTAO_DEFAULT_PROJECT / ZENTAO_TOKEN_TTL / ZENTAO_LOG_LEVEL / ZENTAO_CACHE_STALE_MS
+配置: 统一存 ~/.toolkit/config.json → zentao 段（也支持 ~/.zentao-cli/.env 兼容）
+toolkit config set zentao.url <url> / zentao.username <u> / zentao.password <p>
 `;
 
 function fileTokenStore(cachePath) {
@@ -91,6 +93,15 @@ function loadFilesText() {
   return files; // 项目级在前（优先级高）
 }
 
+// 从 ~/.toolkit/config.json → zentao 段读配置(优先级高于 .env)
+function loadToolkitZentaoConfig() {
+  try {
+    const configPath = path.join(os.homedir(), '.toolkit', 'config.json');
+    const raw = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(raw).zentao || {};
+  } catch { return {}; }
+}
+
 function main() {
   const argv = process.argv.slice(2);
   const parsed = parseArgs(argv);
@@ -139,18 +150,28 @@ export function parseEnvFile(text) {
 
 const REQUIRED = ['ZENTAO_URL', 'ZENTAO_USERNAME', 'ZENTAO_PASSWORD'];
 
-export function loadConfig({ env, filesText }, { required } = {}) {
-  // filesText: 数组，靠前优先级高（项目级 .env 在前，用户级在后）
+export function loadConfig({ env, filesText, toolkitZentao }, { required } = {}) {
+  // 优先级(高→低): OS env > 项目 .env > 用户 .env > ~/.toolkit/config.json → zentao 段
   const merged = {};
+
+  // 1. toolkit config.json → zentao 段(最低优先级,作为底)
+  const tkZentao = toolkitZentao !== undefined ? toolkitZentao : loadToolkitZentaoConfig();
+  for (const [camel, upper] of Object.entries(ZENTAO_KEY_MAP)) {
+    if (tkZentao[camel] != null) merged[upper] = String(tkZentao[camel]);
+  }
+
+  // 2. .env 文件(项目级 > 用户级)
   for (let i = filesText.length - 1; i >= 0; i--) {
     Object.assign(merged, parseEnvFile(filesText[i]));
   }
-  Object.assign(merged, env); // env 优先级最高
+
+  // 3. OS env(最高优先级)
+  Object.assign(merged, env);
 
   const requiredKeys = required !== false ? REQUIRED : [];
   const missing = requiredKeys.filter((k) => !merged[k]);
   if (missing.length) {
-    throw new ZentaoError('CONFIG_ERROR', `缺少必需环境变量: ${missing.join(', ')}（见 .env.example）`);
+    throw new ZentaoError('CONFIG_ERROR', `缺少必需配置: ${missing.join(', ')}（toolkit config set zentao.url / zentao.username / zentao.password 或编辑 .env）`);
   }
   return {
     zentaoUrl: String(merged.ZENTAO_URL || '').replace(/\/+$/, ''),
@@ -165,12 +186,27 @@ export function loadConfig({ env, filesText }, { required } = {}) {
 // ---- config 读写（操作 ~/.zentao-cli/.env）----
 
 export function configFilePath() {
+  // .env 文件路径(兼容读写);toolkit config.json 通过 loadToolkitZentaoConfig 读
   return path.join(os.homedir(), '.zentao-cli', '.env');
 }
 
+export function toolkitConfigPath() {
+  return path.join(os.homedir(), '.toolkit', 'config.json');
+}
+
 // 已知配置键（用于 list 展示顺序与 set 校验提示）
 const KNOWN_KEYS = ['ZENTAO_URL', 'ZENTAO_USERNAME', 'ZENTAO_PASSWORD', 'ZENTAO_DEFAULT_PROJECT', 'ZENTAO_TOKEN_TTL', 'ZENTAO_LOG_LEVEL', 'ZENTAO_CACHE_STALE_MS'];
 
+// toolkit config.json 键名映射(camelCase ↔ UPPER_CASE)
+const ZENTAO_KEY_MAP = {
+  'url': 'ZENTAO_URL',
+  'username': 'ZENTAO_USERNAME',
+  'password': 'ZENTAO_PASSWORD',
+  'default-project': 'ZENTAO_DEFAULT_PROJECT',
+  'token-ttl': 'ZENTAO_TOKEN_TTL',
+  'cache-stale-ms': 'ZENTAO_CACHE_STALE_MS',
+};
+
 // 敏感键：list/get 默认脱敏
 const SENSITIVE_KEYS = new Set(['ZENTAO_PASSWORD']);
 
@@ -273,6 +309,16 @@ export function shapeProduct(p) {
   };
 }
 
+// 版本（build）：依据 禅道APIv1.0.md §2.11 GET /projects/{id}/builds
+export function shapeBuild(b) {
+  return {
+    id: b.id, name: b.name,
+    project: b.project ?? '', product: b.product ?? '',
+    execution: b.execution ?? '', branch: b.branch ?? '',
+    date: b.date ?? '', builder: b.builder ?? '', desc: b.desc ?? '',
+  };
+}
+
 export function shapeBugListItem(b) {
   return {
     id: b.id, title: b.title, severity: b.severity, priority: b.pri,
@@ -311,6 +357,15 @@ export function productsToMarkdown({ total, count, products }) {
   return lines.join('\n');
 }
 
+export function buildsToMarkdown({ total, count, builds }) {
+  const lines = ['# Builds List', '', `Found ${total} builds (showing ${count})`, '',
+    '| ID | Name | Project | Product | Date | Builder | Desc |', '|---|---|---|---|---|---|---|'];
+  for (const b of builds) {
+    lines.push(`| ${b.id} | ${b.name} | ${b.project} | ${b.product} | ${b.date} | ${b.builder} | ${b.desc} |`);
+  }
+  return lines.join('\n');
+}
+
 export function bugListToMarkdown({ total, count, bugs }) {
   const lines = ['# Bug List', '', `Found ${total} bugs (showing ${count})`, '',
     '| ID | Title | Sev | Pri | Status | AssignedTo | OpenedBy | OpenedDate |', '|---|---|---|---|---|---|---|---|'];
@@ -499,9 +554,23 @@ function cmdConfigSet(parsed, filesystem) {
   const key = parsed.positional[0];
   const value = parsed.positional[1];
   if (!key || value === undefined) return { stderr: '用法：zentao config set <key> <value>', exitCode: 2 };
-  const keyUpper = key.toUpperCase();
+  // 接受 ZENTAO_URL 或 url 或 URL 两种写法
+  const keyUpper = key.toUpperCase().replace(/^ZENTAO_/, 'ZENTAO_').startsWith('ZENTAO_') ? key.toUpperCase() : `ZENTAO_${key.toUpperCase()}`;
   if (!KNOWN_KEYS.includes(keyUpper)) {
-    return { stderr: `未知配置项: ${key}（合法值: ${KNOWN_KEYS.join(', ')}）。如需自定义变量请直接编辑 .env`, exitCode: 2 };
+    return { stderr: `未知配置项: ${key}（合法值: ${KNOWN_KEYS.join(', ')}）。也可用 toolkit config set zentao.url <value>`, exitCode: 2 };
+  }
+  // 优先写 ~/.toolkit/config.json → zentao 段;同时也写 .env(兼容旧逻辑)
+  const camelKey = Object.entries(ZENTAO_KEY_MAP).find(([_, u]) => u === keyUpper)?.[0];
+  if (camelKey) {
+    try {
+      const configPath = path.join(os.homedir(), '.toolkit', 'config.json');
+      let tkConfig = {};
+      try { tkConfig = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch {}
+      if (!tkConfig.zentao) tkConfig.zentao = {};
+      tkConfig.zentao[camelKey] = value;
+      fs.mkdirSync(path.dirname(configPath), { recursive: true });
+      fs.writeFileSync(configPath, JSON.stringify(tkConfig, null, 2));
+    } catch { /* 写 toolkit config 失败不影响 .env */ }
   }
   setConfigKey(keyUpper, value, filesystem);
   return { stdout: JSON.stringify({ set: keyUpper, value: maskIfSensitive(keyUpper, value) }, null, 2) };
@@ -516,7 +585,7 @@ function cmdConfigUnset(parsed, filesystem) {
 }
 
 function cmdConfigPath() {
-  return { stdout: configFilePath() };
+  return { stdout: toolkitConfigPath() + ' (zentao 段) / ' + configFilePath() + ' (.env 兼容)' };
 }
 
 // ---- init 向导 ----
@@ -656,43 +725,49 @@ async function cmdProductList(parsed, client) {
   return { stdout: JSON.stringify(out, null, 2) };
 }
 
-// 统一 bug 列表 → 全走本地缓存（先 sync 后查）
-// bug list / bug search 两者等价，search 为隐藏别名
-async function cmdBugList(parsed, config, deps) {
-  const { cacheDir, fs, now } = deps;
-  // 解析 --product：非数字按产品名前缀匹配
-  let wantProduct = parsed.flags.product;
-  if (wantProduct && !/^\d+$/.test(String(wantProduct))) {
-    const client = deps.client || createClient(config, deps);
-    const data = await client.request('GET', '/api.php/v1/products');
-    const matches = (data.products || []).filter((p) => p.name && String(p.name).startsWith(wantProduct));
+// 列出项目版本（builds）：依据 禅道APIv1.0.md §2.11.1 GET /projects/{id}/builds
+async function cmdBuildList(parsed, client, config) {
+  let projectId = parsed.flags.project || config.defaultProject;
+  if (!projectId) throw new ZentaoError('INVALID_PARAMETER', '未指定 --project 且无 ZENTAO_DEFAULT_PROJECT');
+  // 名称前缀解析 + 存在性校验（与 sync/create 一致）
+  const projectList = await client.request('GET', '/api.php/v1/projects');
+  const projects = projectList.projects || [];
+  const knownIds = new Set(projects.map((p) => String(p.id)));
+  if (!/^\d+$/.test(String(projectId))) {
+    const matches = projects.filter((p) => p.name && String(p.name).startsWith(projectId));
     if (!matches.length) {
-      const names = (data.products || []).slice(0, 20).map((p) => p.name).filter(Boolean).join(', ');
-      return { stderr: `未找到名前缀匹配 "${wantProduct}" 的产品。已知产品: ${names || '(无)'}`, exitCode: 2 };
+      const names = projects.slice(0, 20).map((p) => p.name).filter(Boolean).join(', ');
+      throw new ZentaoError('INVALID_PARAMETER', `未找到名前缀匹配 "${projectId}" 的项目。已知项目: ${names || '(无)'}`);
     }
-    wantProduct = matches[0].id; // 优先取第一个匹配
-  }
-  const products = wantProduct ? [String(wantProduct)] : listCacheProducts(fs, cacheDir);
-  if (!products.length) {
-    return { stderr: '无本地缓存，请先：zentao bug sync --product <ID>', exitCode: 2 };
+    projectId = matches[0].id;
   }
-  const nowMs = typeof now === 'function' ? now() : (now ?? Date.now());
-  let merged = [];
-  let oldestSync = Infinity;
-  let missing = false;
-  for (const pid of products) {
-    const cache = readBugCache(cacheDir, pid, fs);
-    if (!cache) { missing = true; continue; }
-    oldestSync = Math.min(oldestSync, cache.syncedAt);
-    for (const b of cache.bugs) merged.push({ ...b, productId: cache.product });
+  if (!knownIds.has(String(projectId))) {
+    throw new ZentaoError('INVALID_PARAMETER', `项目 ${projectId} 在当前服务器不存在。可用项目 ID: ${[...knownIds].slice(0, 20).join(', ') || '(无)'}`);
   }
-  if (!merged.length && missing) {
-    return { stderr: `产品 ${wantProduct} 无本地缓存，请先：zentao bug sync --product ${wantProduct}`, exitCode: 2 };
+  const data = await client.request('GET', `/api.php/v1/projects/${projectId}/builds`);
+  const builds = (data.builds || []).map(shapeBuild);
+  const limit = Number(parsed.flags.limit) || 20;
+  const offset = Number(parsed.flags.offset) || 0;
+  const page = paginate(builds, limit, offset);
+  const out = { total: page.total, count: page.count, offset: page.offset, has_more: page.has_more, next_offset: page.next_offset, builds: page.items };
+  if (parsed.flags.pretty) return { stdout: buildsToMarkdown({ ...out, builds: page.items }) };
+  return { stdout: JSON.stringify(out, null, 2) };
+}
+
+// 统一 bug 列表 → 只在本地【工作集】内查（先 sync 后查，list 不访问服务端）
+// bug list / bug search 两者等价，search 为隐藏别名
+async function cmdBugList(parsed, config, deps) {
+  const { cacheDir, fs, now } = deps;
+  const set = readWorkingSet(cacheDir, config, fs);
+  if (!set) {
+    return { stderr: '无本地工作集（或已切换服务器/账号），请先：zentao bug sync --product <ID|名称前缀>', exitCode: 2 };
   }
+  const nowMs = typeof now === 'function' ? now() : (now ?? Date.now());
+  let out = set.bugs.map((b) => ({ ...b }));
 
-  // ---- 本地过滤 ----
-  let out = merged;
+  // ---- 本地过滤 ----（--product 退化为本地 productId 过滤，不再访问服务端）
   if (parsed.flags.mine) out = out.filter((b) => b.assignedTo === config.username);
+  if (parsed.flags.product) out = out.filter((b) => String(b.productId) === String(parsed.flags.product));
   if (parsed.flags.title) {
     const kw = String(parsed.flags.title).toLowerCase();
     out = out.filter((b) => String(b.title || '').toLowerCase().includes(kw));
@@ -727,14 +802,14 @@ async function cmdBugList(parsed, config, deps) {
 
   // staleness 提示
   let stderr;
-  if (isFinite(oldestSync) && nowMs - oldestSync > CACHE_STALE_MS) {
-    const hrs = ((nowMs - oldestSync) / 3600000).toFixed(1);
-    stderr = `⚠ 缓存可能过期（${hrs}h 前同步），关键判断请 'bug get <id>' 或重新 'bug sync'`;
+  if (nowMs - set.syncedAt > CACHE_STALE_MS) {
+    const hrs = ((nowMs - set.syncedAt) / 3600000).toFixed(1);
+    stderr = `⚠ 工作集可能过期（${hrs}h 前同步），关键判断请 'bug get <id>' 或重新 'bug sync'`;
   }
   if (parsed.flags.pretty) {
     return { stdout: bugListToMarkdown({ total: out.length, count: page.length, bugs: page }), stderr };
   }
-  const body = { syncedAt: isFinite(oldestSync) ? oldestSync : null, total: out.length, count: page.length, offset, has_more: end < out.length, bugs: page };
+  const body = { syncedAt: set.syncedAt, product: set.product, total: out.length, count: page.length, offset, has_more: end < out.length, bugs: page };
   return { stdout: JSON.stringify(body, null, 2), stderr };
 }
 
@@ -750,21 +825,39 @@ async function cmdBugGet(parsed, client) {
 
 // 创建 Bug
 // 依据 禅道APIv1.0.md §创建Bug：POST /products/id/bugs（brief 原写 /projects/id/bugs 为误，文档以产品为作用域）
-// TODO 依据 禅道APIv1.0.md §创建Bug，实测受限(只读环境)未做活体验证
-async function cmdBugCreate(parsed, client, defaultProject) {
-  // 文档作用域为 product；保留 --project 旗标与 defaultProject 配置以兼容现有 cfg，语义等同 productId
-  const productId = parsed.flags.project || parsed.flags.product || defaultProject;
-  if (!productId) throw new ZentaoError('INVALID_PARAMETER', '未指定 --project 且无 ZENTAO_DEFAULT_PROJECT');
+async function cmdBugCreate(parsed, client, config) {
+  // 文档作用域为 product；保留 --project/--product 旗标与 defaultProject 配置，语义等同 productId
+  const defaultProject = config?.defaultProject;
+  let productId = parsed.flags.project || parsed.flags.product || defaultProject;
+  if (!productId) throw new ZentaoError('INVALID_PARAMETER', '未指定 --project/--product 且无 ZENTAO_DEFAULT_PROJECT');
   if (!parsed.flags.title) return { stderr: '错误：缺少 --title', exitCode: 2 };
+  // 名称前缀解析 + 存在性校验（与 sync 一致，防 defaultProject 指向不存在产品时静默出错）
+  const productList = await client.request('GET', '/api.php/v1/products');
+  const products = productList.products || [];
+  const knownIds = new Set(products.map((p) => String(p.id)));
+  if (!/^\d+$/.test(String(productId))) {
+    const matches = products.filter((p) => p.name && String(p.name).startsWith(productId));
+    if (!matches.length) {
+      const names = products.slice(0, 20).map((p) => p.name).filter(Boolean).join(', ');
+      throw new ZentaoError('INVALID_PARAMETER', `未找到名前缀匹配 "${productId}" 的产品。已知产品: ${names || '(无)'}`);
+    }
+    productId = matches[0].id;
+  }
+  if (!knownIds.has(String(productId))) {
+    throw new ZentaoError('INVALID_PARAMETER', `产品 ${productId} 在当前服务器不存在。可用产品 ID: ${[...knownIds].slice(0, 20).join(', ') || '(无)'}`);
+  }
   const body = {
     title: parsed.flags.title,
-    // severity/pri/type 文档标为必填；这里仅透传，缺失时由后端校验
-    ...(parsed.flags.severity ? { severity: parsed.flags.severity } : {}),
-    ...(parsed.flags.priority ? { pri: parsed.flags.priority } : {}),
-    ...(parsed.flags['assigned-to'] ? { assignedTo: parsed.flags['assigned-to'] } : {}),
-    ...(parsed.flags.type ? { type: parsed.flags.type } : {}),
+    // openedBuild（影响版本）：多数 zentao 版本必填，默认 trunk（主线）可在无 build 记录时创建；--build 可覆盖
+    openedBuild: parsed.flags.build || 'trunk',
+    // type（Bug类型）：文档标必填，默认 code；--type 可覆盖（codeerror/interface/config/security/...）
+    type: parsed.flags.type || 'code',
+    // 默认指派给当前用户（自己），--assigned-to 可覆盖
+    assignedTo: parsed.flags['assigned-to'] || config?.username || '',
+    // severity/pri 文档标必填，默认 3（次要/中）；--severity/--priority 可覆盖
+    severity: parsed.flags.severity || '3',
+    pri: parsed.flags.priority || '3',
     ...(parsed.flags.steps ? { steps: parsed.flags.steps } : {}),
-    // openedBuild 在部分版本必填，留 TODO：实测后补默认值
   };
   const data = await client.request('POST', `/api.php/v1/products/${productId}/bugs`, { body });
   return { stdout: JSON.stringify({ id: data.id ?? data.bugId ?? null }, null, 2) };
@@ -772,19 +865,20 @@ async function cmdBugCreate(parsed, client, defaultProject) {
 
 // 解决 Bug
 // 依据 禅道APIv1.0.md §解决Bug：POST /bugs/id/resolve，body resolution 必填
-async function cmdBugResolve(parsed, client, deps) {
+async function cmdBugResolve(parsed, client, deps, config) {
   const bugId = parsed.positional[0];
   if (!bugId) return { stderr: '错误：缺少 bugId', exitCode: 2 };
   if (!parsed.flags.resolution) return { stderr: `错误：缺少 --resolution（可选：${RESOLUTIONS.join(',')}）`, exitCode: 2 };
   const body = {
     resolution: parsed.flags.resolution,
-    ...(parsed.flags.build ? { resolvedBuild: parsed.flags.build } : {}),
+    // resolvedBuild（解决版本）：21.x 起必填，默认 trunk（主线）；--build 可覆盖
+    resolvedBuild: parsed.flags.build || 'trunk',
     ...(parsed.flags.comment ? { comment: parsed.flags.comment } : {}),
   };
   const data = await client.request('POST', `/api.php/v1/bugs/${bugId}/resolve`, { body });
-  // best-effort 更新本地索引（不阻断）
-  if (deps?.cacheDir && deps?.fs) {
-    updateCachedBugAnywhere(deps.cacheDir, bugId, { status: 'resolved', resolution: parsed.flags.resolution }, deps.fs);
+  // best-effort 更新本地工作集（不阻断）
+  if (deps?.cacheDir && deps?.fs && config) {
+    updateWorkingSetBug(deps.cacheDir, config, bugId, { status: 'resolved', resolution: parsed.flags.resolution }, deps.fs);
   }
   return { stdout: JSON.stringify({ id: bugId, resolved: true, raw: data?.id ?? null }, null, 2) };
 }
@@ -794,19 +888,37 @@ async function cmdBugResolve(parsed, client, deps) {
 // 亦无独立 comment 端点）。指派复用「修改 Bug」通道，body 仅传 assignedTo 字段。
 // 字段名 assignedTo 为禅道各动作体（confirm/active/task 等）通用指派字段，与文档一致。
 // TODO 实测受限(只读环境)未做活体验证。
-async function cmdBugAssign(parsed, client, deps) {
+async function cmdBugAssign(parsed, client, deps, config) {
   const bugId = parsed.positional[0];
   if (!bugId) return { stderr: '错误：缺少 bugId', exitCode: 2 };
   if (!parsed.flags.to) return { stderr: '错误：缺少 --to <user>', exitCode: 2 };
   const body = { assignedTo: parsed.flags.to };
   const data = await client.request('PUT', `/api.php/v1/bugs/${bugId}`, { body });
-  // best-effort 更新本地索引（不阻断）
-  if (deps?.cacheDir && deps?.fs) {
-    updateCachedBugAnywhere(deps.cacheDir, bugId, { assignedTo: parsed.flags.to }, deps.fs);
+  // best-effort 更新本地工作集（不阻断）
+  if (deps?.cacheDir && deps?.fs && config) {
+    updateWorkingSetBug(deps.cacheDir, config, bugId, { assignedTo: parsed.flags.to }, deps.fs);
   }
   return { stdout: JSON.stringify({ id: bugId, assignedTo: parsed.flags.to, raw: data?.id ?? null }, null, 2) };
 }
 
+// 确认 Bug：依据 禅道APIv1.0.md §2.14.6 POST /bugs/{id}/confirm（body 字段全可选）
+async function cmdBugConfirm(parsed, client, deps, config) {
+  const bugId = parsed.positional[0];
+  if (!bugId) return { stderr: '错误：缺少 bugId', exitCode: 2 };
+  const body = {
+    ...(parsed.flags['assigned-to'] ? { assignedTo: parsed.flags['assigned-to'] } : {}),
+    ...(parsed.flags.type ? { type: parsed.flags.type } : {}),
+    ...(parsed.flags.priority ? { pri: parsed.flags.priority } : {}),
+    ...(parsed.flags.comment ? { comment: parsed.flags.comment } : {}),
+  };
+  const data = await client.request('POST', `/api.php/v1/bugs/${bugId}/confirm`, { body });
+  // best-effort：若改了优先级，同步到本地工作集（confirmed 标志不在列表 shape 内，不更新）
+  if (deps?.cacheDir && deps?.fs && config && parsed.flags.priority) {
+    updateWorkingSetBug(deps.cacheDir, config, bugId, { priority: parsed.flags.priority }, deps.fs);
+  }
+  return { stdout: JSON.stringify({ id: bugId, confirmed: true, raw: data?.id ?? null }, null, 2) };
+}
+
 // ============ 本地 Bug 索引（sync / search） ============
 
 // bug 列表服务端 browseType 合法值（源码 module/bug/model.php getBugs 398-414）
@@ -832,71 +944,62 @@ export const BUG_BROWSE_TYPES = [
 // 缓存过期阈值（ms），默认 1h，可由 ZENTAO_CACHE_STALE_MS 覆盖
 const CACHE_STALE_MS = Number(process.env.ZENTAO_CACHE_STALE_MS) || 3600 * 1000;
 
-// 本地 bug 索引缓存 I/O（注入 fs 便于测试）
-export function cacheFilePath(dir, productId) {
-  return `${dir}/bugs-${productId}.json`;
+// ============ 本地工作集（单文件，绑 url+account） ============
+// 设计：sync 定义工作集（整体替换），list 只在工作集内查，不再跨产品/跨服务器合并。
+// 工作集文件盖 url/account 戳：切服务器/切账号后，旧工作集 url/account 不匹配 → 视为未 sync，
+// 天然隔离，无需主动清理。
+
+// 工作集文件名（整个本地只有一个工作集）
+export function workingSetPath(dir) {
+  return `${dir}/working-set.json`;
 }
 
-export function readBugCache(dir, productId, fs) {
+// 身份戳：工作集归属哪个服务器+账号
+function stampOf(config) {
+  return { url: config.zentaoUrl, account: config.username };
+}
+
+// 读工作集；url/account 与当前配置不匹配 → 返回 null（视为未 sync）。注入 fs 便于测试。
+export function readWorkingSet(dir, config, fs) {
   try {
-    const raw = fs.readFileSync(cacheFilePath(dir, productId), 'utf8');
+    const raw = fs.readFileSync(workingSetPath(dir), 'utf8');
     const obj = JSON.parse(raw);
-    if (obj && Array.isArray(obj.bugs)) return obj;
-    return null; // 结构不符当作无缓存
-  } catch (e) {
-    if (e && e.code === 'ENOENT') return null;
-    return null; // 损坏缓存当作无缓存
+    if (!obj || !Array.isArray(obj.bugs)) return null; // 结构不符当作无工作集
+    if (obj.url !== config.zentaoUrl || obj.account !== config.username) return null; // 跨服务器/账号 → 不可见
+    return obj;
+  } catch {
+    return null; // ENOENT / 损坏都当无工作集
   }
 }
 
-// 原子写：先写 .tmp 再 rename，避免崩溃损坏；目录自动建；权限收紧
-export function writeBugCache(dir, productId, data, fs) {
-  const final = cacheFilePath(dir, productId);
+// 原子写：盖身份戳 + tmp→rename，避免崩溃损坏；目录自动建；权限收紧
+export function writeWorkingSet(dir, config, data, fs) {
+  const final = workingSetPath(dir);
   const tmp = `${final}.tmp`;
+  const stamped = { ...data, ...stampOf(config) }; // 戳最后写，始终反映当前身份
   try { fs.mkdirSync(dir, { recursive: true }); } catch { /* 已存在或不可建 */ }
-  fs.writeFileSync(tmp, JSON.stringify(data), { mode: 0o600 });
+  fs.writeFileSync(tmp, JSON.stringify(stamped), { mode: 0o600 });
   try { if (typeof fs.chmodSync === 'function') fs.chmodSync(tmp, 0o600); } catch { /* Windows no-op */ }
   fs.renameSync(tmp, final);
 }
 
-// 列出已缓存的产品 id（扫描 cacheDir 下 bugs-<id>.json）
-export function listCacheProducts(fs, cacheDir) {
-  let entries = [];
-  try { entries = fs.readdirSync(cacheDir); } catch { return []; }
-  const out = [];
-  for (const name of entries) {
-    const m = name.match(/^bugs-(.+)\.json$/);
-    if (m) out.push(m[1]);
-  }
-  return out;
-}
-
-// best-effort 更新某产品缓存中指定 bug；命中并写入返回 true，否则 false；失败静默
-export function updateCachedBug(cacheDir, productId, bugId, patch, fs) {
+// best-effort：在工作集内就地更新某 bug（写命令 resolve/assign 后），命中并写入返回 true；失败静默
+export function updateWorkingSetBug(cacheDir, config, bugId, patch, fs) {
   try {
-    const cache = readBugCache(cacheDir, productId, fs);
-    if (!cache) return false;
+    const set = readWorkingSet(cacheDir, config, fs);
+    if (!set) return false;
     let hit = false;
-    cache.bugs = cache.bugs.map((b) => {
+    set.bugs = set.bugs.map((b) => {
       if (String(b.id) === String(bugId)) { hit = true; return { ...b, ...patch }; }
       return b;
     });
-    if (hit) writeBugCache(cacheDir, productId, cache, fs);
+    if (hit) writeWorkingSet(cacheDir, config, set, fs);
     return hit;
   } catch {
     return false;
   }
 }
 
-// 扫描所有已缓存产品，更新命中 bug（写命令后 best-effort）
-export function updateCachedBugAnywhere(cacheDir, bugId, patch, fs) {
-  let hit = false;
-  for (const pid of listCacheProducts(fs, cacheDir)) {
-    if (updateCachedBug(cacheDir, pid, bugId, patch, fs)) hit = true;
-  }
-  return hit;
-}
-
 // 输出 browseType 合法值
 function cmdBugBrowseTypes(parsed) {
   const rows = BUG_BROWSE_TYPES;
@@ -908,20 +1011,28 @@ function cmdBugBrowseTypes(parsed) {
   return { stdout: JSON.stringify({ browseTypes: rows.map((r) => r.value) }, null, 2) };
 }
 
-// 一次性同步某产品 bug 到本地索引
+// 一次性同步某产品 bug 到本地【工作集】（整体替换，不再按产品分文件累加）
 async function cmdBugSync(parsed, client, config, { cacheDir, fs }) {
   let productId = parsed.flags.product || config.defaultProject;
+  // 拉一次产品列表：名称前缀解析 + 存在性校验共用，避免重复请求
+  const productList = await client.request('GET', '/api.php/v1/products');
+  const products = productList.products || [];
+  const knownIds = new Set(products.map((p) => String(p.id)));
   // --product 非数字 → 产品名前缀匹配
   if (productId && !/^\d+$/.test(String(productId))) {
-    const data = await client.request('GET', '/api.php/v1/products');
-    const matches = (data.products || []).filter((p) => p.name && String(p.name).startsWith(productId));
+    const matches = products.filter((p) => p.name && String(p.name).startsWith(productId));
     if (!matches.length) {
-      const names = (data.products || []).slice(0, 20).map((p) => p.name).filter(Boolean).join(', ');
+      const names = products.slice(0, 20).map((p) => p.name).filter(Boolean).join(', ');
       throw new ZentaoError('INVALID_PARAMETER', `未找到名前缀匹配 "${productId}" 的产品。已知产品: ${names || '(无)'}`);
     }
     productId = matches[0].id;
   }
   if (!productId) throw new ZentaoError('INVALID_PARAMETER', '未指定 --product 且无 ZENTAO_DEFAULT_PROJECT');
+  // 存在性校验：禅道对不存在的 product id 会【静默回退】到别的产品吐数据，
+  // 不校验就会把 A 产品的请求错当成 B 产品并缓存（曾导致切本地后仍显示老数据）。
+  if (!knownIds.has(String(productId))) {
+    throw new ZentaoError('INVALID_PARAMETER', `产品 ${productId} 在当前服务器不存在。可用产品 ID: ${[...knownIds].slice(0, 20).join(', ') || '(无)'}`);
+  }
   const browseType = parsed.flags.status || 'unclosed'; // sync 的 --status = 服务端 browseType，默认 unclosed
   const limit = 100;
   const all = [];
@@ -932,10 +1043,11 @@ async function cmdBugSync(parsed, client, config, { cacheDir, fs }) {
     if (!data.bugs || data.bugs.length < limit) break; // 不足一页 = 取完
   }
   // --mine：本地按 assignedTo === 当前账号 过滤（可与任意 browseType 叠加）
-  const final = parsed.flags.mine ? all.filter((b) => b.assignedTo === config.username) : all;
-  const cache = { product: String(productId), status: browseType, syncedAt: Date.now(), count: final.length, bugs: final };
-  writeBugCache(cacheDir, productId, cache, fs); // 仅成功后写，失败不破坏旧缓存
-  return { stdout: JSON.stringify({ product: String(productId), status: browseType, syncedAt: cache.syncedAt, count: final.length, cached: final.length }, null, 2) };
+  const mine = !!parsed.flags.mine;
+  const final = mine ? all.filter((b) => b.assignedTo === config.username) : all;
+  const set = { product: String(productId), status: browseType, mine, syncedAt: Date.now(), count: final.length, bugs: final };
+  writeWorkingSet(cacheDir, config, set, fs); // 整体替换工作集（盖 url/account 戳）；仅成功后写，失败不破坏旧工作集
+  return { stdout: JSON.stringify({ product: String(productId), status: browseType, mine, syncedAt: set.syncedAt, count: final.length }, null, 2) };
 }
 
 // 命令分发：根据 parsed 派发到对应 cmd，捕获 ZentaoError 转 exitCode
@@ -951,11 +1063,13 @@ export async function runCommand(parsed, { config, deps }) {
     else if (parsed.command === 'init') res = await cmdInit(parsed, config, deps);
     else if (parsed.command === 'project' && parsed.sub === 'list') res = await cmdProjectList(parsed, client);
     else if (parsed.command === 'product' && parsed.sub === 'list') res = await cmdProductList(parsed, client);
+    else if (parsed.command === 'build' && parsed.sub === 'list') res = await cmdBuildList(parsed, client, config);
     else if (parsed.command === 'bug' && (parsed.sub === 'list' || parsed.sub === 'search')) res = await cmdBugList(parsed, config, deps);
     else if (parsed.command === 'bug' && parsed.sub === 'get') res = await cmdBugGet(parsed, client);
-    else if (parsed.command === 'bug' && parsed.sub === 'create') res = await cmdBugCreate(parsed, client, config.defaultProject);
-    else if (parsed.command === 'bug' && parsed.sub === 'resolve') res = await cmdBugResolve(parsed, client, deps);
-    else if (parsed.command === 'bug' && parsed.sub === 'assign') res = await cmdBugAssign(parsed, client, deps);
+    else if (parsed.command === 'bug' && parsed.sub === 'create') res = await cmdBugCreate(parsed, client, config);
+    else if (parsed.command === 'bug' && parsed.sub === 'resolve') res = await cmdBugResolve(parsed, client, deps, config);
+    else if (parsed.command === 'bug' && parsed.sub === 'assign') res = await cmdBugAssign(parsed, client, deps, config);
+    else if (parsed.command === 'bug' && parsed.sub === 'confirm') res = await cmdBugConfirm(parsed, client, deps, config);
     else if (parsed.command === 'bug' && parsed.sub === 'sync') res = await cmdBugSync(parsed, client, config, deps);
     else if (parsed.command === 'bug' && parsed.sub === 'browse-types') res = cmdBugBrowseTypes(parsed);
     else if (parsed.command === 'ping') res = await cmdPing(parsed, client, config);