i18-fe-automator-beta 2.1.9 → 2.1.10

package/dist/commonjs/index.js

@@ -108,6 +108,68 @@ class CheckboxAllPrompt extends CheckboxPrompt {
     super.onInverseKey();
     this.syncAllChoice();
   }
+}
+
+/**
+ * 组联动式checkbox prompt：
+ * - 组开关选项标记 groupToggle: '<组名>'，组成员选项标记 group: '<组名>'
+ * - 勾选/取消组开关：该组全部成员同步勾选/取消(可视化联动，而非静默取集合)
+ * - 切换组成员：组内全勾时开关自动点亮，任一取消则开关熄灭
+ * - 未标记 group 的选项为普通选项，不参与任何联动
+ */
+class CheckboxGroupPrompt extends CheckboxPrompt {
+  getGroupToggles() {
+    return this.opt.choices.filter(
+      (choice) =>
+        choice.type !== "separator" && choice.groupToggle && !choice.disabled
+    );
+  }
+
+  getGroupMembers(groupId) {
+    return this.opt.choices.filter(
+      (choice) =>
+        choice.type !== "separator" &&
+        choice.group === groupId &&
+        !choice.disabled
+    );
+  }
+
+  // 根据各组勾选情况同步开关状态(组内全勾才亮)
+  syncGroupToggles() {
+    this.getGroupToggles().forEach((toggle) => {
+      const members = this.getGroupMembers(toggle.groupToggle);
+      if (members.length) {
+        toggle.checked = members.every((item) => item.checked);
+      }
+    });
+  }
+
+  // 覆写toggleChoice: 空格键和数字键选择都会经过这里，统一处理联动
+  toggleChoice(index) {
+    const choice = this.opt.choices.getChoice(index);
+    if (choice && choice.groupToggle) {
+      // 切换组开关：该组成员全部跟随
+      const checked = !choice.checked;
+      choice.checked = checked;
+      this.getGroupMembers(choice.groupToggle).forEach((item) => {
+        item.checked = checked;
+      });
+    } else {
+      super.toggleChoice(index);
+      this.syncGroupToggles();
+    }
+  }
+
+  // 按a全选/按i反选后，同步各组开关状态
+  onAllKey() {
+    super.onAllKey();
+    this.syncGroupToggles();
+  }
+
+  onInverseKey() {
+    super.onInverseKey();
+    this.syncGroupToggles();
+  }
 }
 
 function Loading() {
@@ -2290,15 +2352,46 @@ function fetchProjectStories(zentaosid, projectID) {
 // 拉项目任务列表(全部状态, 不含已删除; 供勾选时统计已建任务数 + 创建前后 diff 拿新任务ID)
 // 注1: 不用禅道 storyWebTasks/storyDevTasks 计数——软删除(回收站)的任务也计入, 数据不准(实测)
 // 注2: pager.recTotal 同样含回收站任务(返回数恒小于 recTotal 属正常), 翻页判定用 pageTotal
-// 注3: 子任务不出现在任务列表(挂在父任务 children 下), 子任务统计须逐任务拉 task-view
-function fetchProjectTasks(zentaosid, projectID) {
-  return zentaoRequest({
+// 注3: 子任务不出现在任务列表(挂在父任务 children 下), 且列表的 children 字段残缺(只带1个子任务, 实测),
+//      子任务统计须按 parent=-1 圈真父任务逐个拉 task-view
+// 注4: 任务超单页时按 pageTotal 循环翻页拉全, 某页失败降级黄字提示不阻塞(该页任务缺计数),
+//      翻页拉全后不再有"计数不全"提醒
+// 注5: 翻页路由格式(实测从任务列表页 pager 的 data-link-creator 提取):
+//      project-task-<ID>-all-0--<recTotal>-<recPerPage>-<页码>;
+//      错误示范: project-task-<ID>-all-<页码> 禅道不认, 静默返回第1页 → 任务重复计数(踩坑实录)
+async function fetchProjectTasks(zentaosid, projectID) {
+  const first = await zentaoRequest({
     route: `project-task-${projectID}-all`,
     zentaosid,
-  }).then((data) => ({
-    tasks: Object.values(data.tasks || {}),
-    pageTotal: Number(data.pager?.pageTotal || 1),
-  }));
+  });
+  const tasks = Object.values(first.tasks || {});
+  const pager = first.pager || {};
+  const pageTotal = Number(pager.pageTotal || 1);
+  for (let page = 2; page <= pageTotal; page += 1) {
+    // ora 的 text 是属性而非方法
+    Loading$1.text = `拉取项目任务中(第${page}/${pageTotal}页)...`;
+    try {
+      const next = await zentaoRequest({
+        route: `project-task-${projectID}-all-0--${pager.recTotal}-${pager.recPerPage}-${page}`,
+        zentaosid,
+      });
+      tasks.push(...Object.values(next.tasks || {}));
+    } catch (e) {
+      // 会话失效上抛, 由 ensureZentaoSession 整体重登重试
+      if (e?.isAuthError) throw e;
+      console.log(
+        chalk.yellow(`第${page}页任务拉取失败, 该页任务缺计数: ${e.message}`)
+      );
+    }
+  }
+  // 按任务ID去重兜底: 翻页路由若再被禅道静默忽略会返回重复数据, 重复计数直接污染前端/后端父任务数
+  const seen = new Set();
+  const unique = tasks.filter((t) => {
+    if (seen.has(t.id)) return false;
+    seen.add(t.id);
+    return true;
+  });
+  return { tasks: unique, pageTotal };
 }
 
 // 拉单个任务详情(含children子任务映射, subtask命令与子任务统计用)
@@ -3213,7 +3306,8 @@ async function storyMain(action, cliOpts) {
       validateChoice(cliOpts.type, ["front", "back"], "--type");
     }
     const session = await ensureZentaoSession(cliOpts);
-    await session.request(async (zentaosid) => {
+    // 具名回调: 交互模式一轮结束后可递归重入, 回到需求勾选列表(计数刷新); 一键模式单轮结束
+    await session.request(async function taskRound(zentaosid) {
       // 项目存在性预校验(不存在的项目ID禅道会返回登录页HTML, 会被误判为会话失效)
       Loading$1.start("校验项目中...");
       const projectMap = await fetchProjectMap(zentaosid);
@@ -3237,22 +3331,14 @@ async function storyMain(action, cliOpts) {
       }
       // 每条需求的前后端已建任务计数(勾选时提示防重复建)
       // 自行从项目任务列表统计(禅道 storyWebTasks/storyDevTasks 会把回收站任务也计入, 实测不准)
-      Loading$1.start("拉取项目任务中...");
+      Loading$1.start("拉取项目任务中(第1页)...");
       const { tasks: projectTasks, pageTotal } = await fetchProjectTasks(
         zentaosid,
         projectID
       );
       Loading$1.succeed(
-        `拉取项目任务成功(${projectTasks.length}条, 需求计数用)`
+        `拉取项目任务成功(${projectTasks.length}条/${pageTotal}页, 需求计数用)`
       );
-      // 任务超单页时计数可能不全(禅道翻页路由不稳定, 只提示不翻页)
-      if (pageTotal > 1) {
-        console.log(
-          chalk.yellow(
-            `项目任务超过单页(${pageTotal}页), 已建计数可能不全`
-          )
-        );
-      }
       // 前端任务判定: type=frontend 或 名称【前端】前缀(修复前的旧数据 type 误传 devel)
       const isFrontTask = (t) =>
         t.type === "frontend" || String(t.name || "").startsWith("【前端】");
@@ -3261,15 +3347,15 @@ async function storyMain(action, cliOpts) {
       const webCount = (s) => tasksOf(s).filter(isFrontTask).length;
       const devCount = (s) =>
         tasksOf(s).filter((t) => t.type === "devel" && !isFrontTask(t)).length;
-      const totalCount = (s) => tasksOf(s).length;
-      // 子任务统计: 子任务不出现在任务列表(挂在父任务children下), 逐个拉详情;
-      // 只拉 工时>8 的主任务(只有这些才可能拆过子任务), 并发限流控制请求量
-      // 注: parent 字段三态(实测): 0=独立任务 | -1=自己是父任务(有子任务) | >0=挂在别人下的子任务
-      // 候选排除子任务即可(parent>0), -1 的父任务必须纳入(它才有children可统计)
+      // 子任务统计: 子任务不出现在任务列表(挂在父任务children下), 逐个拉详情, 并发限流控制请求量
+      // 注1: parent 字段三态(实测): 0=独立任务(无子任务) | -1=自己是父任务(有子任务) | >0=挂在别人下的子任务
+      // 注2: 候选只拉 parent=-1 的真父任务即可——列表里 parent=0 的独立任务不会有 children(实测抽查),
+      //      且列表 children 字段本身残缺(只带1个, 详情才全), 逐父任务拉 task-view 是唯一准确途径;
+      //      此前按 estimate>8 圈候选会漏掉 ≤8h 却手动拆过子任务的父任务, 且请求量大(89个→15个, 6倍提速)
       const subCountMap = new Map(); // 任务ID -> 子任务数
       {
         const candidates = projectTasks.filter(
-          (t) => Number(t.estimate) > 8 && !(Number(t.parent) > 0)
+          (t) => Number(t.parent) === -1
         );
         if (candidates.length) {
           Loading$1.start(`统计子任务 (0/${candidates.length})...`);
@@ -3302,6 +3388,8 @@ async function storyMain(action, cliOpts) {
       }
       // 先勾选需求: 一键(--type直通)自动取候选; 交互则列出项目全部需求
       let picked;
+      // 交互勾了「一键前端」的标志(供后续跳过任务类型询问, 前端已隐含)
+      let frontTodoPicked = false;
       if (cliOpts.type !== undefined) {
         const presetLabel = cliOpts.type === "front" ? "前端" : "后端";
         const hourOfPreset = (s) =>
@@ -3346,85 +3434,129 @@ async function storyMain(action, cliOpts) {
             ? Math.max(...frontTasks.map((t) => Number(t.estimate) || 0))
             : Number(s.webestimate);
         };
+        // 后端子任务计数/基准工时: 与前端同构(父任务=devel类任务, 无父任务用需求estimate)
+        const isBackTask = (t) => t.type === "devel" && !isFrontTask(t);
+        const backSubsOf = (s) =>
+          tasksOf(s)
+            .filter(isBackTask)
+            .reduce(
+              (sum, t) => sum + (subCountMap.get(String(t.id)) || 0),
+              0
+            );
+        const backBaseHours = (s) => {
+          const backTasks = tasksOf(s).filter(isBackTask);
+          return backTasks.length
+            ? Math.max(...backTasks.map((t) => Number(t.estimate) || 0))
+            : Number(s.estimate);
+        };
+        // 一键前端: 批量选中"前端待办"(有前端工时且未建父任务, 或有父任务但子任务未满)
+        const frontTodo = pj.stories.filter((s) => {
+          if (!(Number(s.webestimate) > 0)) return false;
+          if (webCount(s) === 0) return true;
+          return (
+            frontBaseHours(s) > 8 &&
+            frontSubsOf(s) < Math.ceil(frontBaseHours(s) / 8)
+          );
+        });
+        const FRONT_TODO = "__FRONT_TODO__";
+        // 组联动式checkbox: 勾「一键前端」下方待办需求同步点亮/熄灭(可视化联动), 取消个别则开关熄灭
+        inquirer.registerPrompt("checkbox-group", CheckboxGroupPrompt);
         ({ picked } = await inquirer.prompt([
           {
-            message: "请勾选要建任务的需求(空格选择, 回车确认)",
+            message: "请勾选要建任务的需求(空格选择, 回车确认; 「一键前端」联动勾选前端待办)",
             name: "picked",
-            type: "checkbox",
+            type: "checkbox-group",
             // 到列表边界停止, 不循环回第一条
             loop: false,
-            choices: [...pj.stories]
-              .sort((a, b) => {
-                // 待办优先级: 0=前端有工时且未建任务(子任务也必无, 全新建)
-                // 1=前端有任务但子任务未满(待补拆, 基准=父任务实际工时) 2=其余有前端工时 3=无前端工时
-                // 组内按需求ID从小到大
-                const rank = (s) => {
-                  if (!(Number(s.webestimate) > 0)) return 3;
-                  const base = frontBaseHours(s);
-                  if (webCount(s) === 0) return 0;
-                  return base > 8 && frontSubsOf(s) < Math.ceil(base / 8)
-                    ? 1
-                    : 2;
-                };
-                return (
-                  rank(a) - rank(b) ||
-                  Number(a.id) - Number(b.id)
-                );
-              })
-              .map((s, i) => {
-                // 子任务进度(仅前端>8h展示, 后端暂不展示): 已建/应建
-                // 应建 = ceil(基准工时/8), 基准=前端父任务实际工时(无父任务用webestimate)
-                // 未满已建数红色, 满则总数绿色; 任务计数后括号内联
-                const subProgress = (hours, count) => {
-                  const total = Math.ceil(Number(hours) / 8);
-                  return count >= total
-                    ? `(${count}/${chalk.green(total)})`
-                    : `(${chalk.red(count)}/${total})`;
+            choices: [
+              {
+                // 无待办时置灰; groupToggle组开关, 联动所有group:front成员
+                name: `一键前端(${frontTodo.length}条: 未建父任务/子任务未满)`,
+                value: FRONT_TODO,
+                short: "一键前端",
+                groupToggle: "front",
+                disabled: frontTodo.length ? false : "无前端待办",
+              },
+              ...[...pj.stories]
+                .sort((a, b) => {
+                  // 待办优先级: 0=前端有工时且未建任务(子任务也必无, 全新建)
+                  // 1=前端有任务但子任务未满(待补拆, 基准=父任务实际工时) 2=其余有前端工时 3=无前端工时
+                  // 组内按需求ID从小到大
+                  const rank = (s) => {
+                    if (!(Number(s.webestimate) > 0)) return 3;
+                    const base = frontBaseHours(s);
+                    if (webCount(s) === 0) return 0;
+                    return base > 8 && frontSubsOf(s) < Math.ceil(base / 8)
+                      ? 1
+                      : 2;
+                  };
+                  return (
+                    rank(a) - rank(b) ||
+                    Number(a.id) - Number(b.id)
+                  );
+                })
+                .map((s, i) => {
+                // 任务计数(前后端一排, " / "分隔): x个父任务 + 子任务进度(已建/应建)
+                // 子任务进度仅基准工时>8h展示: 应建 = ceil(基准工时/8), 基准=该类父任务实际工时(无父任务用需求该类工时)
+                // 未满应建数红色, 满则绿色; 工时与计数合并为一行(标题行内联), 无该类工时不输出该段
+                const taskLine = (label, hours, count, baseHours, subs) => {
+                  let text = `${label}${hours}h，${count}个父任务`;
+                  if (baseHours > 8) {
+                    const total = Math.ceil(baseHours / 8);
+                    const progress =
+                      subs >= total
+                        ? `${subs}/${chalk.green(total)}`
+                        : `${subs}/${chalk.red(total)}`;
+                    text += `，${progress}子任务`;
+                  }
+                  return text;
                 };
-                const frontSubs = frontSubsOf(s);
-                const base = frontBaseHours(s);
-                // 前端: 任务数(子任务进度); 后端: 任务数(暂不展示子任务)
-                const built = [
+                const countParts = [
                   Number(s.webestimate) > 0
-                    ? `前端${webCount(s)}个${
-                        base > 8 ? subProgress(base, frontSubs) : ""
-                      }`
+                    ? taskLine("前端", s.webestimate, webCount(s), frontBaseHours(s), frontSubsOf(s))
+                    : "",
+                  Number(s.estimate) > 0
+                    ? taskLine("后端", s.estimate, devCount(s), backBaseHours(s), backSubsOf(s))
                     : "",
-                  Number(s.estimate) > 0 ? `后端${devCount(s)}个 任务` : "",
-                ]
-                  .filter(Boolean)
-                  .join("/");
-                // 父任务工时不足提示: 有前端父任务但工时 < 需求前端工时(黄字, 手建父任务漏填/填少)
-                const shortWarn =
-                  webCount(s) > 0 && base < Number(s.webestimate)
-                    ? `, ${chalk.yellow(`父任务${base}h<需求${s.webestimate}h, 不足!`)}`
-                    : "";
-                // 第二行详情(已建/警告): 换行 + 缩进对齐, 与标题行区分
-                const detail = [built ? `已建${built}` : "", shortWarn.slice(2)]
-                  .filter(Boolean)
-                  .join(", ");
+                ].filter(Boolean);
+                // 父任务工时不足提示: 有前端父任务但工时 < 需求前端工时(黄字, 手建父任务漏填/填少), 追加同排末尾
+                const frontBase = frontBaseHours(s);
+                if (webCount(s) > 0 && frontBase < Number(s.webestimate)) {
+                  countParts.push(
+                    chalk.yellow(
+                      `父任务${frontBase}h<需求${s.webestimate}h, 不足!`
+                    )
+                  );
+                }
                 return {
-                  name: `${i + 1}. #${s.id} ${s.title} (前端${
-                    Number(s.webestimate) > 0 ? `${s.webestimate}h` : "-"
-                  } / 后端${
-                    Number(s.estimate) > 0 ? `${s.estimate}h` : "-"
-                  })${detail ? `\n    ${detail}` : ""}`,
+                  name: `${i + 1}. #${s.id} ${s.title} (${countParts.join(" / ")})`,
                   value: s,
-                  // 有工时但从未建过任何任务的需求默认勾选
-                  checked: totalCount(s) === 0,
+                  // 前端待办成员: 受「一键前端」组开关联动勾选/取消
+                  ...(frontTodo.includes(s) ? { group: "front" } : {}),
                 };
               }),
+            ],
           },
         ]));
+        // 勾了「一键前端」: 提交结果按实际勾选的需求算(联动已把待办项点亮, 哨兵值剔除), 类型固定前端
+        if (picked.includes(FRONT_TODO)) {
+          frontTodoPicked = true;
+          picked = picked.filter((v) => v !== FRONT_TODO);
+          console.log(
+            chalk.blue(`一键前端: 已选中 ${picked.length} 条前端待办需求`)
+          );
+        }
       }
       if (!picked.length) {
         console.log(chalk.yellow("未勾选需求, 结束"));
         return;
       }
-      // 再选任务类型: --type 直通(一键场景) > 选完需求后交互询问
+      // 再选任务类型: --type 直通(一键场景) > 一键前端固定前端 > 选完需求后交互询问
       let taskType;
       if (cliOpts.type !== undefined) {
         taskType = cliOpts.type;
+      } else if (frontTodoPicked) {
+        taskType = "front"; // 一键前端已隐含类型
       } else {
         ({ taskType } = await inquirer.prompt([
           {
@@ -3467,7 +3599,7 @@ async function storyMain(action, cliOpts) {
             : t.type === "devel" && !isFrontTask(t)
         );
       // 处理模式(选择即确认): --split-only > --split > 交互列表 > 一键默认
-      // parent=仅创建父任务 | parent-split=创建父任务+拆分子任务 | split=仅拆分(无父任务自动先建)
+      // parent=仅创建父任务 | parent-split=拆分子任务(无父任务自动先建, ≤8h仅建父任务不拆) | split=仅拆分(--split-only专用, >8h才建父任务)
       let taskMode;
       if (cliOpts.splitOnly) {
         taskMode = "split";
@@ -3488,6 +3620,7 @@ async function storyMain(action, cliOpts) {
           },
         ]));
       } else {
+        // 交互合并原"创建父任务+拆分子任务"与"仅拆分"为一项: 无父任务自动先建(≤8h仅建父任务), >8h拆分, 已有父任务复用
         ({ taskMode } = await inquirer.prompt([
           {
             message: `将处理 ${picked.length} 条【${typeLabel}】任务(截止 ${pj.project.end}), 请选择模式`,
@@ -3495,9 +3628,10 @@ async function storyMain(action, cliOpts) {
             type: "list",
             choices: [
               { name: "1. 创建父任务", value: "parent" },
-              { name: "2. 创建父任务+拆分子任务", value: "parent-split" },
-              { name: "3. 拆分子任务(无父任务自动先创建)", value: "split" },
+              { name: "2. 创建子任务(无父任务自动先创建, ≤8h不拆)", value: "parent-split" },
             ],
+            // 默认选中2(创建子任务)
+            default: "parent-split",
           },
         ]));
       }
@@ -3654,7 +3788,22 @@ async function storyMain(action, cliOpts) {
           splitLogs.forEach((line) => console.log(line));
         }
       }
-      // 部分失败以非零退出码收尾, 供自动化流程感知重试
+      // 交互模式: 一轮结束询问是否继续(默认继续), 继续则回到需求勾选列表(任务计数重新拉取)
+      if (cliOpts.type === undefined) {
+        const { goNext } = await inquirer.prompt([
+          {
+            message: "是否继续处理其他需求? (继续回到需求勾选列表)",
+            name: "goNext",
+            type: "confirm",
+            default: true,
+          },
+        ]);
+        if (goNext) {
+          // 递归进入新一轮(会话失效仍由 session.request 兜底重登)
+          return session.request(taskRound);
+        }
+      }
+      // 部分失败以非零退出码收尾(一键模式, 或交互模式选择结束时), 供自动化流程感知重试
       if (failedStories.length) {
         console.log(
           chalk.red(
@@ -3809,7 +3958,8 @@ async function storyMain(action, cliOpts) {
     }
     const projectID = match[1];
     const session = await ensureZentaoSession(cliOpts);
-    await session.request(async (zentaosid) => {
+    // 具名回调: 一轮关闭结束后可递归重入, 回到任务勾选列表(任务状态重新拉取)
+    await session.request(async function closeRound(zentaosid) {
       // 项目存在性预校验(不存在的项目ID禅道会返回登录页HTML, 会被误判为会话失效)
       Loading$1.start("校验项目中...");
       const projectMap = await fetchProjectMap(zentaosid);
@@ -3880,14 +4030,7 @@ async function storyMain(action, cliOpts) {
           )
         );
       }
-      // 项目任务超单页时"由我完成"部分可能漏列(禅道翻页路由不稳定, 只提示不翻页)
-      if (projectAll.pageTotal > 1) {
-        console.log(
-          chalk.yellow(
-            `项目任务超过单页(${projectAll.pageTotal}页), 由我完成待关闭的任务可能漏列`
-          )
-        );
-      }
+      // fetchProjectTasks 已翻页拉全, "由我完成"兜底不再漏列(单页失败时其黄字已提示)
       if (!tasks.length) {
         console.log(
           chalk.yellow("无指派给我的任务, 也无由我完成待关闭的任务, 结束")
@@ -3926,39 +4069,51 @@ async function storyMain(action, cliOpts) {
         Loading$1.succeed("拉取任务详情完成");
       }
       // 勾选要完成的任务(完成后自动关闭; 到列表边界停止, 不循环回第一条)
+      // 顶部「一键关闭」与下方任务联动: 勾上=全选可选任务, 取消任一下方任务则自动熄灭(已关闭项不参与)
+      inquirer.registerPrompt("checkbox-all", CheckboxAllPrompt);
+      const closableCount = tasks.filter((t) => t.status !== "closed").length;
       const { picked } = await inquirer.prompt([
         {
-          message: "请勾选要处理的任务(空格选择, 回车确认; 未完成的先完成后关闭, 已完成的直接关闭, 已关闭的仅展示不可选)",
+          message: "请勾选要处理的任务(空格选择, 回车确认; 未完成的先完成后关闭, 已完成的直接关闭, 已关闭的仅展示不可选, 关闭全部子任务后父任务自动关闭)",
           name: "picked",
-          type: "checkbox",
+          type: "checkbox-all",
           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,
-            };
-          }),
+          choices: [
+            {
+              name: `一键关闭(共${closableCount}个可选任务)`,
+              value: SELECT_ALL,
+              short: "一键关闭",
+            },
+            ...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
+                ? `${t.estimate || 0}h，子任务${closedCount}/${children.length}`
+                : `${t.estimate || 0}h`;
+              return {
+                name: `#${t.id} [${TASK_STATUS_LABELS[t.status] || t.status}] ${t.name} (${childInfo})`,
+                value: t,
+                // 已关闭的仅展示, 不可勾选
+                disabled: t.status === "closed" ? "已关闭" : false,
+              };
+            }),
+          ],
         },
       ]);
-      if (!picked.length) {
+      // 「一键关闭」是哨兵值, 剔除后剩下的即勾选任务(联动勾上时下方已全选, 数组完整)
+      const targets = picked.filter((v) => v !== SELECT_ALL);
+      if (!targets.length) {
         console.log(chalk.yellow("未勾选任务, 结束"));
         return;
       }
       // 写操作确认(关闭属敏感操作, 二次确认防误关)
       const { ok } = await inquirer.prompt([
         {
-          message: `确认处理勾选的 ${picked.length} 个任务? (未完成的先完成后关闭; 有子任务的逐个关闭子任务, 全关后父任务自动关闭)`,
+          message: `确认处理勾选的 ${targets.length} 个任务? (未完成的先完成后关闭; 有子任务的逐个关闭子任务, 全关后父任务自动关闭)`,
           name: "ok",
           type: "confirm",
           default: true,
@@ -3990,8 +4145,8 @@ async function storyMain(action, cliOpts) {
       let failedCount = 0;
       let done = 0;
       const logs = [];
-      Loading$1.start(`处理任务 (0/${picked.length})...`);
-      for (const task of picked) {
+      Loading$1.start(`处理任务 (0/${targets.length})...`);
+      for (const task of targets) {
         try {
           // 详情缺失(预拉阶段失败的)现拉, 防父任务被误判成叶子任务直接 finish
           const detail =
@@ -4057,12 +4212,25 @@ async function storyMain(action, cliOpts) {
         }
         done += 1;
         // ora 的 text 是属性而非方法
-        Loading$1.text = `处理任务 (${done}/${picked.length})...`;
+        Loading$1.text = `处理任务 (${done}/${targets.length})...`;
       }
       Loading$1.succeed(
-        `处理完成: 成功 ${picked.length - failedCount} 条 / 失败 ${failedCount} 条`
+        `处理完成: 成功 ${targets.length - failedCount} 条 / 失败 ${failedCount} 条`
       );
       logs.forEach((line) => console.log(line));
+      // 一轮结束询问是否继续(默认继续), 继续则回到任务勾选列表(任务状态重新拉取)
+      const { goNext } = await inquirer.prompt([
+        {
+          message: "是否继续处理其他任务? (继续回到任务勾选列表)",
+          name: "goNext",
+          type: "confirm",
+          default: true,
+        },
+      ]);
+      if (goNext) {
+        // 递归进入新一轮(会话失效仍由 session.request 兜底重登)
+        return session.request(closeRound);
+      }
       // 部分失败以非零退出码收尾, 供自动化流程感知重试
       if (failedCount) {
         console.log(chalk.red(`失败${failedCount}个, 详情见上方黄字提示`));

package/dist/esm/index.mjs

@@ -86,6 +86,68 @@ class CheckboxAllPrompt extends CheckboxPrompt {
     super.onInverseKey();
     this.syncAllChoice();
   }
+}
+
+/**
+ * 组联动式checkbox prompt：
+ * - 组开关选项标记 groupToggle: '<组名>'，组成员选项标记 group: '<组名>'
+ * - 勾选/取消组开关：该组全部成员同步勾选/取消(可视化联动，而非静默取集合)
+ * - 切换组成员：组内全勾时开关自动点亮，任一取消则开关熄灭
+ * - 未标记 group 的选项为普通选项，不参与任何联动
+ */
+class CheckboxGroupPrompt extends CheckboxPrompt {
+  getGroupToggles() {
+    return this.opt.choices.filter(
+      (choice) =>
+        choice.type !== "separator" && choice.groupToggle && !choice.disabled
+    );
+  }
+
+  getGroupMembers(groupId) {
+    return this.opt.choices.filter(
+      (choice) =>
+        choice.type !== "separator" &&
+        choice.group === groupId &&
+        !choice.disabled
+    );
+  }
+
+  // 根据各组勾选情况同步开关状态(组内全勾才亮)
+  syncGroupToggles() {
+    this.getGroupToggles().forEach((toggle) => {
+      const members = this.getGroupMembers(toggle.groupToggle);
+      if (members.length) {
+        toggle.checked = members.every((item) => item.checked);
+      }
+    });
+  }
+
+  // 覆写toggleChoice: 空格键和数字键选择都会经过这里，统一处理联动
+  toggleChoice(index) {
+    const choice = this.opt.choices.getChoice(index);
+    if (choice && choice.groupToggle) {
+      // 切换组开关：该组成员全部跟随
+      const checked = !choice.checked;
+      choice.checked = checked;
+      this.getGroupMembers(choice.groupToggle).forEach((item) => {
+        item.checked = checked;
+      });
+    } else {
+      super.toggleChoice(index);
+      this.syncGroupToggles();
+    }
+  }
+
+  // 按a全选/按i反选后，同步各组开关状态
+  onAllKey() {
+    super.onAllKey();
+    this.syncGroupToggles();
+  }
+
+  onInverseKey() {
+    super.onInverseKey();
+    this.syncGroupToggles();
+  }
 }
 
 function Loading$1() {
@@ -2268,15 +2330,46 @@ function fetchProjectStories(zentaosid, projectID) {
 // 拉项目任务列表(全部状态, 不含已删除; 供勾选时统计已建任务数 + 创建前后 diff 拿新任务ID)
 // 注1: 不用禅道 storyWebTasks/storyDevTasks 计数——软删除(回收站)的任务也计入, 数据不准(实测)
 // 注2: pager.recTotal 同样含回收站任务(返回数恒小于 recTotal 属正常), 翻页判定用 pageTotal
-// 注3: 子任务不出现在任务列表(挂在父任务 children 下), 子任务统计须逐任务拉 task-view
-function fetchProjectTasks(zentaosid, projectID) {
-  return zentaoRequest({
+// 注3: 子任务不出现在任务列表(挂在父任务 children 下), 且列表的 children 字段残缺(只带1个子任务, 实测),
+//      子任务统计须按 parent=-1 圈真父任务逐个拉 task-view
+// 注4: 任务超单页时按 pageTotal 循环翻页拉全, 某页失败降级黄字提示不阻塞(该页任务缺计数),
+//      翻页拉全后不再有"计数不全"提醒
+// 注5: 翻页路由格式(实测从任务列表页 pager 的 data-link-creator 提取):
+//      project-task-<ID>-all-0--<recTotal>-<recPerPage>-<页码>;
+//      错误示范: project-task-<ID>-all-<页码> 禅道不认, 静默返回第1页 → 任务重复计数(踩坑实录)
+async function fetchProjectTasks(zentaosid, projectID) {
+  const first = await zentaoRequest({
     route: `project-task-${projectID}-all`,
     zentaosid,
-  }).then((data) => ({
-    tasks: Object.values(data.tasks || {}),
-    pageTotal: Number(data.pager?.pageTotal || 1),
-  }));
+  });
+  const tasks = Object.values(first.tasks || {});
+  const pager = first.pager || {};
+  const pageTotal = Number(pager.pageTotal || 1);
+  for (let page = 2; page <= pageTotal; page += 1) {
+    // ora 的 text 是属性而非方法
+    Loading.text = `拉取项目任务中(第${page}/${pageTotal}页)...`;
+    try {
+      const next = await zentaoRequest({
+        route: `project-task-${projectID}-all-0--${pager.recTotal}-${pager.recPerPage}-${page}`,
+        zentaosid,
+      });
+      tasks.push(...Object.values(next.tasks || {}));
+    } catch (e) {
+      // 会话失效上抛, 由 ensureZentaoSession 整体重登重试
+      if (e?.isAuthError) throw e;
+      console.log(
+        chalk.yellow(`第${page}页任务拉取失败, 该页任务缺计数: ${e.message}`)
+      );
+    }
+  }
+  // 按任务ID去重兜底: 翻页路由若再被禅道静默忽略会返回重复数据, 重复计数直接污染前端/后端父任务数
+  const seen = new Set();
+  const unique = tasks.filter((t) => {
+    if (seen.has(t.id)) return false;
+    seen.add(t.id);
+    return true;
+  });
+  return { tasks: unique, pageTotal };
 }
 
 // 拉单个任务详情(含children子任务映射, subtask命令与子任务统计用)
@@ -3191,7 +3284,8 @@ async function storyMain(action, cliOpts) {
       validateChoice(cliOpts.type, ["front", "back"], "--type");
     }
     const session = await ensureZentaoSession(cliOpts);
-    await session.request(async (zentaosid) => {
+    // 具名回调: 交互模式一轮结束后可递归重入, 回到需求勾选列表(计数刷新); 一键模式单轮结束
+    await session.request(async function taskRound(zentaosid) {
       // 项目存在性预校验(不存在的项目ID禅道会返回登录页HTML, 会被误判为会话失效)
       Loading.start("校验项目中...");
       const projectMap = await fetchProjectMap(zentaosid);
@@ -3215,22 +3309,14 @@ async function storyMain(action, cliOpts) {
       }
       // 每条需求的前后端已建任务计数(勾选时提示防重复建)
       // 自行从项目任务列表统计(禅道 storyWebTasks/storyDevTasks 会把回收站任务也计入, 实测不准)
-      Loading.start("拉取项目任务中...");
+      Loading.start("拉取项目任务中(第1页)...");
       const { tasks: projectTasks, pageTotal } = await fetchProjectTasks(
         zentaosid,
         projectID
       );
       Loading.succeed(
-        `拉取项目任务成功(${projectTasks.length}条, 需求计数用)`
+        `拉取项目任务成功(${projectTasks.length}条/${pageTotal}页, 需求计数用)`
       );
-      // 任务超单页时计数可能不全(禅道翻页路由不稳定, 只提示不翻页)
-      if (pageTotal > 1) {
-        console.log(
-          chalk.yellow(
-            `项目任务超过单页(${pageTotal}页), 已建计数可能不全`
-          )
-        );
-      }
       // 前端任务判定: type=frontend 或 名称【前端】前缀(修复前的旧数据 type 误传 devel)
       const isFrontTask = (t) =>
         t.type === "frontend" || String(t.name || "").startsWith("【前端】");
@@ -3239,15 +3325,15 @@ async function storyMain(action, cliOpts) {
       const webCount = (s) => tasksOf(s).filter(isFrontTask).length;
       const devCount = (s) =>
         tasksOf(s).filter((t) => t.type === "devel" && !isFrontTask(t)).length;
-      const totalCount = (s) => tasksOf(s).length;
-      // 子任务统计: 子任务不出现在任务列表(挂在父任务children下), 逐个拉详情;
-      // 只拉 工时>8 的主任务(只有这些才可能拆过子任务), 并发限流控制请求量
-      // 注: parent 字段三态(实测): 0=独立任务 | -1=自己是父任务(有子任务) | >0=挂在别人下的子任务
-      // 候选排除子任务即可(parent>0), -1 的父任务必须纳入(它才有children可统计)
+      // 子任务统计: 子任务不出现在任务列表(挂在父任务children下), 逐个拉详情, 并发限流控制请求量
+      // 注1: parent 字段三态(实测): 0=独立任务(无子任务) | -1=自己是父任务(有子任务) | >0=挂在别人下的子任务
+      // 注2: 候选只拉 parent=-1 的真父任务即可——列表里 parent=0 的独立任务不会有 children(实测抽查),
+      //      且列表 children 字段本身残缺(只带1个, 详情才全), 逐父任务拉 task-view 是唯一准确途径;
+      //      此前按 estimate>8 圈候选会漏掉 ≤8h 却手动拆过子任务的父任务, 且请求量大(89个→15个, 6倍提速)
       const subCountMap = new Map(); // 任务ID -> 子任务数
       {
         const candidates = projectTasks.filter(
-          (t) => Number(t.estimate) > 8 && !(Number(t.parent) > 0)
+          (t) => Number(t.parent) === -1
         );
         if (candidates.length) {
           Loading.start(`统计子任务 (0/${candidates.length})...`);
@@ -3280,6 +3366,8 @@ async function storyMain(action, cliOpts) {
       }
       // 先勾选需求: 一键(--type直通)自动取候选; 交互则列出项目全部需求
       let picked;
+      // 交互勾了「一键前端」的标志(供后续跳过任务类型询问, 前端已隐含)
+      let frontTodoPicked = false;
       if (cliOpts.type !== undefined) {
         const presetLabel = cliOpts.type === "front" ? "前端" : "后端";
         const hourOfPreset = (s) =>
@@ -3324,85 +3412,129 @@ async function storyMain(action, cliOpts) {
             ? Math.max(...frontTasks.map((t) => Number(t.estimate) || 0))
             : Number(s.webestimate);
         };
+        // 后端子任务计数/基准工时: 与前端同构(父任务=devel类任务, 无父任务用需求estimate)
+        const isBackTask = (t) => t.type === "devel" && !isFrontTask(t);
+        const backSubsOf = (s) =>
+          tasksOf(s)
+            .filter(isBackTask)
+            .reduce(
+              (sum, t) => sum + (subCountMap.get(String(t.id)) || 0),
+              0
+            );
+        const backBaseHours = (s) => {
+          const backTasks = tasksOf(s).filter(isBackTask);
+          return backTasks.length
+            ? Math.max(...backTasks.map((t) => Number(t.estimate) || 0))
+            : Number(s.estimate);
+        };
+        // 一键前端: 批量选中"前端待办"(有前端工时且未建父任务, 或有父任务但子任务未满)
+        const frontTodo = pj.stories.filter((s) => {
+          if (!(Number(s.webestimate) > 0)) return false;
+          if (webCount(s) === 0) return true;
+          return (
+            frontBaseHours(s) > 8 &&
+            frontSubsOf(s) < Math.ceil(frontBaseHours(s) / 8)
+          );
+        });
+        const FRONT_TODO = "__FRONT_TODO__";
+        // 组联动式checkbox: 勾「一键前端」下方待办需求同步点亮/熄灭(可视化联动), 取消个别则开关熄灭
+        inquirer.registerPrompt("checkbox-group", CheckboxGroupPrompt);
         ({ picked } = await inquirer.prompt([
           {
-            message: "请勾选要建任务的需求(空格选择, 回车确认)",
+            message: "请勾选要建任务的需求(空格选择, 回车确认; 「一键前端」联动勾选前端待办)",
             name: "picked",
-            type: "checkbox",
+            type: "checkbox-group",
             // 到列表边界停止, 不循环回第一条
             loop: false,
-            choices: [...pj.stories]
-              .sort((a, b) => {
-                // 待办优先级: 0=前端有工时且未建任务(子任务也必无, 全新建)
-                // 1=前端有任务但子任务未满(待补拆, 基准=父任务实际工时) 2=其余有前端工时 3=无前端工时
-                // 组内按需求ID从小到大
-                const rank = (s) => {
-                  if (!(Number(s.webestimate) > 0)) return 3;
-                  const base = frontBaseHours(s);
-                  if (webCount(s) === 0) return 0;
-                  return base > 8 && frontSubsOf(s) < Math.ceil(base / 8)
-                    ? 1
-                    : 2;
-                };
-                return (
-                  rank(a) - rank(b) ||
-                  Number(a.id) - Number(b.id)
-                );
-              })
-              .map((s, i) => {
-                // 子任务进度(仅前端>8h展示, 后端暂不展示): 已建/应建
-                // 应建 = ceil(基准工时/8), 基准=前端父任务实际工时(无父任务用webestimate)
-                // 未满已建数红色, 满则总数绿色; 任务计数后括号内联
-                const subProgress = (hours, count) => {
-                  const total = Math.ceil(Number(hours) / 8);
-                  return count >= total
-                    ? `(${count}/${chalk.green(total)})`
-                    : `(${chalk.red(count)}/${total})`;
+            choices: [
+              {
+                // 无待办时置灰; groupToggle组开关, 联动所有group:front成员
+                name: `一键前端(${frontTodo.length}条: 未建父任务/子任务未满)`,
+                value: FRONT_TODO,
+                short: "一键前端",
+                groupToggle: "front",
+                disabled: frontTodo.length ? false : "无前端待办",
+              },
+              ...[...pj.stories]
+                .sort((a, b) => {
+                  // 待办优先级: 0=前端有工时且未建任务(子任务也必无, 全新建)
+                  // 1=前端有任务但子任务未满(待补拆, 基准=父任务实际工时) 2=其余有前端工时 3=无前端工时
+                  // 组内按需求ID从小到大
+                  const rank = (s) => {
+                    if (!(Number(s.webestimate) > 0)) return 3;
+                    const base = frontBaseHours(s);
+                    if (webCount(s) === 0) return 0;
+                    return base > 8 && frontSubsOf(s) < Math.ceil(base / 8)
+                      ? 1
+                      : 2;
+                  };
+                  return (
+                    rank(a) - rank(b) ||
+                    Number(a.id) - Number(b.id)
+                  );
+                })
+                .map((s, i) => {
+                // 任务计数(前后端一排, " / "分隔): x个父任务 + 子任务进度(已建/应建)
+                // 子任务进度仅基准工时>8h展示: 应建 = ceil(基准工时/8), 基准=该类父任务实际工时(无父任务用需求该类工时)
+                // 未满应建数红色, 满则绿色; 工时与计数合并为一行(标题行内联), 无该类工时不输出该段
+                const taskLine = (label, hours, count, baseHours, subs) => {
+                  let text = `${label}${hours}h，${count}个父任务`;
+                  if (baseHours > 8) {
+                    const total = Math.ceil(baseHours / 8);
+                    const progress =
+                      subs >= total
+                        ? `${subs}/${chalk.green(total)}`
+                        : `${subs}/${chalk.red(total)}`;
+                    text += `，${progress}子任务`;
+                  }
+                  return text;
                 };
-                const frontSubs = frontSubsOf(s);
-                const base = frontBaseHours(s);
-                // 前端: 任务数(子任务进度); 后端: 任务数(暂不展示子任务)
-                const built = [
+                const countParts = [
                   Number(s.webestimate) > 0
-                    ? `前端${webCount(s)}个${
-                        base > 8 ? subProgress(base, frontSubs) : ""
-                      }`
+                    ? taskLine("前端", s.webestimate, webCount(s), frontBaseHours(s), frontSubsOf(s))
+                    : "",
+                  Number(s.estimate) > 0
+                    ? taskLine("后端", s.estimate, devCount(s), backBaseHours(s), backSubsOf(s))
                     : "",
-                  Number(s.estimate) > 0 ? `后端${devCount(s)}个 任务` : "",
-                ]
-                  .filter(Boolean)
-                  .join("/");
-                // 父任务工时不足提示: 有前端父任务但工时 < 需求前端工时(黄字, 手建父任务漏填/填少)
-                const shortWarn =
-                  webCount(s) > 0 && base < Number(s.webestimate)
-                    ? `, ${chalk.yellow(`父任务${base}h<需求${s.webestimate}h, 不足!`)}`
-                    : "";
-                // 第二行详情(已建/警告): 换行 + 缩进对齐, 与标题行区分
-                const detail = [built ? `已建${built}` : "", shortWarn.slice(2)]
-                  .filter(Boolean)
-                  .join(", ");
+                ].filter(Boolean);
+                // 父任务工时不足提示: 有前端父任务但工时 < 需求前端工时(黄字, 手建父任务漏填/填少), 追加同排末尾
+                const frontBase = frontBaseHours(s);
+                if (webCount(s) > 0 && frontBase < Number(s.webestimate)) {
+                  countParts.push(
+                    chalk.yellow(
+                      `父任务${frontBase}h<需求${s.webestimate}h, 不足!`
+                    )
+                  );
+                }
                 return {
-                  name: `${i + 1}. #${s.id} ${s.title} (前端${
-                    Number(s.webestimate) > 0 ? `${s.webestimate}h` : "-"
-                  } / 后端${
-                    Number(s.estimate) > 0 ? `${s.estimate}h` : "-"
-                  })${detail ? `\n    ${detail}` : ""}`,
+                  name: `${i + 1}. #${s.id} ${s.title} (${countParts.join(" / ")})`,
                   value: s,
-                  // 有工时但从未建过任何任务的需求默认勾选
-                  checked: totalCount(s) === 0,
+                  // 前端待办成员: 受「一键前端」组开关联动勾选/取消
+                  ...(frontTodo.includes(s) ? { group: "front" } : {}),
                 };
               }),
+            ],
           },
         ]));
+        // 勾了「一键前端」: 提交结果按实际勾选的需求算(联动已把待办项点亮, 哨兵值剔除), 类型固定前端
+        if (picked.includes(FRONT_TODO)) {
+          frontTodoPicked = true;
+          picked = picked.filter((v) => v !== FRONT_TODO);
+          console.log(
+            chalk.blue(`一键前端: 已选中 ${picked.length} 条前端待办需求`)
+          );
+        }
       }
       if (!picked.length) {
         console.log(chalk.yellow("未勾选需求, 结束"));
         return;
       }
-      // 再选任务类型: --type 直通(一键场景) > 选完需求后交互询问
+      // 再选任务类型: --type 直通(一键场景) > 一键前端固定前端 > 选完需求后交互询问
       let taskType;
       if (cliOpts.type !== undefined) {
         taskType = cliOpts.type;
+      } else if (frontTodoPicked) {
+        taskType = "front"; // 一键前端已隐含类型
       } else {
         ({ taskType } = await inquirer.prompt([
           {
@@ -3445,7 +3577,7 @@ async function storyMain(action, cliOpts) {
             : t.type === "devel" && !isFrontTask(t)
         );
       // 处理模式(选择即确认): --split-only > --split > 交互列表 > 一键默认
-      // parent=仅创建父任务 | parent-split=创建父任务+拆分子任务 | split=仅拆分(无父任务自动先建)
+      // parent=仅创建父任务 | parent-split=拆分子任务(无父任务自动先建, ≤8h仅建父任务不拆) | split=仅拆分(--split-only专用, >8h才建父任务)
       let taskMode;
       if (cliOpts.splitOnly) {
         taskMode = "split";
@@ -3466,6 +3598,7 @@ async function storyMain(action, cliOpts) {
           },
         ]));
       } else {
+        // 交互合并原"创建父任务+拆分子任务"与"仅拆分"为一项: 无父任务自动先建(≤8h仅建父任务), >8h拆分, 已有父任务复用
         ({ taskMode } = await inquirer.prompt([
           {
             message: `将处理 ${picked.length} 条【${typeLabel}】任务(截止 ${pj.project.end}), 请选择模式`,
@@ -3473,9 +3606,10 @@ async function storyMain(action, cliOpts) {
             type: "list",
             choices: [
               { name: "1. 创建父任务", value: "parent" },
-              { name: "2. 创建父任务+拆分子任务", value: "parent-split" },
-              { name: "3. 拆分子任务(无父任务自动先创建)", value: "split" },
+              { name: "2. 创建子任务(无父任务自动先创建, ≤8h不拆)", value: "parent-split" },
             ],
+            // 默认选中2(创建子任务)
+            default: "parent-split",
           },
         ]));
       }
@@ -3632,7 +3766,22 @@ async function storyMain(action, cliOpts) {
           splitLogs.forEach((line) => console.log(line));
         }
       }
-      // 部分失败以非零退出码收尾, 供自动化流程感知重试
+      // 交互模式: 一轮结束询问是否继续(默认继续), 继续则回到需求勾选列表(任务计数重新拉取)
+      if (cliOpts.type === undefined) {
+        const { goNext } = await inquirer.prompt([
+          {
+            message: "是否继续处理其他需求? (继续回到需求勾选列表)",
+            name: "goNext",
+            type: "confirm",
+            default: true,
+          },
+        ]);
+        if (goNext) {
+          // 递归进入新一轮(会话失效仍由 session.request 兜底重登)
+          return session.request(taskRound);
+        }
+      }
+      // 部分失败以非零退出码收尾(一键模式, 或交互模式选择结束时), 供自动化流程感知重试
       if (failedStories.length) {
         console.log(
           chalk.red(
@@ -3787,7 +3936,8 @@ async function storyMain(action, cliOpts) {
     }
     const projectID = match[1];
     const session = await ensureZentaoSession(cliOpts);
-    await session.request(async (zentaosid) => {
+    // 具名回调: 一轮关闭结束后可递归重入, 回到任务勾选列表(任务状态重新拉取)
+    await session.request(async function closeRound(zentaosid) {
       // 项目存在性预校验(不存在的项目ID禅道会返回登录页HTML, 会被误判为会话失效)
       Loading.start("校验项目中...");
       const projectMap = await fetchProjectMap(zentaosid);
@@ -3858,14 +4008,7 @@ async function storyMain(action, cliOpts) {
           )
         );
       }
-      // 项目任务超单页时"由我完成"部分可能漏列(禅道翻页路由不稳定, 只提示不翻页)
-      if (projectAll.pageTotal > 1) {
-        console.log(
-          chalk.yellow(
-            `项目任务超过单页(${projectAll.pageTotal}页), 由我完成待关闭的任务可能漏列`
-          )
-        );
-      }
+      // fetchProjectTasks 已翻页拉全, "由我完成"兜底不再漏列(单页失败时其黄字已提示)
       if (!tasks.length) {
         console.log(
           chalk.yellow("无指派给我的任务, 也无由我完成待关闭的任务, 结束")
@@ -3904,39 +4047,51 @@ async function storyMain(action, cliOpts) {
         Loading.succeed("拉取任务详情完成");
       }
       // 勾选要完成的任务(完成后自动关闭; 到列表边界停止, 不循环回第一条)
+      // 顶部「一键关闭」与下方任务联动: 勾上=全选可选任务, 取消任一下方任务则自动熄灭(已关闭项不参与)
+      inquirer.registerPrompt("checkbox-all", CheckboxAllPrompt);
+      const closableCount = tasks.filter((t) => t.status !== "closed").length;
       const { picked } = await inquirer.prompt([
         {
-          message: "请勾选要处理的任务(空格选择, 回车确认; 未完成的先完成后关闭, 已完成的直接关闭, 已关闭的仅展示不可选)",
+          message: "请勾选要处理的任务(空格选择, 回车确认; 未完成的先完成后关闭, 已完成的直接关闭, 已关闭的仅展示不可选, 关闭全部子任务后父任务自动关闭)",
           name: "picked",
-          type: "checkbox",
+          type: "checkbox-all",
           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,
-            };
-          }),
+          choices: [
+            {
+              name: `一键关闭(共${closableCount}个可选任务)`,
+              value: SELECT_ALL,
+              short: "一键关闭",
+            },
+            ...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
+                ? `${t.estimate || 0}h，子任务${closedCount}/${children.length}`
+                : `${t.estimate || 0}h`;
+              return {
+                name: `#${t.id} [${TASK_STATUS_LABELS[t.status] || t.status}] ${t.name} (${childInfo})`,
+                value: t,
+                // 已关闭的仅展示, 不可勾选
+                disabled: t.status === "closed" ? "已关闭" : false,
+              };
+            }),
+          ],
         },
       ]);
-      if (!picked.length) {
+      // 「一键关闭」是哨兵值, 剔除后剩下的即勾选任务(联动勾上时下方已全选, 数组完整)
+      const targets = picked.filter((v) => v !== SELECT_ALL);
+      if (!targets.length) {
         console.log(chalk.yellow("未勾选任务, 结束"));
         return;
       }
       // 写操作确认(关闭属敏感操作, 二次确认防误关)
       const { ok } = await inquirer.prompt([
         {
-          message: `确认处理勾选的 ${picked.length} 个任务? (未完成的先完成后关闭; 有子任务的逐个关闭子任务, 全关后父任务自动关闭)`,
+          message: `确认处理勾选的 ${targets.length} 个任务? (未完成的先完成后关闭; 有子任务的逐个关闭子任务, 全关后父任务自动关闭)`,
           name: "ok",
           type: "confirm",
           default: true,
@@ -3968,8 +4123,8 @@ async function storyMain(action, cliOpts) {
       let failedCount = 0;
       let done = 0;
       const logs = [];
-      Loading.start(`处理任务 (0/${picked.length})...`);
-      for (const task of picked) {
+      Loading.start(`处理任务 (0/${targets.length})...`);
+      for (const task of targets) {
         try {
           // 详情缺失(预拉阶段失败的)现拉, 防父任务被误判成叶子任务直接 finish
           const detail =
@@ -4035,12 +4190,25 @@ async function storyMain(action, cliOpts) {
         }
         done += 1;
         // ora 的 text 是属性而非方法
-        Loading.text = `处理任务 (${done}/${picked.length})...`;
+        Loading.text = `处理任务 (${done}/${targets.length})...`;
       }
       Loading.succeed(
-        `处理完成: 成功 ${picked.length - failedCount} 条 / 失败 ${failedCount} 条`
+        `处理完成: 成功 ${targets.length - failedCount} 条 / 失败 ${failedCount} 条`
       );
       logs.forEach((line) => console.log(line));
+      // 一轮结束询问是否继续(默认继续), 继续则回到任务勾选列表(任务状态重新拉取)
+      const { goNext } = await inquirer.prompt([
+        {
+          message: "是否继续处理其他任务? (继续回到任务勾选列表)",
+          name: "goNext",
+          type: "confirm",
+          default: true,
+        },
+      ]);
+      if (goNext) {
+        // 递归进入新一轮(会话失效仍由 session.request 兜底重登)
+        return session.request(closeRound);
+      }
       // 部分失败以非零退出码收尾, 供自动化流程感知重试
       if (failedCount) {
         console.log(chalk.red(`失败${failedCount}个, 详情见上方黄字提示`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18-fe-automator-beta",
-  "version": "2.1.9",
+  "version": "2.1.10",
   "description": "i18-fe-automator-beta内测版本,只用于key: ''替换、检测中文规则等",
   "type": "module",
   "bin": {