i18-fe-automator-beta 2.1.4 → 2.1.5

package/dist/commonjs/index.js

@@ -1809,6 +1809,16 @@ const CACHE_KEY = "zentao"; // .cache/zentao: { account, password, zentaosid, pr
 const PLAN_STORY_TABLE_LIMIT = 50;
 const PULL_CONCURRENCY = 5;
 
+// 任务状态中文标签(close 命令展示用)
+const TASK_STATUS_LABELS = {
+  wait: "未开始",
+  doing: "进行中",
+  pause: "已暂停",
+  done: "已完成",
+  closed: "已关闭",
+  cancel: "已取消",
+};
+
 // 确保 .cache 目录存在
 function ensureCacheDir() {
   const cacheDir = getRunCliPath({ root: true }) + "/.cache";
@@ -1934,6 +1944,8 @@ function zentaoRequest({ route, zentaosid, qs }) {
  * - message 校验失败时是对象(如 {estStarted: [『预计开始』不能为空。]}), 统一格式化为文本
  * - form 字段名必须对齐表单真实 name(如 assignedTo[]): 实测传多余字段(mailto/after/hiddenwin)
  *   或 desc 含 HTML 标签时, 会出现"返回保存成功但未落库"或空响应, 只传验证过的最小字段集
+ * - 非JSON响应分类(实测禅道部分写接口成功也返回 JS跳转页而非JSON信封):
+ *   alert脚本=业务拦截(提取文案作真实错误) | 脚本location跳转: 跳登录页=会话失效, 跳其他页(如 task-view-x)=操作成功 | 其余带响应片段报错
  */
 function zentaoPost({ route, zentaosid, form }) {
   return new Promise((resolve, reject) => {
@@ -1953,30 +1965,56 @@ function zentaoPost({ route, zentaosid, form }) {
       (error, _response, body) => {
         if (error) return reject(error);
         const text = String(body).replace(/^\uFEFF/, "");
-        if (/^\s*<html/i.test(text)) {
-          return reject(
-            Object.assign(new Error("禅道会话已失效"), { isAuthError: true })
-          );
+        // 先尝试按JSON信封解析(<html开头的响应跳过解析, 走下方非JSON分类)
+        let envelope = null;
+        if (!/^\s*<html/i.test(text)) {
+          try {
+            envelope = JSON.parse(text);
+          } catch (e) {
+            /* 非JSON, 走下方非JSON分类 */
+          }
         }
-        let envelope;
-        try {
-          envelope = JSON.parse(text);
-        } catch (e) {
+        if (envelope && typeof envelope === "object") {
+          if (envelope.result === "success") {
+            return resolve(envelope);
+          }
+          const message = envelope.message;
+          const detail =
+            typeof message === "string"
+              ? message
+              : Object.values(message || {})
+                  .map((v) => (Array.isArray(v) ? v.join("; ") : String(v)))
+                  .join("; ");
+          return reject(new Error(detail || `禅道接口返回失败: ${JSON.stringify(envelope)}`));
+        }
+        // 非JSON响应分类:
+        // 1) alert脚本: 业务规则拦截(如字段校验失败"本次消耗必须为数字"), 提取alert文案作为真实错误
+        const alertMatch = text.match(/alert\((['"])([\s\S]*?)\1\)/);
+        if (alertMatch) {
+          return reject(new Error(alertMatch[2]));
+        }
+        // 2) 脚本location跳转: 跳登录页=会话失效; 跳其他页(如 task-view-x)=操作成功(旧式 die(js::locate) 成功响应)
+        const locateMatch = text.match(
+          /(?:parent|self|window|top)\.location(?:\.href)?\s*=\s*['"]([^'"]+)['"]/
+        );
+        if (locateMatch) {
+          if (/user-login/.test(locateMatch[1])) {
+            return reject(
+              Object.assign(new Error("禅道会话已失效"), { isAuthError: true })
+            );
+          }
+          return resolve({ result: "success", locate: locateMatch[1] });
+        }
+        // 3) 兜底登录页字样(无脚本跳转的登录页响应, POST响应不含用户数据可安全判定)
+        if (/user-login/.test(text)) {
           return reject(
             Object.assign(new Error("禅道会话已失效"), { isAuthError: true })
           );
         }
-        if (envelope.result === "success") {
-          return resolve(envelope);
-        }
-        const message = envelope.message;
-        const detail =
-          typeof message === "string"
-            ? message
-            : Object.values(message || {})
-                .map((v) => (Array.isArray(v) ? v.join("; ") : String(v)))
-                .join("; ");
-        return reject(new Error(detail || `禅道接口返回失败: ${JSON.stringify(envelope)}`));
+        // 4) 其余异常: 带响应片段便于定位
+        return reject(
+          new Error(`禅道POST响应异常(非JSON): ${text.slice(0, 200)}`)
+        );
       }
     );
   });
@@ -2267,6 +2305,18 @@ function fetchTaskDetail(zentaosid, taskID) {
   );
 }
 
+// 拉项目中指派给登录账号的任务列表(myinvolved页, close命令用)
+// 注: 与任务列表一致, 子任务不出现在列表(挂父任务children下), 父任务需逐个拉详情拿子任务
+function fetchMyInvolvedTasks(zentaosid, projectID) {
+  return zentaoRequest({
+    route: `project-task-${projectID}-myinvolved`,
+    zentaosid,
+  }).then((data) => ({
+    tasks: Object.values(data.tasks || {}),
+    pageTotal: Number(data.pager?.pageTotal || 1),
+  }));
+}
+
 /**
  * 在项目下为需求创建任务(实测协议, 12.3.1): POST task-create-{projectID}-{storyID}.json
  * - estStarted/deadline 必填(缺了返回 fail + 字段错误提示)
@@ -2365,6 +2415,38 @@ function createZentaoSubtasks({ zentaosid, projectID, story, parentTaskID, type,
   });
 }
 
+/**
+ * 完成任务: POST task-finish-{taskID}.json (close 命令用)
+ * - "本次消耗"字段名实测为 currentConsumed(本次增量, 服务端自动累计到总消耗);
+ *   传 consumed 会报 ""本次消耗"必须为数字"(该字段没上送被校验为空)
+ * - 完成人/指派人字段不传: 禅道服务端完成任务时强制置 finishedBy=当前登录人、
+ *   assignedTo='closed'(页面"指派给"列显示 Closed), 传了也会被覆盖, 不如不传
+ * - 完成后状态置 done; 已 done 的无需 finish 直接 close
+ */
+function finishZentaoTask({ zentaosid, taskID, consumed }) {
+  return zentaoPost({
+    route: `task-finish-${taskID}`,
+    zentaosid,
+    form: {
+      currentConsumed: String(Number(consumed) || 0),
+      comment: "",
+      uid: String(Date.now()),
+    },
+  });
+}
+
+// 关闭任务: POST task-close-{taskID}.json, 只传 comment 最小字段集(close 命令用)
+function closeZentaoTask({ zentaosid, taskID }) {
+  return zentaoPost({
+    route: `task-close-${taskID}`,
+    zentaosid,
+    form: {
+      comment: "",
+      uid: String(Date.now()),
+    },
+  });
+}
+
 // 本地时区当天日期(YYYY-MM-DD, 任务estStarted用; toISOString是UTC会差8小时)
 function localToday() {
   const d = new Date();
@@ -2543,6 +2625,11 @@ async function downloadStoryImages({ stories, storyDetails, zentaosid, zentaoDir
     mapping.set(src, ref);
   };
   let index = 0;
+  let imgDone = 0;
+  const failedLogs = [];
+  if (jobs.length) {
+    Loading$1.start(`下载需求图片 (0/${jobs.length})...`);
+  }
   const worker = async () => {
     while (index < jobs.length) {
       const { story, src } = jobs[index];
@@ -2555,15 +2642,25 @@ async function downloadStoryImages({ stories, storyDetails, zentaosid, zentaoDir
         fs.writeFileSync(target, buf);
         setMapping(story.id, src, `images/${fileName}`);
       } catch (e) {
-        console.log(
-          chalk.yellow(`需求 ${story.id} 图片下载失败(${src}): ${e.message}, 该图保留远程链接`)
+        // 失败提示延后到spinner结束统一输出(避免与spinner交错)
+        failedLogs.push(
+          `需求 ${story.id} 图片下载失败(${src}): ${e.message}, 该图保留远程链接`
         );
       }
+      imgDone += 1;
+      // ora 的 text 是属性而非方法
+      Loading$1.text = `下载需求图片 (${imgDone}/${jobs.length})...`;
     }
   };
   await Promise.all(
     Array.from({ length: PULL_CONCURRENCY }, () => worker())
   );
+  if (jobs.length) {
+    Loading$1.succeed(
+      `下载需求图片完成(${jobs.length - failedLogs.length}/${jobs.length})`
+    );
+  }
+  failedLogs.forEach((line) => console.log(chalk.yellow(line)));
   return result;
 }
 
@@ -2959,13 +3056,13 @@ async function exportPlanStories(zentaosid, selected, scope) {
 
 /**
  * story 主入口
- * @param action login | plan | detail | task | subtask
+ * @param action login | plan | detail | task | subtask | close
  * @param cliOpts 合并后的命令参数(name/username/password/cache/export...)
  */
 async function storyMain(action, cliOpts) {
   validateChoice(
     action,
-    ["login", "plan", "detail", "task", "subtask"],
+    ["login", "plan", "detail", "task", "subtask", "close"],
     "story <action>"
   );
   if (action === "login") {
@@ -3090,11 +3187,17 @@ async function storyMain(action, cliOpts) {
       const totalCount = (s) => tasksOf(s).length;
       // 子任务统计: 子任务不出现在任务列表(挂在父任务children下), 逐个拉详情;
       // 只拉 工时>8 的主任务(只有这些才可能拆过子任务), 并发限流控制请求量
+      // 注: parent 字段三态(实测): 0=独立任务 | -1=自己是父任务(有子任务) | >0=挂在别人下的子任务
+      // 候选排除子任务即可(parent>0), -1 的父任务必须纳入(它才有children可统计)
       const subCountMap = new Map(); // 任务ID -> 子任务数
       {
         const candidates = projectTasks.filter(
-          (t) => Number(t.estimate) > 8 && !Number(t.parent)
+          (t) => Number(t.estimate) > 8 && !(Number(t.parent) > 0)
         );
+        if (candidates.length) {
+          Loading$1.start(`统计子任务 (0/${candidates.length})...`);
+        }
+        let subDone = 0;
         let index = 0;
         const worker = async () => {
           while (index < candidates.length) {
@@ -3108,11 +3211,17 @@ async function storyMain(action, cliOpts) {
               if (e?.isAuthError) throw e;
               // 子任务统计失败不阻塞主流程(勾选列表仍可用, 只是少了子任务数)
             }
+            subDone += 1;
+            // ora 的 text 是属性而非方法
+            Loading$1.text = `统计子任务 (${subDone}/${candidates.length})...`;
           }
         };
         await Promise.all(
           Array.from({ length: PULL_CONCURRENCY }, () => worker())
         );
+        if (candidates.length) {
+          Loading$1.succeed("统计子任务完成");
+        }
       }
       // 先勾选需求: 一键(--type直通)自动取候选; 交互则列出项目全部需求
       let picked;
@@ -3273,6 +3382,13 @@ async function storyMain(action, cliOpts) {
       const account = readZentaoCache().account;
       const assigneeOf = (s) =>
         (taskType === "front" ? s.webuser : s.devuser) || account;
+      // 现有父任务(pick中已建该类任务的): 拆分类模式复用, 不重复建
+      const existingParentOf = (s) =>
+        tasksOf(s).find((t) =>
+          taskType === "front"
+            ? isFrontTask(t)
+            : t.type === "devel" && !isFrontTask(t)
+        );
       // 处理模式(选择即确认): --split-only > --split > 交互列表 > 一键默认
       // parent=仅创建父任务 | parent-split=创建父任务+拆分子任务 | split=仅拆分(无父任务自动先建)
       let taskMode;
@@ -3282,6 +3398,18 @@ async function storyMain(action, cliOpts) {
         taskMode = "parent-split";
       } else if (cliOpts.type !== undefined) {
         taskMode = "parent"; // 一键默认仅建父任务
+      } else if (picked.every((s) => existingParentOf(s))) {
+        // 全部已有父任务: 无需再建父任务, 仅展示补拆选项(剩余工时拆满, 部分已拆的补齐)
+        ({ taskMode } = await inquirer.prompt([
+          {
+            message: `将处理 ${picked.length} 条【${typeLabel}】任务(截止 ${pj.project.end}), 请选择模式`,
+            name: "taskMode",
+            type: "list",
+            choices: [
+              { name: "1. 拆分子任务(按剩余工时补满)", value: "split" },
+            ],
+          },
+        ]));
       } else {
         ({ taskMode } = await inquirer.prompt([
           {
@@ -3296,13 +3424,6 @@ async function storyMain(action, cliOpts) {
           },
         ]));
       }
-      // 现有父任务(pick中已建该类任务的): 拆分类模式复用, 不重复建
-      const existingParentOf = (s) =>
-        tasksOf(s).find((t) =>
-          taskType === "front"
-            ? isFrontTask(t)
-            : t.type === "devel" && !isFrontTask(t)
-        );
       // 需创建父任务的需求:
       // parent=全部勾选 | parent-split=无父任务的 | split=无父任务且>8h(仅为拆分而建)
       const toCreate =
@@ -3314,11 +3435,13 @@ async function storyMain(action, cliOpts) {
                 (taskMode === "parent-split" || hourOf(s) > 8)
             );
       // 创建前任务基线(创建后 diff 出新任务ID)
+      Loading$1.start("同步任务基线中...");
       const baseline = new Set(
         (await fetchProjectTasks(zentaosid, projectID)).tasks.map((t) =>
           String(t.id)
         )
       );
+      Loading$1.succeed("任务基线就绪");
       // 逐条创建(串行, 避免并发触发禅道限流)
       let done = 0;
       const failedStories = [];
@@ -3356,9 +3479,11 @@ async function storyMain(action, cliOpts) {
       }
       // 重拉任务列表 diff 出新任务, 输出任务url
       const pickedIDs = new Set(picked.map((s) => String(s.id)));
+      Loading$1.start("刷新任务列表中...");
       const newTasks = (await fetchProjectTasks(zentaosid, projectID)).tasks.filter(
         (t) => !baseline.has(String(t.id)) && pickedIDs.has(String(t.story))
       );
+      Loading$1.succeed(`刷新完成(新任务 ${newTasks.length} 条)`);
       newTasks.forEach((t) =>
         console.log(
           chalk.green(
@@ -3372,70 +3497,85 @@ async function storyMain(action, cliOpts) {
         const newByStory = new Map(
           newTasks.map((t) => [String(t.story), t])
         );
-        for (const s of picked) {
-          if (!(hourOf(s) > 8)) continue; // <=8h 无可拆, 跳过
-          const created = newByStory.get(String(s.id));
-          const parent = created || existingParentOf(s);
-          if (!parent) continue; // 创建失败等场景
-          // 截止日期须晚于今天(禅道校验 截止>开始, 旧任务截止已过期的跳过)
-          const deadline = parent.deadline || pj.project.end;
-          if (String(deadline) <= localToday()) {
-            console.log(
-              chalk.yellow(
-                `任务 #${parent.id} ${parent.name} 截止日期 ${deadline} 不晚于今天, 跳过拆分(需先调整父任务截止日期)`
-              )
-            );
-            continue;
-          }
-          // 剩余工时: 新建父任务=全部工时; 已有父任务=工时-已有子任务和(拉详情算)
-          let remaining = hourOf(s);
-          if (!created) {
-            const detail = await fetchTaskDetail(zentaosid, parent.id);
-            const childHours = Object.values(detail?.children || {}).reduce(
-              (sum, c) => sum + Number(c.estimate || 0),
-              0
-            );
-            remaining = Number(parent.estimate) - childHours;
-          }
-          if (!(remaining > 8)) {
-            console.log(
-              chalk.yellow(
-                `任务 #${parent.id} ${parent.name} 剩余工时 ${remaining}h 未超过 8h, 跳过拆分`
-              )
-            );
-            continue;
-          }
-          const subs = splitTaskPlan(parent.name, remaining, taskType);
+        // 拆分候选(仅>8h); 执行期间只显示spinner进度, 结果收集到splitLogs结束后统一输出
+        const splitCandidates = picked.filter((s) => hourOf(s) > 8);
+        const splitLogs = [];
+        let splitDone = 0;
+        if (splitCandidates.length) {
+          Loading$1.start(`拆分子任务 (0/${splitCandidates.length})...`);
+        }
+        for (const s of splitCandidates) {
+          let parent = null;
           try {
-            await createZentaoSubtasks({
-              zentaosid,
-              projectID,
-              story: s,
-              parentTaskID: parent.id,
-              type: taskType === "front" ? "frontend" : "devel",
-              assignedTo: parent.assignedTo,
-              estStarted: localToday(),
-              // 截止日期跟随父任务(新建父任务即为项目结束日期)
-              deadline: parent.deadline || pj.project.end,
-              subs,
-            });
-            console.log(
-              chalk.green(
-                `子任务 ${subs.length} 个已创建(父任务 #${parent.id}): ${subs
-                  .map((sub) => `${sub.name}(${sub.estimate}h)`)
-                  .join(", ")}`
-              )
-            );
+            const created = newByStory.get(String(s.id));
+            parent = created || existingParentOf(s);
+            if (!parent) {
+              // 创建失败等场景, 无父任务可挂, 跳过
+            } else if (String(parent.deadline || pj.project.end) <= localToday()) {
+              // 截止日期须晚于今天(禅道校验 截止>开始, 旧任务截止已过期的跳过)
+              splitLogs.push(
+                chalk.yellow(
+                  `任务 #${parent.id} ${parent.name} 截止日期 ${parent.deadline || pj.project.end} 不晚于今天, 跳过拆分(需先调整父任务截止日期)`
+                )
+              );
+            } else {
+              // 剩余工时: 新建父任务=全部工时; 已有父任务=工时-已有子任务和(拉详情算)
+              let remaining = hourOf(s);
+              if (!created) {
+                const detail = await fetchTaskDetail(zentaosid, parent.id);
+                const childHours = Object.values(detail?.children || {}).reduce(
+                  (sum, c) => sum + Number(c.estimate || 0),
+                  0
+                );
+                remaining = Number(parent.estimate) - childHours;
+              }
+              if (!(remaining > 8)) {
+                splitLogs.push(
+                  chalk.yellow(
+                    `任务 #${parent.id} ${parent.name} 剩余工时 ${remaining}h 未超过 8h, 跳过拆分`
+                  )
+                );
+              } else {
+                const subs = splitTaskPlan(parent.name, remaining, taskType);
+                await createZentaoSubtasks({
+                  zentaosid,
+                  projectID,
+                  story: s,
+                  parentTaskID: parent.id,
+                  type: taskType === "front" ? "frontend" : "devel",
+                  assignedTo: parent.assignedTo,
+                  estStarted: localToday(),
+                  // 截止日期跟随父任务(新建父任务即为项目结束日期)
+                  deadline: parent.deadline || pj.project.end,
+                  subs,
+                });
+                splitLogs.push(
+                  chalk.green(
+                    `子任务 ${subs.length} 个已创建(父任务 #${parent.id}): ${subs
+                      .map((sub) => `${sub.name}(${sub.estimate}h)`)
+                      .join(", ")}`
+                  )
+                );
+              }
+            }
           } catch (e) {
             // 会话失效上抛, 由 ensureZentaoSession 整体重登重试
             if (e?.isAuthError) throw e;
-            console.log(
+            splitLogs.push(
               chalk.yellow(
-                `任务 ${parent.id} 子任务创建失败: ${e.message || String(e)}`
+                `任务 #${parent?.id || s.id} 子任务创建失败: ${e.message || String(e)}`
               )
             );
+          } finally {
+            splitDone += 1;
+            // ora 的 text 是属性而非方法
+            Loading$1.text = `拆分子任务 (${splitDone}/${splitCandidates.length})...`;
           }
         }
+        if (splitCandidates.length) {
+          Loading$1.succeed("拆分子任务完成");
+          splitLogs.forEach((line) => console.log(line));
+        }
       }
       // 部分失败以非零退出码收尾, 供自动化流程感知重试
       if (failedStories.length) {
@@ -3504,9 +3644,36 @@ async function storyMain(action, cliOpts) {
         );
         return;
       }
+      // 截止日期须晚于预计开始(今天): 父任务截止已过期时禅道会校验失败, 交互输入子任务新截止日期
+      let deadline = parent.deadline;
+      if (String(deadline) <= localToday()) {
+        console.log(
+          chalk.yellow(
+            `父任务截止日期 ${deadline} 已不晚于今天, 子任务截止日期需重新指定`
+          )
+        );
+        const after7 = new Date();
+        after7.setDate(after7.getDate() + 7);
+        const defaultDeadline = `${after7.getFullYear()}-${String(
+          after7.getMonth() + 1
+        ).padStart(2, "0")}-${String(after7.getDate()).padStart(2, "0")}`;
+        ({ deadline } = await inquirer.prompt([
+          {
+            message: "请输入子任务截止日期(YYYY-MM-DD)",
+            name: "deadline",
+            type: "input",
+            default: defaultDeadline,
+            validate: (val) =>
+              (/^\d{4}-\d{2}-\d{2}$/.test(String(val).trim()) &&
+                String(val).trim() > localToday()) ||
+              "请输入晚于今天的日期, 格式 YYYY-MM-DD",
+          },
+        ]));
+        deadline = String(deadline).trim();
+      }
       // 拆分方案(按剩余工时, 名称对齐父任务名)
       const subs = splitTaskPlan(parent.name, remainHours, taskType);
-      console.log(chalk.bold(`\n拆分方案(${subs.length} 个子任务, 共${remainHours}h):`));
+      console.log(chalk.bold(`\n拆分方案(${subs.length} 个子任务, 共${remainHours}h, 截止 ${deadline}):`));
       subs.forEach((sub) =>
         console.log(`  ${sub.name} (${sub.estimate}h) -> ${parent.assignedTo}`)
       );
@@ -3525,6 +3692,7 @@ async function storyMain(action, cliOpts) {
           return;
         }
       }
+      Loading$1.start("创建子任务中...");
       await createZentaoSubtasks({
         zentaosid,
         projectID: parent.project,
@@ -3533,9 +3701,10 @@ async function storyMain(action, cliOpts) {
         type: parent.type,
         assignedTo: parent.assignedTo,
         estStarted: localToday(),
-        deadline: parent.deadline,
+        deadline,
         subs,
       });
+      Loading$1.succeed(`子任务 ${subs.length} 个创建成功`);
       console.log(
         chalk.green(
           `子任务 ${subs.length} 个已创建(父任务 #${parent.id}): ${subs
@@ -3547,6 +3716,284 @@ async function storyMain(action, cliOpts) {
     });
     return;
   }
+  if (action === "close") {
+    // 入参 = 项目ID(完整url/相对路径/纯ID), 如 project-task-2915-myinvolved.html 里的 2915
+    const input = String(cliOpts.name || "").trim();
+    const match =
+      input.match(/project-task-(\d+)/) ||
+      (/^\d+$/.test(input) ? [input, input] : null);
+    if (!match) {
+      console.log(
+        chalk.red(
+          "请传入项目ID(从禅道任务列表url复制), 如: fe-it-beta story close 2915 或 fe-it-beta story close https://zentao.hongxinshop.com/zentao/project-task-2915-myinvolved.html"
+        )
+      );
+      process.exit(1);
+    }
+    const projectID = match[1];
+    const session = await ensureZentaoSession(cliOpts);
+    await session.request(async (zentaosid) => {
+      // 项目存在性预校验(不存在的项目ID禅道会返回登录页HTML, 会被误判为会话失效)
+      Loading$1.start("校验项目中...");
+      const projectMap = await fetchProjectMap(zentaosid);
+      if (!projectMap[projectID]) {
+        Loading$1.fail("项目不存在");
+        throw new Error(`项目ID ${projectID} 不存在, 请检查后重试`);
+      }
+      Loading$1.succeed(`项目: #${projectID} ${projectMap[projectID]}`);
+      const account = readZentaoCache().account;
+      // 任务来源(两路取并集):
+      // 1) myinvolved: 指派给登录账号的任务(完成的主入口)
+      // 2) 项目任务列表中"由我完成未关闭"的——完成任务后禅道把指派转回创建人, 会从
+      //    myinvolved消失, 但仍需关闭, 须从项目任务列表按 finishedBy 兜回来
+      Loading$1.start("拉取我的任务中...");
+      const involved = await fetchMyInvolvedTasks(zentaosid, projectID);
+      // 项目任务列表(由我完成的任务兜底来源); 失败降级不阻塞(少一路来源), 提示延后到spinner结束统一输出
+      Loading$1.text = "拉取项目任务列表中...";
+      let projectAll = { tasks: [], pageTotal: 1 };
+      let projectAllError = null;
+      try {
+        projectAll = await fetchProjectTasks(zentaosid, projectID);
+      } catch (e) {
+        // 会话失效上抛, 由 ensureZentaoSession 整体重登重试; 其余降级不阻塞(少一路来源)
+        if (e?.isAuthError) throw e;
+        projectAllError = e;
+      }
+      const seen = new Set();
+      const tasks = [];
+      // 指派给我的(过滤已关闭/已取消)
+      involved.tasks
+        .filter(
+          (t) =>
+            t.assignedTo === account && !["closed", "cancel"].includes(t.status)
+        )
+        .forEach((t) => {
+          if (!seen.has(String(t.id))) {
+            seen.add(String(t.id));
+            tasks.push(t);
+          }
+        });
+      // 由我完成的(完成后禅道把指派置'closed'离开myinvolved, 统一从项目任务列表按 finishedBy 兜回):
+      // 已完成待关闭的可勾选关闭; 已关闭的也进列表仅展示(不可选)
+      projectAll.tasks
+        .filter((t) => t.finishedBy === account && t.status !== "cancel")
+        .forEach((t) => {
+          if (!seen.has(String(t.id))) {
+            seen.add(String(t.id));
+            tasks.push(t);
+          }
+        });
+      // 已完成待关闭的排最前(优先处理), 未完成的其后, 已关闭的最后(仅展示不可选), 组内按任务ID升序
+      const statusRank = (t) =>
+        t.status === "done" ? 0 : t.status === "closed" ? 2 : 1;
+      tasks.sort(
+        (a, b) => statusRank(a) - statusRank(b) || Number(a.id) - Number(b.id)
+      );
+      const donePending = tasks.filter((t) => t.status === "done").length;
+      const closedShown = tasks.filter((t) => t.status === "closed").length;
+      Loading$1.succeed(
+        `拉取成功(未完成 ${tasks.length - donePending - closedShown} 条, 待关闭 ${donePending} 条${
+          closedShown ? `, 已关闭 ${closedShown} 条(仅展示)` : ""
+        })`
+      );
+      if (projectAllError) {
+        console.log(
+          chalk.yellow(
+            `项目任务列表拉取失败, 由我完成的任务将不显示: ${projectAllError.message || String(projectAllError)}`
+          )
+        );
+      }
+      // 项目任务超单页时"由我完成"部分可能漏列(禅道翻页路由不稳定, 只提示不翻页)
+      if (projectAll.pageTotal > 1) {
+        console.log(
+          chalk.yellow(
+            `项目任务超过单页(${projectAll.pageTotal}页), 由我完成待关闭的任务可能漏列`
+          )
+        );
+      }
+      if (!tasks.length) {
+        console.log(
+          chalk.yellow("无指派给我的任务, 也无由我完成待关闭的任务, 结束")
+        );
+        return;
+      }
+      // 逐任务拉详情拿子任务(父任务的子任务不出现在任务列表, 展示与关闭都用)
+      const details = new Map(); // 任务ID -> 任务详情
+      const detailTargets = tasks.filter((t) => t.status !== "closed");
+      if (detailTargets.length) {
+        Loading$1.start(`拉取任务详情 (0/${detailTargets.length})...`);
+      }
+      let detailDone = 0;
+      let index = 0;
+      const detailWorker = async () => {
+        while (index < tasks.length) {
+          const t = tasks[index];
+          index += 1;
+          // 已关闭的仅展示不可选, 不参与处理, 跳过详情拉取省请求
+          if (t.status === "closed") continue;
+          try {
+            details.set(String(t.id), await fetchTaskDetail(zentaosid, t.id));
+          } catch (e) {
+            if (e?.isAuthError) throw e;
+            // 详情拉取失败不阻塞(该项关闭时再拉, 展示少了子任务数而已)
+          }
+          detailDone += 1;
+          // ora 的 text 是属性而非方法
+          Loading$1.text = `拉取任务详情 (${detailDone}/${detailTargets.length})...`;
+        }
+      };
+      await Promise.all(
+        Array.from({ length: PULL_CONCURRENCY }, () => detailWorker())
+      );
+      if (detailTargets.length) {
+        Loading$1.succeed("拉取任务详情完成");
+      }
+      // 勾选要完成的任务(完成后自动关闭; 到列表边界停止, 不循环回第一条)
+      const { picked } = await inquirer.prompt([
+        {
+          message: "请勾选要处理的任务(空格选择, 回车确认; 未完成的先完成后关闭, 已完成的直接关闭, 已关闭的仅展示不可选)",
+          name: "picked",
+          type: "checkbox",
+          loop: false,
+          choices: tasks.map((t) => {
+            const detail = details.get(String(t.id));
+            const children = Object.values(detail?.children || {});
+            const closedCount = children.filter(
+              (c) => c.status === "closed"
+            ).length;
+            // 第二行详情(子任务进度): 换行 + 缩进对齐, 与标题行区分
+            const childInfo = children.length
+              ? `\n    子任务${children.length}个(已关${closedCount}), 关闭全部子任务后父任务自动关闭`
+              : "";
+            return {
+              name: `#${t.id} [${TASK_STATUS_LABELS[t.status] || t.status}] ${t.name} (${t.estimate || 0}h)${childInfo}`,
+              value: t,
+              // 已关闭的仅展示, 不可勾选
+              disabled: t.status === "closed" ? "已关闭" : false,
+            };
+          }),
+        },
+      ]);
+      if (!picked.length) {
+        console.log(chalk.yellow("未勾选任务, 结束"));
+        return;
+      }
+      // 写操作确认(关闭属敏感操作, 二次确认防误关)
+      const { ok } = await inquirer.prompt([
+        {
+          message: `确认处理勾选的 ${picked.length} 个任务? (未完成的先完成后关闭; 有子任务的逐个关闭子任务, 全关后父任务自动关闭)`,
+          name: "ok",
+          type: "confirm",
+          default: true,
+        },
+      ]);
+      if (!ok) {
+        console.log(chalk.yellow("已取消"));
+        return;
+      }
+      // 单任务完成并关闭(叶子任务): 已 done 直接关, 否则先 finish 再 close
+      // 结果进 logs(执行期间只显示spinner进度, 结束后统一输出, 避免与spinner交错)
+      const finishAndClose = async (task, logs) => {
+        if (task.status === "done") {
+          await closeZentaoTask({ zentaosid, taskID: task.id });
+          logs.push(
+            chalk.green(`任务 #${task.id} ${task.name} 已关闭(原状态已完成)`)
+          );
+          return;
+        }
+        // 本次消耗取任务预估(currentConsumed 为增量, 服务端自动累计总消耗)
+        await finishZentaoTask({
+          zentaosid,
+          taskID: task.id,
+          consumed: task.estimate,
+        });
+        await closeZentaoTask({ zentaosid, taskID: task.id });
+        logs.push(chalk.green(`任务 #${task.id} ${task.name} 已完成并关闭`));
+      };
+      let failedCount = 0;
+      let done = 0;
+      const logs = [];
+      Loading$1.start(`处理任务 (0/${picked.length})...`);
+      for (const task of picked) {
+        try {
+          // 详情缺失(预拉阶段失败的)现拉, 防父任务被误判成叶子任务直接 finish
+          const detail =
+            details.get(String(task.id)) ||
+            (await fetchTaskDetail(zentaosid, task.id));
+          const children = Object.values(detail?.children || {});
+          if (children.length) {
+            // 父任务: 逐个完成并关闭子任务, 全关后禅道自动关闭父任务
+            for (const child of children) {
+              if (child.status === "closed") {
+                logs.push(
+                  chalk.yellow(
+                    `  子任务 #${child.id} ${child.name} 已是关闭状态, 跳过`
+                  )
+                );
+                continue;
+              }
+              if (child.status === "done") {
+                await closeZentaoTask({ zentaosid, taskID: child.id });
+                logs.push(
+                  chalk.green(
+                    `  子任务 #${child.id} ${child.name} 已关闭(原状态已完成)`
+                  )
+                );
+              } else {
+                await finishZentaoTask({
+                  zentaosid,
+                  taskID: child.id,
+                  consumed: child.estimate,
+                });
+                await closeZentaoTask({ zentaosid, taskID: child.id });
+                logs.push(
+                  chalk.green(`  子任务 #${child.id} ${child.name} 已完成并关闭`)
+                );
+              }
+            }
+            // 核验父任务最终状态(子任务全关后禅道自动关父任务)
+            const after = await fetchTaskDetail(zentaosid, task.id);
+            if (after?.status === "closed") {
+              logs.push(
+                chalk.green(
+                  `父任务 #${task.id} ${task.name} 已自动关闭(子任务全部关闭)`
+                )
+              );
+            } else {
+              logs.push(
+                chalk.yellow(
+                  `父任务 #${task.id} ${task.name} 状态 ${after?.status || "?"}, 未自动关闭, 请到禅道手动处理: ${taskUrl(task.id)}`
+                )
+              );
+            }
+          } else {
+            // 叶子任务: 直接完成并关闭
+            await finishAndClose(task, logs);
+          }
+        } catch (e) {
+          // 会话失效上抛, 由 ensureZentaoSession 整体重登重试
+          if (e?.isAuthError) throw e;
+          failedCount += 1;
+          logs.push(
+            chalk.yellow(`任务 #${task.id} ${task.name} 处理失败: ${e.message || String(e)}`)
+          );
+        }
+        done += 1;
+        // ora 的 text 是属性而非方法
+        Loading$1.text = `处理任务 (${done}/${picked.length})...`;
+      }
+      Loading$1.succeed(
+        `处理完成: 成功 ${picked.length - failedCount} 条 / 失败 ${failedCount} 条`
+      );
+      logs.forEach((line) => console.log(line));
+      // 部分失败以非零退出码收尾, 供自动化流程感知重试
+      if (failedCount) {
+        console.log(chalk.red(`失败${failedCount}个, 详情见上方黄字提示`));
+        process.exit(1);
+      }
+    });
+    return;
+  }
   // plan: 产品选择 -> 计划选取 -> 展示 -> 导出(--export直通一键场景, 不传则收尾交互)
   const session = await ensureZentaoSession(cliOpts);
   await session.request(async (zentaosid) => {
@@ -3589,7 +4036,7 @@ function registerStoryCommand(program, { markHandled, addHelpExample }) {
   program
     .command("story <action> [name]")
     .description(
-      "禅道需求: login 登录 | plan 选计划看需求列表并可导出(按计划生成需求目录+工作区) | detail 看需求详情 | task 勾选项目需求在线建任务 | subtask 给已建任务单独拆子任务"
+      "禅道需求: login 登录 | plan 选计划看需求列表并可导出(按计划生成需求目录+工作区) | detail 看需求详情 | task 勾选项目需求在线建任务 | subtask 给已建任务单独拆子任务 | close 完成并关闭指派给我的任务"
     )
     // 子命令的 option 独立于 program 级: story login --cache 中 --cache 出现在子命令位, 须在子命令上重复注册
     .option("--username <name>", "禅道账号(story命令用)")
@@ -3621,6 +4068,10 @@ function registerStoryCommand(program, { markHandled, addHelpExample }) {
     "一键创建前端任务并自动拆分子任务"
   );
   addHelpExample("fe-it-beta story subtask 父任务ID", "给已建任务单独拆子任务(按剩余工时)");
+  addHelpExample(
+    "fe-it-beta story close 2915",
+    "完成并关闭项目中指派给我的任务(子任务全关父任务自动关闭)"
+  );
   addHelpExample(
     "fe-it-beta story plan --product 87 --export front --cache",
     "一键导出前端需求并生成多项目工作区"