i18-fe-automator-beta 2.1.8 → 2.1.10

package/dist/commonjs/index.js

@@ -17,6 +17,8 @@ var xlsx = require('node-xlsx');
 var crypto = require('crypto');
 var querystring = require('querystring');
 var uuid = require('uuid');
+var os = require('os');
+var AdmZip = require('adm-zip');
 var eslint = require('eslint');
 var espree = require('espree');
 var node_module = require('node:module');
@@ -26,7 +28,6 @@ require('shelljs');
 var process$1 = require('child_process');
 var _ = require('lodash');
 var request$1 = require('request-promise');
-require('os');
 require('console');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -107,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() {
@@ -1803,7 +1866,7 @@ async function addSassPermission(cliOpts = {}) {
 
 // 禅道基础地址/缓存键(联调不符只改这里)
 const ZENTAO_BASE = "https://zentao.hongxinshop.com/zentao";
-const CACHE_KEY = "zentao"; // .cache/zentao: { account, password, zentaosid, products: [{id, name}] }
+const CACHE_KEY$1 = "zentao"; // .cache/zentao: { account, password, zentaosid, products: [{id, name}] }
 
 // 需求列表展示与pull并发的上限
 const PLAN_STORY_TABLE_LIMIT = 50;
@@ -1832,12 +1895,12 @@ function ensureCacheDir() {
 // 读取禅道凭据/会话缓存(不存在/损坏返回 {})
 function readZentaoCache() {
   const cacheFilePath =
-    getRunCliPath({ root: true }) + "/.cache/" + CACHE_KEY;
+    getRunCliPath({ root: true }) + "/.cache/" + CACHE_KEY$1;
   if (!isExistPath(cacheFilePath)) {
     return {};
   }
   try {
-    return JSON.parse(readCache(CACHE_KEY).toString("utf8")) || {};
+    return JSON.parse(readCache(CACHE_KEY$1).toString("utf8")) || {};
   } catch (error) {
     return {};
   }
@@ -1847,7 +1910,7 @@ function readZentaoCache() {
 function writeZentaoCache(obj) {
   ensureCacheDir();
   writeCache(
-    CACHE_KEY,
+    CACHE_KEY$1,
     JSON.stringify({ ...readZentaoCache(), ...obj })
   );
 }
@@ -2116,7 +2179,7 @@ function askZentaoCredentials(cliOpts) {
       password: cliOpts.password,
     },
     useCache: Boolean(cliOpts.cache),
-    cacheKey: CACHE_KEY,
+    cacheKey: CACHE_KEY$1,
   }).then((secret) => {
     // resolveSecretQuestions 会整文件覆盖回写缓存(只剩凭据字段, 发生在登录之前),
     // 合并写补回 zentaosid 等字段, 防止登录失败时已缓存的有效会话被抹掉
@@ -2289,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命令与子任务统计用)
@@ -3212,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);
@@ -3236,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("【前端】");
@@ -3260,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})...`);
@@ -3301,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) =>
@@ -3345,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 ? `后端${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(", ");
+                  Number(s.estimate) > 0
+                    ? taskLine("后端", s.estimate, devCount(s), backBaseHours(s), backSubsOf(s))
+                    : "",
+                ].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([
           {
@@ -3466,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";
@@ -3487,6 +3620,7 @@ async function storyMain(action, cliOpts) {
           },
         ]));
       } else {
+        // 交互合并原"创建父任务+拆分子任务"与"仅拆分"为一项: 无父任务自动先建(≤8h仅建父任务), >8h拆分, 已有父任务复用
         ({ taskMode } = await inquirer.prompt([
           {
             message: `将处理 ${picked.length} 条【${typeLabel}】任务(截止 ${pj.project.end}), 请选择模式`,
@@ -3494,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",
           },
         ]));
       }
@@ -3653,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(
@@ -3808,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);
@@ -3879,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("无指派给我的任务, 也无由我完成待关闭的任务, 结束")
@@ -3925,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,
@@ -3989,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 =
@@ -4056,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}个, 详情见上方黄字提示`));
@@ -4181,6 +4350,1209 @@ function registerStoryCommand(program, { markHandled, addHelpExample }) {
   );
 }
 
+// 坚果云 WebDAV 公共模块(其他功能可直接复用)
+// 应用密码需网页端 账户信息->安全选项->添加应用密码 生成, 非登录密码
+const JIANGUOYUN_DAV = "https://dav.jianguoyun.com/dav";
+const CACHE_KEY = "jianguoyun"; // .cache/jianguoyun: { account, appPassword, remoteDir }
+
+// 凭据交互问题(默认值会被缓存覆盖, 输入后回写缓存)
+const JGY_QUESTIONS = [
+  {
+    message: "请输入坚果云账号(邮箱)",
+    name: "account",
+    validate: (v) => (v && v.trim() ? true : "账号不能为空"),
+  },
+  {
+    message: "请输入坚果云应用密码(网页端: 账户信息->安全选项->添加应用密码)",
+    name: "appPassword",
+    type: "password",
+    validate: (v) => (v && v.trim() ? true : "应用密码不能为空"),
+  },
+  {
+    message: "请输入远程目录(坚果云里的文件夹名)",
+    name: "remoteDir",
+    default: "claude-migrate",
+  },
+];
+
+/**
+ * 解析坚果云凭据: CLI参数 > --cache缓存 > 交互(展示缓存默认值), 解析后回写缓存
+ * @param cliValues CLI 参数值 { account, appPassword, remoteDir }
+ * @param useCache  是否静默走缓存(缓存缺失的字段回退交互)
+ */
+function resolveJianguoyunSecret(cliValues = {}, useCache = false) {
+  return resolveSecretQuestions({
+    questions: JGY_QUESTIONS,
+    cliValues,
+    useCache,
+    cacheKey: CACHE_KEY,
+  });
+}
+
+function basicAuth(account, appPassword) {
+  return "Basic " + Buffer.from(`${account}:${appPassword}`).toString("base64");
+}
+
+// 规范化远程目录: 去首尾空白与斜杠
+function normDir(remoteDir) {
+  return String(remoteDir || "").trim().replace(/^\/+|\/+$/g, "");
+}
+
+function remoteUrl(secret, fileName = "") {
+  const parts = [JIANGUOYUN_DAV, normDir(secret.remoteDir)];
+  if (fileName) parts.push(...String(fileName).split("/").map(encodeURIComponent));
+  return parts.filter(Boolean).join("/");
+}
+
+// 从 WebDAV 错误响应体提取可读信息(坚果云错误是 XML, 含 <s:message>)
+async function extractErrorMessage(res) {
+  if (res.status === 401) return "账号或应用密码错误(应用密码需网页端生成, 非登录密码)";
+  let text = "";
+  try {
+    text = await res.text();
+  } catch {
+    /* 忽略 */
+  }
+  const msg = text.match(/<(?:[\w-]+:)?message>([\s\S]*?)<\/(?:[\w-]+:)?message>/i)?.[1]?.trim();
+  return msg || `HTTP ${res.status}`;
+}
+
+// 确保远程目录存在(逐级 MKCOL, 已存在返回 405 忽略)
+async function ensureRemoteDir(secret) {
+  const dir = normDir(secret.remoteDir);
+  if (!dir) return;
+  const auth = basicAuth(secret.account, secret.appPassword);
+  let current = JIANGUOYUN_DAV;
+  for (const seg of dir.split("/")) {
+    current += "/" + encodeURIComponent(seg);
+    const res = await fetch(current, { method: "MKCOL", headers: { Authorization: auth } });
+    // 201=创建成功 405=已存在; 其他视为失败
+    if (res.status !== 201 && res.status !== 405) {
+      throw new Error(`创建远程目录失败: ${await extractErrorMessage(res)}`);
+    }
+  }
+}
+
+/**
+ * 上传文件到坚果云
+ * @param secret  resolveJianguoyunSecret 的结果
+ * @param localFile 本地文件路径
+ * @param fileName  远程文件名(默认取 localFile 的 basename)
+ */
+async function jianguoyunUpload(secret, localFile, fileName) {
+  await ensureRemoteDir(secret);
+  const name = fileName || localFile.split(/[\\/]/).pop();
+  const res = await fetch(remoteUrl(secret, name), {
+    method: "PUT",
+    headers: { Authorization: basicAuth(secret.account, secret.appPassword) },
+    body: fs.readFileSync(localFile),
+  });
+  if (!res.ok) {
+    throw new Error(`上传坚果云失败: ${await extractErrorMessage(res)}`);
+  }
+  return `${normDir(secret.remoteDir)}/${name}`;
+}
+
+// 解析 PROPFIND 响应, 返回目录下文件列表(跳过目录本身)
+function parsePropfind(xml) {
+  const files = [];
+  const respRe = /<(?:[\w-]+:)?response>([\s\S]*?)<\/(?:[\w-]+:)?response>/g;
+  let m;
+  while ((m = respRe.exec(xml))) {
+    const block = m[1];
+    const href =
+      block.match(/<(?:[\w-]+:)?href>([\s\S]*?)<\/(?:[\w-]+:)?href>/)?.[1] || "";
+    if (!href || href.endsWith("/")) continue; // 目录本身
+    const name = decodeURIComponent(href.split("/").filter(Boolean).pop());
+    const size = Number(
+      block.match(/<(?:[\w-]+:)?getcontentlength>([\s\S]*?)</)?.[1] || 0
+    );
+    const mtime =
+      block.match(/<(?:[\w-]+:)?getlastmodified>([\s\S]*?)</)?.[1] || "";
+    files.push({ name, size, mtime });
+  }
+  return files;
+}
+
+/**
+ * 列出坚果云远程目录下的文件(目录不存在返回 [])
+ * @returns [{ name, size, mtime }]
+ */
+async function jianguoyunList(secret) {
+  const dir = normDir(secret.remoteDir);
+  if (!dir) return [];
+  const res = await fetch(remoteUrl(secret), {
+    method: "PROPFIND",
+    headers: {
+      Authorization: basicAuth(secret.account, secret.appPassword),
+      Depth: "1",
+    },
+  });
+  if (res.status === 404) return []; // 目录不存在
+  if (!res.ok) {
+    throw new Error(`读取坚果云目录失败: ${await extractErrorMessage(res)}`);
+  }
+  return parsePropfind(await res.text());
+}
+
+/**
+ * 从坚果云下载文件
+ * @param localPath 下载保存的本地路径
+ */
+async function jianguoyunDownload(secret, fileName, localPath) {
+  const res = await fetch(remoteUrl(secret, fileName), {
+    headers: { Authorization: basicAuth(secret.account, secret.appPassword) },
+  });
+  if (!res.ok) {
+    throw new Error(`下载坚果云文件失败: ${await extractErrorMessage(res)}`);
+  }
+  fs.writeFileSync(localPath, Buffer.from(await res.arrayBuffer()));
+}
+
+// claude 子命令 — Claude Code 数据跨平台迁移(list/export/import)
+// 参照 claude-migrate.sh 重写为 Node 版: zip 归档 + 跨系统路径重映射(POSIX <-> Windows)
+const MIGRATE_VERSION = "1.0.0";
+const ALL_CATEGORIES =
+  "settings,history,plans,projects,plugins,skills,memory";
+const CATEGORY_LIST = ALL_CATEGORIES.split(",");
+
+// 类别 -> 顶层文件(相对 ~/.claude)
+const CATEGORY_FILES = {
+  settings: ["settings.json", "settings.local.json", "keybindings.json"],
+  history: ["history.jsonl"],
+};
+// 类别 -> 整目录拷贝(相对 ~/.claude)
+const CATEGORY_DIRS = {
+  plans: "plans",
+  projects: "projects",
+  skills: "skills",
+};
+// export 交互勾选时默认不勾选的类别(history/projects 体积大且含大量本机路径, 按需勾选)
+const UNCHECKED_BY_DEFAULT = ["history", "projects"];
+// plugins 只迁 2 个清单(插件本体可重装, 不迁)
+const PLUGIN_FILES = ["installed_plugins.json", "known_marketplaces.json"];
+// memory = memory/ 目录 + 全局记忆文件
+const MEMORY_DIR = "memory";
+const MEMORY_FILES = ["CLAUDE.md", "AGENTS.md"];
+
+// ─── 工具函数 ─────────────────────────────────────────────────────────
+
+function log(msg) {
+  console.log(`${chalk.green("=>")} ${msg}`);
+}
+function warn(msg) {
+  console.log(chalk.yellow(`警告: ${msg}`));
+}
+function verbose(msg, enabled) {
+  if (enabled) console.log(`  ${chalk.blue("+")} ${msg}`);
+}
+function die(msg) {
+  console.error(chalk.red(`错误: ${msg}`));
+  process.exit(1);
+}
+
+const pad = (n) => String(n).padStart(2, "0");
+
+// 时间戳 YYYY-MM-DD-HHmmss(年月日时分秒)
+function getTimestamp() {
+  const d = new Date();
+  return (
+    `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` +
+    `-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`
+  );
+}
+
+// 递归收集目录下所有文件(绝对路径)
+function walkFiles(dir) {
+  const out = [];
+  (function rec(d) {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      if (e.isDirectory()) rec(path.join(d, e.name));
+      else out.push(path.join(d, e.name));
+    }
+  })(dir);
+  return out;
+}
+
+function countFiles(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  return walkFiles(dir).length;
+}
+
+// ─── 路径编码与重映射 ──────────────────────────────────────────────────
+
+/**
+ * 跨平台路径编码(Claude Code projects 目录名规则):
+ * / \ : 均替换为 -(统一按正斜杠处理, POSIX 首斜杠替换后自然带前导横杠)
+ * /Users/harry       -> -Users-harry
+ * D:\Users\harry     -> D--Users-harry
+ */
+function encodePath(p) {
+  const norm = String(p).replace(/\\/g, "/").replace(/\/+$/, "");
+  return norm.replace(/[:/]/g, "-");
+}
+
+// projects 子目录名: 把编码后的源 home 前缀替换为目标 home 前缀
+function remapDirname(name, srcHome, dstHome) {
+  const src = encodePath(srcHome);
+  const dst = encodePath(dstHome);
+  if (src === dst || !name.startsWith(src)) return name;
+  return dst + name.slice(src.length);
+}
+
+/**
+ * 文件内容路径重映射, 覆盖 3 种变体(长变体优先, 避免单分隔符替换破坏双转义):
+ * 1. JSON 双反斜杠转义: D:\\Users\\harry
+ * 2. 反斜杠分隔: D:\Users\harry 或 \Users\harry
+ * 3. 正斜杠分隔: /Users/harry 或 D:/Users/harry
+ */
+function remapContent(content, srcHome, dstHome) {
+  if (!srcHome || !dstHome || srcHome === dstHome) return content;
+  const srcPosix = srcHome.replace(/\\/g, "/");
+  const dstPosix = dstHome.replace(/\\/g, "/");
+  const srcWin = srcPosix.replace(/\//g, "\\");
+  const dstWin = dstPosix.replace(/\//g, "\\");
+  const pairs = [
+    [srcWin.replace(/\\/g, "\\\\"), dstWin.replace(/\\/g, "\\\\")],
+    [srcWin, dstWin],
+    [srcPosix, dstPosix],
+  ];
+  for (const [from, to] of pairs) {
+    if (from && from !== to) content = content.split(from).join(to);
+  }
+  return content;
+}
+
+function remapFileContents(file, srcHome, dstHome) {
+  if (srcHome === dstHome) return;
+  const content = fs.readFileSync(file, "utf-8");
+  const newContent = remapContent(content, srcHome, dstHome);
+  if (newContent !== content) {
+    fs.writeFileSync(file, newContent, "utf-8");
+  }
+}
+
+// ─── claude 目录解析 ───────────────────────────────────────────────────
+
+function detectClaudeDir() {
+  return (
+    process.env.CLAUDE_DIR || path.join(os.homedir(), ".claude")
+  );
+}
+
+// 读操作(list/export)用: --claude-dir > 环境变量 > 默认检测; 不存在则交互输入
+async function resolveClaudeDirForRead(options) {
+  if (options.claudeDir) {
+    const p = path.resolve(options.claudeDir);
+    if (!fs.existsSync(p)) die(`claude 目录不存在: ${p}`);
+    return p;
+  }
+  const detected = detectClaudeDir();
+  if (fs.existsSync(detected)) return detected;
+  warn(`未检测到 claude 目录: ${detected}`);
+  const { custom } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "custom",
+      message: "请输入 claude 数据目录路径",
+      validate: (v) => {
+        if (!v.trim()) return "路径不能为空";
+        if (!fs.existsSync(v.trim())) return "目录不存在, 请重新输入";
+        return true;
+      },
+    },
+  ]);
+  return path.resolve(custom.trim());
+}
+
+// import 用: --claude-dir 传了直接用; 否则展示检测路径让用户确认或自定义
+async function resolveClaudeDirForImport(options) {
+  if (options.claudeDir) return path.resolve(options.claudeDir);
+  const detected = detectClaudeDir();
+  const exists = fs.existsSync(detected);
+  const { choice } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "choice",
+      message: "请确认目标 claude 数据目录",
+      choices: [
+        {
+          name: `使用检测到的路径: ${detected}${exists ? "" : chalk.yellow(" (目录不存在, 导入时会创建)")}`,
+          value: detected,
+        },
+        { name: "手动输入自定义路径", value: null },
+      ],
+    },
+  ]);
+  if (choice) return choice;
+  const { custom } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "custom",
+      message: "请输入 claude 数据目录路径",
+      validate: (v) => (v.trim() ? true : "路径不能为空"),
+    },
+  ]);
+  return path.resolve(custom.trim());
+}
+
+// ─── 类别收集(export 暂存) ─────────────────────────────────────────────
+
+function collectCategory(claudeDir, dataDir, cat, isVerbose) {
+  if (CATEGORY_FILES[cat]) {
+    for (const f of CATEGORY_FILES[cat]) {
+      const src = path.join(claudeDir, f);
+      if (fs.existsSync(src)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.copyFileSync(src, path.join(dataDir, f));
+        verbose(f, isVerbose);
+      }
+    }
+  } else if (CATEGORY_DIRS[cat]) {
+    const dir = CATEGORY_DIRS[cat];
+    const src = path.join(claudeDir, dir);
+    if (fs.existsSync(src)) {
+      const dst = path.join(dataDir, cat);
+      fs.mkdirSync(dst, { recursive: true });
+      fs.cpSync(src, dst, { recursive: true });
+      verbose(`${cat}/ (${countFiles(src)} 个文件)`, isVerbose);
+    }
+  } else if (cat === "plugins") {
+    const src = path.join(claudeDir, "plugins");
+    if (fs.existsSync(src)) {
+      fs.mkdirSync(path.join(dataDir, "plugins"), { recursive: true });
+      for (const f of PLUGIN_FILES) {
+        if (fs.existsSync(path.join(src, f))) {
+          fs.copyFileSync(path.join(src, f), path.join(dataDir, "plugins", f));
+          verbose(`plugins/${f}`, isVerbose);
+        }
+      }
+    }
+  } else if (cat === "memory") {
+    const memSrc = path.join(claudeDir, MEMORY_DIR);
+    if (fs.existsSync(memSrc)) {
+      fs.mkdirSync(path.join(dataDir, MEMORY_DIR), { recursive: true });
+      fs.cpSync(memSrc, path.join(dataDir, MEMORY_DIR), { recursive: true });
+      verbose(`memory/ (${countFiles(memSrc)} 个文件)`, isVerbose);
+    }
+    for (const f of MEMORY_FILES) {
+      const src = path.join(claudeDir, f);
+      if (fs.existsSync(src)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.copyFileSync(src, path.join(dataDir, f));
+        verbose(f, isVerbose);
+      }
+    }
+  }
+}
+
+// ─── 本地类别统计(list) ────────────────────────────────────────────────
+
+function scanCategoryLocal(claudeDir, cat) {
+  const exists = (p) => fs.existsSync(path.join(claudeDir, p));
+  switch (cat) {
+    case "settings": {
+      const n = CATEGORY_FILES.settings.filter(exists).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "history": {
+      const p = path.join(claudeDir, "history.jsonl");
+      if (!fs.existsSync(p)) return "未找到";
+      const lines = fs
+        .readFileSync(p, "utf-8")
+        .split("\n")
+        .filter((l) => l.trim()).length;
+      return `${lines} 条`;
+    }
+    case "plans": {
+      const p = path.join(claudeDir, CATEGORY_DIRS[cat]);
+      if (!fs.existsSync(p)) return "未找到";
+      return `${countFiles(p)} 个文件`;
+    }
+    case "projects":
+    case "skills": {
+      const p = path.join(claudeDir, CATEGORY_DIRS[cat]);
+      if (!fs.existsSync(p)) return "未找到";
+      const dirs = fs
+        .readdirSync(p, { withFileTypes: true })
+        .filter((e) => e.isDirectory());
+      const label = cat === "skills" ? "个 skill" : "个项目";
+      return `${dirs.length} ${label}, ${countFiles(p)} 个文件`;
+    }
+    case "plugins": {
+      const p = path.join(claudeDir, "plugins");
+      if (!fs.existsSync(p)) return "未找到";
+      const n = PLUGIN_FILES.filter((f) =>
+        fs.existsSync(path.join(p, f))
+      ).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "memory": {
+      let n = MEMORY_FILES.filter(exists).length;
+      const memDir = path.join(claudeDir, MEMORY_DIR);
+      if (fs.existsSync(memDir)) n += countFiles(memDir);
+      return n ? `${n} 个文件` : "未找到";
+    }
+    default:
+      return "未找到";
+  }
+}
+
+function printCategoryTable(claudeDir, scanFn) {
+  console.log("");
+  for (const cat of CATEGORY_LIST) {
+    const info = scanFn(claudeDir, cat);
+    const isFound = info !== "未找到" && !info.startsWith("0 ");
+    const colored = isFound
+      ? chalk.green(cat.padEnd(10))
+      : chalk.yellow(cat.padEnd(10));
+    console.log(`  ${colored} ${info}`);
+  }
+}
+
+function printDirDetails(dir, title, unit) {
+  if (!fs.existsSync(dir)) return;
+  const dirs = fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isDirectory());
+  if (!dirs.length) return;
+  console.log("");
+  console.log(chalk.bold(`${title}:`));
+  for (const d of dirs) {
+    const n = countFiles(path.join(dir, d.name));
+    console.log(`  ${d.name} (${n} ${unit})`);
+  }
+}
+
+function cmdListLocal(options) {
+  return resolveClaudeDirForRead(options).then((claudeDir) => {
+    console.log(chalk.bold(`本地 Claude 数据:`), claudeDir);
+    printCategoryTable(claudeDir, scanCategoryLocal);
+    printDirDetails(path.join(claudeDir, "projects"), "Projects", "个文件");
+    printDirDetails(path.join(claudeDir, "skills"), "Skills", "个文件");
+  });
+}
+
+// ─── 归档类别统计(list 归档) ───────────────────────────────────────────
+
+// adm-zip 兼容: 旧版 isDirectory() 是方法, 新版是 boolean 属性
+function entryIsDirectory(e) {
+  return typeof e.isDirectory === "function"
+    ? e.isDirectory()
+    : e.isDirectory === true;
+}
+
+// 解析归档: 返回 { zip, root, manifest, relMap }(relMap: 相对 root 的路径 -> entry)
+function readArchive(archive) {
+  if (!fs.existsSync(archive)) die(`归档不存在: ${archive}`);
+  let zip;
+  try {
+    zip = new AdmZip(archive);
+  } catch (error) {
+    die(`读取归档失败: ${error.message}`);
+  }
+  const entries = zip.getEntries();
+  const manifestEntry = entries.find(
+    (e) => !entryIsDirectory(e) && e.entryName.split("/").pop() === "manifest.json"
+  );
+  if (!manifestEntry) die("归档中未找到 manifest.json");
+  const root = manifestEntry.entryName.includes("/")
+    ? manifestEntry.entryName.slice(
+        0,
+        manifestEntry.entryName.lastIndexOf("/")
+      )
+    : "";
+  let manifest;
+  try {
+    manifest = JSON.parse(zip.readAsText(manifestEntry.entryName));
+  } catch (error) {
+    die("manifest.json 解析失败");
+  }
+  const relMap = new Map();
+  for (const e of entries) {
+    if (entryIsDirectory(e)) continue;
+    const rel = root ? e.entryName.slice(root.length + 1) : e.entryName;
+    relMap.set(rel, e);
+  }
+  return { zip, root, manifest, relMap };
+}
+
+function scanCategoryArchive(relMap, zip, cat) {
+  const has = (rel) => relMap.has(rel);
+  switch (cat) {
+    case "settings": {
+      const n = CATEGORY_FILES.settings.filter((f) => has(`data/${f}`)).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "history": {
+      const e = relMap.get("data/history.jsonl");
+      if (!e) return "未找到";
+      const lines = zip
+        .readAsText(e.entryName)
+        .split("\n")
+        .filter((l) => l.trim()).length;
+      return `${lines} 条`;
+    }
+    case "plans":
+    case "skills": {
+      const prefix = `data/${cat}/`;
+      const n = [...relMap.keys()].filter((rel) =>
+        rel.startsWith(prefix)
+      ).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "projects": {
+      const prefix = "data/projects/";
+      const rels = [...relMap.keys()].filter((rel) =>
+        rel.startsWith(prefix)
+      );
+      if (!rels.length) return "未找到";
+      const dirs = new Set(rels.map((rel) => rel.slice(prefix.length).split("/")[0]));
+      return `${dirs.size} 个项目, ${rels.length} 个文件`;
+    }
+    case "plugins": {
+      const n = PLUGIN_FILES.filter((f) => has(`data/plugins/${f}`)).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "memory": {
+      let n = MEMORY_FILES.filter((f) => has(`data/${f}`)).length;
+      n += [...relMap.keys()].filter((rel) =>
+        rel.startsWith(`data/${MEMORY_DIR}/`)
+      ).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    default:
+      return "未找到";
+  }
+}
+
+function cmdListArchive(archive) {
+  const { zip, manifest, relMap } = readArchive(archive);
+  const platformLabel =
+    manifest.platform ? ` [${manifest.platform}]` : "";
+  console.log(chalk.bold(`归档:`), archive);
+  console.log(chalk.bold(`来源:`), `${manifest.hostname || "unknown"} (${manifest.source_home})${platformLabel}`);
+  console.log(chalk.bold(`日期:`), manifest.date || "unknown");
+  printCategoryTable(relMap, (map, cat) =>
+    scanCategoryArchive(map, zip, cat)
+  );
+  // projects / skills 一级列表
+  for (const [cat, title] of [
+    ["projects", "Projects"],
+    ["skills", "Skills"],
+  ]) {
+    const prefix = `data/${cat}/`;
+    const names = new Set(
+      [...relMap.keys()]
+        .filter((rel) => rel.startsWith(prefix))
+        .map((rel) => rel.slice(prefix.length).split("/")[0])
+    );
+    if (!names.size) continue;
+    console.log("");
+    console.log(chalk.bold(`${title}:`));
+    for (const name of names) {
+      const n = [...relMap.keys()].filter(
+        (rel) => rel.startsWith(prefix + name + "/")
+      ).length;
+      console.log(`  ${name} (${n} 个文件)`);
+    }
+  }
+}
+
+// ─── export ───────────────────────────────────────────────────────────
+
+function parseCategories(str) {
+  const cats = String(str || ALL_CATEGORIES)
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  for (const c of cats) {
+    if (!CATEGORY_LIST.includes(c)) {
+      die(`未知类别: ${c} (可选: ${ALL_CATEGORIES})`);
+    }
+  }
+  return cats.length ? cats : CATEGORY_LIST;
+}
+
+// 类别中文说明(勾选列表展示用)
+const CATEGORY_LABELS = {
+  settings: "配置(settings.json等)",
+  history: "输入历史(history.jsonl, 体积大)",
+  plans: "计划(plans/)",
+  projects: "项目会话记录(projects/, 体积大)",
+  plugins: "插件清单(installed_plugins等)",
+  skills: "技能(skills/)",
+  memory: "全局记忆(memory/ + CLAUDE.md)",
+};
+
+/**
+ * export 交互勾选导出类别(「全选」与子项父子联动, 复用 CheckboxAllPrompt)
+ * history/projects 默认不勾选(体积大且含大量本机路径), 其余默认勾选
+ */
+async function selectExportCategories(claudeDir) {
+  // prompt 注册幂等, 与 story.js/upload.js 各自使用前注册
+  inquirer.registerPrompt("checkbox-all", CheckboxAllPrompt);
+  const choices = [
+    {
+      name: "全选",
+      value: SELECT_ALL,
+      short: "全选",
+      // 默认未全勾(history/projects), 与子项联动状态保持一致
+      checked: false,
+    },
+    ...CATEGORY_LIST.map((cat) => ({
+      name: `${cat} — ${CATEGORY_LABELS[cat]} [${scanCategoryLocal(claudeDir, cat)}]`,
+      value: cat,
+      short: cat,
+      checked: !UNCHECKED_BY_DEFAULT.includes(cat),
+    })),
+  ];
+  const { picked } = await inquirer.prompt([
+    {
+      message:
+        "请勾选要导出的类别(空格选择, 回车确认; 「全选」与单个类别联动)",
+      name: "picked",
+      type: "checkbox-all",
+      // 到列表边界停止, 不循环回第一条
+      loop: false,
+      choices,
+    },
+  ]);
+  const cats = picked.filter((v) => v !== SELECT_ALL);
+  if (!cats.length) {
+    warn("未勾选任何类别, 已取消导出");
+    process.exit(0);
+  }
+  return cats;
+}
+
+// 校验并归一化位置参数(local|jianguoyun)
+function normalizeLocation(value, optionName) {
+  if (value === undefined) return null;
+  if (value !== "local" && value !== "jianguoyun") {
+    die(`参数 ${optionName} 的值 "${value}" 不合法, 可选值: local | jianguoyun`);
+  }
+  return value;
+}
+
+// 解析坚果云凭据: CLI参数 > --cache缓存 > 交互(展示缓存默认值), 输入后回写缓存
+function getJianguoyunSecret(options) {
+  return resolveJianguoyunSecret(
+    {
+      account: options.account,
+      appPassword: options.appPassword,
+      remoteDir: options.remoteDir,
+    },
+    Boolean(options.cache)
+  );
+}
+
+// export 选保存位置: --dest 直通(一键), 否则交互选 本地/坚果云
+async function selectExportDest(options) {
+  const dest = normalizeLocation(options.dest, "--dest");
+  if (dest) return dest;
+  const { picked } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "picked",
+      message: "请选择归档保存位置",
+      choices: [
+        { name: "本地(当前目录下 zip 文件)", value: "local" },
+        { name: "坚果云(WebDAV, 账号密码缓存后下次免输)", value: "jianguoyun" },
+      ],
+    },
+  ]);
+  return picked;
+}
+
+async function cmdExport(options) {
+  const claudeDir = await resolveClaudeDirForRead(options);
+  // --categories 传了直通用(一键), 否则交互勾选
+  const cats = options.categories
+    ? parseCategories(options.categories)
+    : await selectExportCategories(claudeDir);
+  // 保存位置: 本地 / 坚果云
+  const dest = await selectExportDest(options);
+  const isVerbose = Boolean(options.verbose);
+  const timestamp = getTimestamp();
+  const dateShort = timestamp.slice(0, 10);
+  const fileName = options.output
+    ? options.output.split(/[\\/]/).pop()
+    : `claude-export-${dateShort}.zip`;
+  const output = dest === "jianguoyun"
+    ? path.join(os.tmpdir(), `claude-export-${timestamp}.zip`) // 坚果云: 先写临时再上传后删除
+    : (options.output || fileName);
+
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), "claude-migrate-"));
+  const stageRoot = path.join(tmpBase, `claude-migrate-${timestamp}`);
+  const dataDir = path.join(stageRoot, "data");
+  fs.mkdirSync(dataDir, { recursive: true });
+
+  log(`导出 Claude 数据: ${claudeDir}`);
+  for (const cat of cats) {
+    collectCategory(claudeDir, dataDir, cat, isVerbose);
+  }
+
+  const manifest = {
+    version: MIGRATE_VERSION,
+    source_home: os.homedir(),
+    hostname: os.hostname(),
+    platform: process.platform,
+    date: timestamp,
+    categories: cats,
+  };
+  fs.writeFileSync(
+    path.join(stageRoot, "manifest.json"),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8"
+  );
+
+  const fileCount = countFiles(dataDir);
+  log(`已暂存 ${fileCount} 个文件`);
+  if (!fileCount) {
+    warn("没有可导出的数据");
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+    process.exit(1);
+  }
+
+  const zip = new AdmZip();
+  // tmpBase 下仅 stageRoot 一个子目录, 整体打入 zip 使根目录为 claude-migrate-<ts>/
+  zip.addLocalFolder(tmpBase, "");
+  zip.writeZip(output);
+  fs.rmSync(tmpBase, { recursive: true, force: true });
+  const size = (fs.statSync(output).size / 1024).toFixed(1);
+
+  if (dest === "jianguoyun") {
+    // 上传坚果云后删除本地临时文件
+    const secret = await getJianguoyunSecret(options);
+    log(`上传坚果云中...`);
+    const remotePath = await jianguoyunUpload(secret, output, fileName);
+    fs.rmSync(output, { force: true });
+    log(`已上传至坚果云: ${remotePath} (${size} KB)`);
+  } else {
+    log(`已创建归档: ${output} (${size} KB)`);
+  }
+}
+
+// ─── import ───────────────────────────────────────────────────────────
+
+// import 选归档来源: --source 直通(一键), 否则交互选 本地/坚果云
+async function selectImportSource(options) {
+  const source = normalizeLocation(options.source, "--source");
+  if (source) return source;
+  const { picked } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "picked",
+      message: "请选择归档来源",
+      choices: [
+        { name: "本地(zip 文件路径)", value: "local" },
+        { name: "坚果云(WebDAV, 列出远程归档选择)", value: "jianguoyun" },
+      ],
+    },
+  ]);
+  return picked;
+}
+
+// 交互输入本地归档路径
+async function askLocalArchivePath() {
+  const { archive } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "archive",
+      message: "请输入归档文件路径",
+      validate: (v) => {
+        if (!v.trim()) return "路径不能为空";
+        if (!fs.existsSync(v.trim())) return "文件不存在, 请重新输入";
+        return true;
+      },
+    },
+  ]);
+  return archive.trim();
+}
+
+// 从坚果云列归档选择并下载; 返回下载后的本地路径
+async function downloadFromJianguoyun(options, savePath) {
+  const secret = await getJianguoyunSecret(options);
+  log("读取坚果云远程目录...");
+  const files = (await jianguoyunList(secret)).filter((f) =>
+    /\.zip$/i.test(f.name)
+  );
+  if (!files.length) {
+    die(`坚果云 ${secret.remoteDir} 目录下没有 zip 归档`);
+  }
+  // 按修改时间倒序, 最新在前
+  files.sort((a, b) => new Date(b.mtime) - new Date(a.mtime));
+  const { picked } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "picked",
+      message: "请选择要导入的归档",
+      choices: files.map((f) => ({
+        name: `${f.name} (${(f.size / 1024).toFixed(1)} KB)`,
+        value: f.name,
+      })),
+    },
+  ]);
+  log(`下载中: ${picked}`);
+  await jianguoyunDownload(secret, picked, savePath);
+  return savePath;
+}
+
+async function cmdImport(archive, options) {
+  const strategy = options.strategy || "overwrite";
+  if (!["overwrite", "merge", "skip"].includes(strategy)) {
+    die(`无效策略: ${strategy} (可选: overwrite, merge, skip)`);
+  }
+  const isVerbose = Boolean(options.verbose);
+  const dryRun = Boolean(options.dryRun);
+
+  // 归档解析: 传了路径直接用; 未传(或 --source)交互选 本地/坚果云
+  let downloadedFile = null;
+  try {
+    if (!archive || options.source) {
+      const source = await selectImportSource(options);
+      if (source === "jianguoyun") {
+        downloadedFile = path.join(
+          os.tmpdir(),
+          `claude-download-${getTimestamp()}.zip`
+        );
+        // die() 的 process.exit 不走 finally, 注册退出钩子兜底清理下载临时文件
+        process.once("exit", () => fs.rmSync(downloadedFile, { force: true }));
+        archive = await downloadFromJianguoyun(options, downloadedFile);
+      } else if (!archive) {
+        archive = await askLocalArchivePath();
+      }
+    }
+    if (!fs.existsSync(archive)) die(`归档不存在: ${archive}`);
+
+    await doImport(archive, options, { strategy, isVerbose, dryRun });
+  } finally {
+    // 坚果云下载的临时文件用后即删
+    if (downloadedFile) fs.rmSync(downloadedFile, { force: true });
+  }
+}
+
+// 实际导入(archive 已是存在的本地文件)
+async function doImport(archive, options, { strategy, isVerbose, dryRun }) {
+  const { zip, manifest, root } = readArchive(archive);
+  const srcHome = manifest.source_home || "";
+  const archiveCategories = manifest.categories || CATEGORY_LIST;
+  const cats = options.categories
+    ? parseCategories(options.categories)
+    : archiveCategories.filter((c) => CATEGORY_LIST.includes(c));
+
+  // 解压到临时目录
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-import-"));
+  // die() 的 process.exit 不走 finally, 注册退出钩子兜底清理解压临时目录
+  process.once("exit", () => fs.rmSync(tmpDir, { recursive: true, force: true }));
+  try {
+    zip.extractAllTo(tmpDir, true);
+    const archiveRoot = root
+      ? path.join(tmpDir, ...root.split("/"))
+      : tmpDir;
+    const dataDir = path.join(archiveRoot, "data");
+    if (!fs.existsSync(dataDir)) die("归档中未找到 data 目录");
+
+    // 目标目录确认(检测 + 确认/自定义)
+    const claudeDir = await resolveClaudeDirForImport(options);
+    const dstHome = path.dirname(path.resolve(claudeDir));
+    const needsRemap = srcHome && srcHome !== dstHome;
+
+    console.log("");
+    console.log(chalk.bold("导入信息:"));
+    console.log(`  来源:     ${manifest.hostname || "unknown"} (${srcHome || "unknown"})${manifest.platform ? ` [${manifest.platform}]` : ""}`);
+    console.log(`  目标:     ${claudeDir}`);
+    console.log(`  日期:     ${manifest.date || "unknown"}`);
+    console.log(`  策略:     ${strategy}`);
+    console.log(`  类别:     ${cats.join(",")}`);
+    if (needsRemap) {
+      console.log(`  ${chalk.yellow("路径重映射")}: ${srcHome} → ${dstHome}`);
+    }
+    console.log("");
+
+    // 路径重映射(projects 目录名 + 文件内容)
+    if (needsRemap) {
+      log("重映射路径...");
+      const projDir = path.join(dataDir, "projects");
+      if (fs.existsSync(projDir)) {
+        for (const name of fs.readdirSync(projDir)) {
+          const newName = remapDirname(name, srcHome, dstHome);
+          if (newName !== name) {
+            fs.renameSync(path.join(projDir, name), path.join(projDir, newName));
+            verbose(`目录重命名: ${name} → ${newName}`, isVerbose || dryRun);
+          }
+        }
+        for (const f of walkFiles(projDir)) {
+          if (f.endsWith(".jsonl")) {
+            remapFileContents(f, srcHome, dstHome);
+            verbose(`内容重映射: ${path.relative(dataDir, f)}`, isVerbose);
+          }
+        }
+      }
+      const historyFile = path.join(dataDir, "history.jsonl");
+      if (fs.existsSync(historyFile)) {
+        remapFileContents(historyFile, srcHome, dstHome);
+        verbose("内容重映射: history.jsonl", isVerbose);
+      }
+      for (const f of PLUGIN_FILES) {
+        const p = path.join(dataDir, "plugins", f);
+        if (fs.existsSync(p)) {
+          remapFileContents(p, srcHome, dstHome);
+          verbose(`内容重映射: plugins/${f}`, isVerbose);
+        }
+      }
+    }
+
+    // 预览模式
+    if (dryRun) {
+      log("预览(dry-run) — 将导入以下内容:");
+      for (const cat of cats) {
+        console.log(`  ${chalk.bold(cat)}:`);
+        dryRunCategory(cat, dataDir);
+      }
+      log("预览结束(未做任何修改)");
+      return;
+    }
+
+    // 备份现有数据
+    if (options.backup !== false && fs.existsSync(claudeDir)) {
+      const backupDir = `${claudeDir}-backup-${getTimestamp()}`;
+      log(`备份 ${claudeDir} → ${backupDir}`);
+      fs.cpSync(claudeDir, backupDir, { recursive: true });
+    }
+
+    // 应用导入
+    fs.mkdirSync(claudeDir, { recursive: true });
+    for (const cat of cats) {
+      importCategory(cat, dataDir, claudeDir, strategy, isVerbose);
+    }
+    log("导入完成!");
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+function dryRunCategory(cat, dataDir) {
+  const listFile = (f) =>
+    fs.existsSync(path.join(dataDir, f)) && console.log(`    ${f}`);
+  const listDir = (d) => {
+    const p = path.join(dataDir, d);
+    if (!fs.existsSync(p)) return;
+    const entries = fs.readdirSync(p);
+    for (const name of entries.slice(0, 20)) {
+      console.log(`    ${d}/${name}${fs.statSync(path.join(p, name)).isDirectory() ? "/" : ""}`);
+    }
+    if (entries.length > 20) console.log(`    ... 共 ${entries.length} 项`);
+  };
+  if (CATEGORY_FILES[cat]) {
+    CATEGORY_FILES[cat].forEach(listFile);
+  } else if (cat === "plugins") {
+    PLUGIN_FILES.forEach((f) => listFile(`plugins/${f}`));
+  } else if (cat === "memory") {
+    MEMORY_FILES.forEach(listFile);
+    listDir(MEMORY_DIR);
+  } else {
+    listDir(cat);
+  }
+}
+
+function importCategory(cat, dataDir, claudeDir, strategy, isVerbose) {
+  if (CATEGORY_FILES[cat]) {
+    importFiles(dataDir, claudeDir, CATEGORY_FILES[cat], strategy, isVerbose);
+  } else if (CATEGORY_DIRS[cat]) {
+    importDir(
+      path.join(dataDir, cat),
+      path.join(claudeDir, cat),
+      strategy,
+      isVerbose
+    );
+  } else if (cat === "plugins") {
+    fs.mkdirSync(path.join(claudeDir, "plugins"), { recursive: true });
+    importFiles(
+      path.join(dataDir, "plugins"),
+      path.join(claudeDir, "plugins"),
+      PLUGIN_FILES,
+      strategy,
+      isVerbose
+    );
+  } else if (cat === "memory") {
+    importFiles(dataDir, claudeDir, MEMORY_FILES, strategy, isVerbose);
+    importDir(
+      path.join(dataDir, MEMORY_DIR),
+      path.join(claudeDir, MEMORY_DIR),
+      strategy,
+      isVerbose
+    );
+  }
+  verbose(`已导入: ${cat}`, isVerbose);
+}
+
+// 单文件按策略导入(json 浅合并 / jsonl 去重合并)
+function importFiles(srcDir, dstDir, files, strategy, isVerbose) {
+  for (const f of files) {
+    const src = path.join(srcDir, f);
+    const dst = path.join(dstDir, f);
+    if (!fs.existsSync(src)) continue;
+    if (fs.existsSync(dst)) {
+      if (strategy === "skip") {
+        verbose(`跳过(已存在): ${f}`, isVerbose);
+        continue;
+      }
+      if (strategy === "merge" && f.endsWith(".json")) {
+        mergeJson(src, dst);
+        verbose(`已合并: ${f}`, isVerbose);
+        continue;
+      }
+      if (strategy === "merge" && f.endsWith(".jsonl")) {
+        importJsonl(src, dst);
+        verbose(`已合并 JSONL: ${f}`, isVerbose);
+        continue;
+      }
+    }
+    fs.mkdirSync(dstDir, { recursive: true });
+    fs.copyFileSync(src, dst);
+    verbose(`已拷贝: ${f}`, isVerbose);
+  }
+}
+
+// 目录按策略导入: overwrite 整目录覆盖; skip/merge 逐文件处理
+function importDir(src, dst, strategy, isVerbose) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dst, { recursive: true });
+  if (strategy === "overwrite") {
+    fs.cpSync(src, dst, { recursive: true });
+    return;
+  }
+  for (const file of walkFiles(src)) {
+    const rel = path.relative(src, file);
+    const dstFile = path.join(dst, rel);
+    if (!fs.existsSync(dstFile)) {
+      fs.mkdirSync(path.dirname(dstFile), { recursive: true });
+      fs.copyFileSync(file, dstFile);
+      verbose(`新增: ${rel}`, isVerbose);
+    } else if (strategy === "skip") {
+      verbose(`跳过(已存在): ${rel}`, isVerbose);
+    } else if (file.endsWith(".jsonl")) {
+      importJsonl(file, dstFile);
+      verbose(`已合并 JSONL: ${rel}`, isVerbose);
+    } else if (file.endsWith(".json")) {
+      mergeJson(file, dstFile);
+      verbose(`已合并 JSON: ${rel}`, isVerbose);
+    } else {
+      fs.copyFileSync(file, dstFile);
+      verbose(`覆盖(非JSON): ${rel}`, isVerbose);
+    }
+  }
+}
+
+// JSONL 按策略导入; merge 时按 timestamp+sessionId 去重(目标优先)
+function importJsonl(src, dst, strategy, isVerbose) {
+  if (!fs.existsSync(dst)) {
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.copyFileSync(src, dst);
+    return;
+  }
+  const lines = [];
+  const seen = new Set();
+  // 先读目标(本机数据优先), 再读来源
+  for (const p of [dst, src]) {
+    const text = fs.readFileSync(p, "utf-8");
+    for (let line of text.split("\n")) {
+      line = line.replace(/\r$/, "");
+      if (!line.trim()) continue;
+      let key = null;
+      try {
+        const obj = JSON.parse(line);
+        key = `${obj.timestamp || ""}|${obj.sessionId || ""}`;
+      } catch {
+        key = null;
+      }
+      if (key) {
+        if (seen.has(key)) continue;
+        seen.add(key);
+      }
+      lines.push(line);
+    }
+  }
+  fs.writeFileSync(dst, lines.join("\n") + "\n", "utf-8");
+}
+
+// JSON 浅合并: 目标(本机)已有的 key 优先, 来源只补缺失
+function mergeJson(src, dst) {
+  try {
+    const srcObj = JSON.parse(fs.readFileSync(src, "utf-8"));
+    const dstObj = JSON.parse(fs.readFileSync(dst, "utf-8"));
+    if (
+      srcObj &&
+      dstObj &&
+      typeof srcObj === "object" &&
+      typeof dstObj === "object" &&
+      !Array.isArray(srcObj) &&
+      !Array.isArray(dstObj)
+    ) {
+      for (const k of Object.keys(srcObj)) {
+        if (!(k in dstObj)) dstObj[k] = srcObj[k];
+      }
+      fs.writeFileSync(dst, JSON.stringify(dstObj, null, 2) + "\n", "utf-8");
+    }
+    // 非对象 JSON: 保持目标不动
+  } catch {
+    // 解析失败: 保持目标不动
+  }
+}
+
+// ─── 命令入口 ─────────────────────────────────────────────────────────
+
+async function runClaudeCommand(action, archive, options) {
+  switch (action) {
+    case "list":
+      return archive
+        ? cmdListArchive(archive)
+        : cmdListLocal(options);
+    case "export":
+      return cmdExport(options);
+    case "import":
+      return cmdImport(archive, options);
+    default:
+      die(`未知操作: ${action} (可选: list, export, import)`);
+  }
+}
+
+function registerClaudeCommand(program, { markHandled, addHelpExample }) {
+  program
+    .command("claude <action> [archive]")
+    .description(
+      "Claude Code 数据迁移: list 查看本地/归档数据 | export 导出zip(本地/坚果云) | import 导入(本地/坚果云, 跨系统路径重映射)"
+    )
+    .option("--categories <cats>", `逗号分隔类别(默认全部): ${ALL_CATEGORIES}`)
+    .option("--output <file>", "export 输出路径(默认 ./claude-export-YYYY-MM-DD.zip)")
+    .option("--dest <dest>", "export 保存位置: local(默认交互选) | jianguoyun")
+    .option("--source <source>", "import 归档来源: local(默认交互选) | jianguoyun")
+    .option("--strategy <mode>", "import 策略: overwrite(默认) | merge | skip")
+    .option("--claude-dir <path>", "指定 claude 数据目录(跳过检测与交互)")
+    .option("--account <mail>", "坚果云账号(邮箱)")
+    .option("--app-password <pwd>", "坚果云应用密码(网页端: 账户信息->安全选项->添加)")
+    .option("--remote-dir <dir>", "坚果云远程目录(默认 claude-migrate)")
+    .option("--cache", "坚果云凭据静默走缓存, 缓存缺失时回退交互")
+    .option("--dry-run", "import 预览, 不写盘")
+    .option("--no-backup", "import 跳过自动备份")
+    .option("--verbose", "显示明细")
+    .action((action, archive, options) => {
+      // 同步置位标记, 防止 index.js 落入默认翻译分支
+      markHandled();
+      runClaudeCommand(action, archive, options).catch((error) => {
+        console.error(chalk.red(error.message || String(error)));
+        process.exit(1);
+      });
+    });
+  addHelpExample("fe-it-beta claude list", "查看本地 Claude 数据概况");
+  addHelpExample("fe-it-beta claude export --verbose", "导出数据(交互选类别与保存位置)");
+  addHelpExample("fe-it-beta claude export --dest jianguoyun --cache", "导出直传坚果云, 凭据走缓存");
+  addHelpExample("fe-it-beta claude import claude-export-2026-09-30.zip --dry-run", "预览导入内容");
+  addHelpExample("fe-it-beta claude import --source jianguoyun --strategy merge --cache", "从坚果云选归档合并导入");
+}
+
 /**
  * @fileoverview 不要单独中文
  * @author ypf
@@ -5646,6 +7018,12 @@ registerStoryCommand(commander.program, {
   addHelpExample: (cmd, desc) => helpExamples.push([cmd, desc]),
 });
 
+let claudeHandled = false;
+registerClaudeCommand(commander.program, {
+  markHandled: () => (claudeHandled = true),
+  addHelpExample: (cmd, desc) => helpExamples.push([cmd, desc]),
+});
+
 commander.program.addHelpText(
   "after",
   "\n" +
@@ -5698,7 +7076,7 @@ const rules = [
     ],
   },
 ];
-if (storyHandled) ; else if (sass) {
+if (claudeHandled) ; else if (storyHandled) ; else if (sass) {
   sassMain(cliOpts).catch((error) => console.error(error));
 } else if (upload) {
   upload$1(cliOpts).catch((error) => console.error(error));