docs(plan): v0.2 adds Pi subagents and scheduled-jobs board

Co-Authored-By: Claude Fable 5.1 <[email protected]>

apps/server/src/modules/file-manager/common.ts

@@ -122,7 +122,7 @@ export function fsErrorToFiles(e: unknown): FilesError | null {
   const msg = e instanceof Error ? e.message : String(e);
   if (OFFLINE_CODES.has(code)) return new FilesError("root_unavailable", `读取失败(${code}),根可能已离线: ${msg}`);
   if (code === "ENOENT" || code === "ENOTDIR") return new FilesError("not_found", `路径已不存在(${code})`);
-  if (code === "EACCES" || code === "EPERM") return new FilesError("forbidden", `无权限访问(${code})`);
+  if (code === "EACCES" || code === "EPERM") return new FilesError("forbidden", `没有访问权限(${code})`);
   return new FilesError("bad_request", `文件系统错误(${code}): ${msg}`);
 }
 
@@ -233,7 +233,7 @@ export async function probeRoot(def: RootDef, timeoutMs: number): Promise<RootHe
 export async function onlineRoot(d: FmDeps, def: RootDef): Promise<string> {
   const h = await probeRoot(def, d.options.healthTimeoutMs);
   if (h.health !== "healthy" || !h.real)
-    throw new FilesError("root_unavailable", `根 ${def.name} 不可用(${h.reason ?? h.health}),不显示为空目录`);
+    throw new FilesError("root_unavailable", `根 ${def.name} 不可用(${h.reason ?? h.health})`);
   return h.real;
 }
 
@@ -288,7 +288,7 @@ export async function resolveIn(
     if (isOfflineErr(e)) throw new FilesError("root_unavailable", `根 ${def.name} 读取失败(${errnoOf(e)})`);
     throw new FilesError("not_found", `父目录不存在: ${dirname(rel) || "/"}`);
   }
-  if (!within(parentReal, rootReal)) throw new FilesError("path_escape", `路径经符号链接逃出根: ${rel}`);
+  if (!within(parentReal, rootReal)) throw new FilesError("path_escape", `路径经符号链接指向根外: ${rel}`);
   const abs = join(parentReal, basename(joined));
   let lst: Awaited<ReturnType<typeof lstat>> | null = null;
   try {
@@ -302,7 +302,7 @@ export async function resolveIn(
   if (isSymlink) {
     const target = await realpath(abs).catch(() => null);
     if (!target || !within(target, rootReal))
-      throw new FilesError("path_escape", `符号链接指向根外或无法解析,已禁用操作: ${rel}`);
+      throw new FilesError("path_escape", `符号链接指向根外或无法解析,不能操作: ${rel}`);
   }
   return { def, rootReal, rel: relOf(rootReal, abs), abs, lst, isSymlink };
 }
@@ -316,7 +316,7 @@ export async function recheck(abs: string, rootReal: string): Promise<string> {
     if (isOfflineErr(e)) throw new FilesError("root_unavailable", `读取失败(${errnoOf(e)})`);
     throw new FilesError("plan_stale", `源已不存在: ${abs}`);
   }
-  if (!within(r, rootReal)) throw new FilesError("path_escape", `执行时发现路径逃出根(符号链接被替换?): ${abs}`);
+  if (!within(r, rootReal)) throw new FilesError("path_escape", `执行时路径指向根外: ${abs}`);
   return r;
 }
 

apps/server/src/modules/file-manager/download.ts

@@ -43,13 +43,12 @@ export async function downloadFile(
 ): Promise<Response> {
   // 路由中间件已按 auth:"session" 拦截;这里同口径复核(纵深防御)
   if (!isAdminSession(principal))
-    throw new FilesError("forbidden", "下载只允许控制台管理员会话(API Key / DEV key 不可用)");
+    throw new FilesError("forbidden", "下载仅限控制台管理员会话,API Key / DEV key 不可用");
   const r = await resolveIn(d, q.root, q.path);
   if (r.rel === "" || r.lst?.isDirectory()) throw new FilesError("bad_request", "只能下载文件,不能下载目录");
   const name = basename(r.abs);
   const kind = kindOfName(name);
-  if (!ALLOWED.has(kind))
-    throw new FilesError("forbidden", `只允许下载 NFO/字幕/图片(${kind}),视频等大文件不经浏览器下载`);
+  if (!ALLOWED.has(kind)) throw new FilesError("forbidden", `只能下载 NFO、字幕和图片,此文件类型为 ${kind}`);
   const real = await recheck(r.abs, r.rootReal);
   const file = await Deno.open(real, { read: true });
   let size: number;

apps/server/src/modules/file-manager/identify.ts

@@ -156,7 +156,7 @@ export async function identify(
     if (remoteQueries >= REMOTE_QUERY_MAX) {
       res = {
         list: [],
-        warning: `本次识别的远端查询已达上限 ${REMOTE_QUERY_MAX} 个,该项仅本地召回;可缩小范围后再识别`,
+        warning: `远端查询已达上限 ${REMOTE_QUERY_MAX} 次,此项只查了本地。缩小范围后重新识别`,
       };
       remoteCache.set(key, res);
       return res;
@@ -193,7 +193,7 @@ export async function identify(
         }));
       res = { list, warning: null };
     } catch (e) {
-      res = { list: [], warning: `远端候选不可用(仅本地召回):${errMessage(e).slice(0, 200)}` };
+      res = { list: [], warning: `远端查询失败,只查了本地:${errMessage(e).slice(0, 200)}` };
     }
     remoteCache.set(key, res);
     return res;

apps/server/src/modules/file-manager/ledger.ts

@@ -44,13 +44,12 @@ export async function loadPlan<C>(d: FmDeps, planId: string, op: string, request
     .select(["id", "content", "content_hash", "expires_at", "title", "kind"])
     .where("id", "=", planId)
     .executeTakeFirst();
-  if (row?.kind !== "plan" || row.title !== "files_plan")
-    throw new FilesError("plan_stale", "planId 不存在,请重新预览");
+  if (row?.kind !== "plan" || row.title !== "files_plan") throw new FilesError("plan_stale", "planId 不存在,重新预览");
   const content = row.content as StoredPlan<C>["content"];
   if (content.op !== op) throw new FilesError("plan_stale", `planId 属于 ${content.op} 操作,不能用于 ${op}`);
   if (!row.expires_at || row.expires_at.getTime() <= d.ao.ports.now().getTime())
-    throw new FilesError("plan_stale", "计划已过期,请重新预览");
-  if (content.requestHash !== requestHash) throw new FilesError("plan_stale", "请求内容与预览时不一致,请重新预览");
+    throw new FilesError("plan_stale", "计划已过期,重新预览");
+  if (content.requestHash !== requestHash) throw new FilesError("plan_stale", "请求与预览时不一致,重新预览");
   return { id: row.id, content, contentHash: row.content_hash, expiresAt: row.expires_at };
 }
 
@@ -101,7 +100,7 @@ export async function idempotent<T>(
     if (!row) return undefined;
     const c = row.content as { reqHash: string; state: string; result?: T };
     if (c.reqHash !== reqHash) throw new FilesError("exists", "idempotencyKey 已用于不同的请求");
-    if (c.state !== "done") throw new FilesError("exists", "同一 idempotencyKey 的请求仍在执行,请稍后重试");
+    if (c.state !== "done") throw new FilesError("exists", "同一 idempotencyKey 的请求仍在执行,稍后重试");
     return c.result as T;
   };
   const prev = await replay();
@@ -116,7 +115,7 @@ export async function idempotent<T>(
   if (!id) {
     const again = await replay();
     if (again !== undefined) return again;
-    throw new FilesError("exists", "同一 idempotencyKey 的请求仍在执行,请稍后重试");
+    throw new FilesError("exists", "同一 idempotencyKey 的请求仍在执行,稍后重试");
   }
   try {
     const result = await fn();

apps/server/src/modules/file-manager/mutate.ts

@@ -16,7 +16,7 @@ const parentRel = (rel: string) => (rel.includes("/") ? dirname(rel) : "");
 
 function assertCleanName(name: string) {
   if (sanitizeSegment(name) !== name)
-    throw new FilesError("bad_request", `文件名含非法字符或首尾空白/点,建议:${sanitizeSegment(name)}`);
+    throw new FilesError("bad_request", `文件名含非法字符或首尾有空白/点,可改为:${sanitizeSegment(name)}`);
 }
 
 export async function mkdirIn(
@@ -56,8 +56,8 @@ export async function renameEntry(
   body: FilesRenameRequest,
 ): Promise<FilesRenameResult> {
   const r = await resolveIn(d, body.root, body.path);
-  if (r.rel === "") throw new FilesError("bad_request", "不能改名根目录");
-  if (!r.def.modifiable) throw new FilesError("not_writable", `根 ${r.def.name} 为只读登记(register_only)`);
+  if (r.rel === "") throw new FilesError("bad_request", "根目录不能重命名");
+  if (!r.def.modifiable) throw new FilesError("not_writable", `根 ${r.def.name} 只读,不能重命名`);
   assertCleanName(body.newName);
   const oldName = basename(r.abs);
   if (body.newName === oldName) throw new FilesError("bad_request", "新名称与原名称相同");
@@ -68,7 +68,7 @@ export async function renameEntry(
   if (hits.length > 0)
     throw new FilesError(
       "download_active",
-      `该路径属于纳管下载任务(${hits.map((h) => h.taskId).join(", ")}),改名会让下载器找不到文件;请先完成整理或移交`,
+      `该路径属于下载任务 ${hits.map((h) => h.taskId).join(", ")},重命名会让下载器找不到文件。先整理入库再改`,
     );
 
   const dirAbs = dirname(r.abs);
@@ -124,10 +124,10 @@ export async function renameEntry(
       const before = await lstat(p.fromAbs);
       const res = await moveSafe(p.fromAbs, p.toAbs);
       if (res.status === "exists") throw new FilesError("exists", `目标已存在,不覆盖: ${p.to}`);
-      if (res.status !== "moved") throw new FilesError("bad_request", `改名失败(${res.status}): ${p.from}`);
+      if (res.status !== "moved") throw new FilesError("bad_request", `重命名失败(${res.status}): ${p.from}`);
       const after = await lstat(p.toAbs);
       if (after.ino !== before.ino || after.dev !== before.dev)
-        throw new FilesError("bad_request", `改名后 inode 不一致,已中止: ${p.to}`);
+        throw new FilesError("bad_request", `重命名后 inode 不一致,已中止: ${p.to}`);
       done.push(p);
     } catch (e) {
       await rollback();

apps/server/src/modules/file-manager/organize.ts

@@ -126,7 +126,7 @@ export async function organizeFiles(
     if (r.isSymlink) throw new FilesError("bad_request", `不整理符号链接: ${r.rel}`);
     const action = it.operation ?? body.action;
     if (action === "move" && !r.def.modifiable)
-      throw new FilesError("not_writable", `源根 ${r.def.name} 为只读登记,不能 Move`);
+      throw new FilesError("not_writable", `源根 ${r.def.name} 只读,不能移动`);
     roots.add(it.root);
     const isDir = !!r.lst?.isDirectory();
     const kind = entities.get(it.mediaEntityId);
@@ -173,10 +173,10 @@ export async function organizeFiles(
     if (slotId) {
       const s = slots.get(slotId);
       if (!s || s.media_entity_id !== it.mediaEntityId) {
-        warnings.push(`${r.rel}: Slot ${slotId} 不属于该作品,未应用`);
+        warnings.push(`${r.rel}: 版本目标 ${slotId} 不属于该作品,未应用`);
         slotId = null;
       } else if (BUSY_SLOT.has(s.status)) {
-        warnings.push(`${r.rel}: Slot 正在获取中(${s.status}),不改其状态`);
+        warnings.push(`${r.rel}: 版本目标正在获取中(${s.status}),不改其状态`);
         slotId = null;
       }
     }
@@ -313,7 +313,7 @@ export async function organizeFiles(
       const again = await planImport(d.ao, importReq(true));
       const nowPairs = pairsOf(again).map(({ src, dst }) => ({ src, dst }));
       if (hashJson(nowPairs) !== hashJson(frozen.pairs))
-        throw new FilesError("plan_stale", "重新计算的前后路径与预览不一致(目标目录或绑定已变化),请重新预览");
+        throw new FilesError("plan_stale", "目标目录或绑定已变化,与预览不一致。重新预览");
       if (again.status === "failed") throw new FilesError("bad_request", `计划不可执行:${again.reason ?? "blocked"}`);
 
       if (g.action === "move") {
@@ -329,7 +329,7 @@ export async function organizeFiles(
         if (block)
           throw new FilesError(
             "download_active",
-            `来源下载任务 ${block.downloadTaskId} 的做种义务${block.hnr === "unknown" ? "未知" : "未满足"},拒绝 Move(未改为 Copy);已建待处理 ${block.decisionId}`,
+            `下载任务 ${block.downloadTaskId} 的做种义务${block.hnr === "unknown" ? "未知" : "未满足"},不能移动,也不会自动改为复制。已建待处理事项 ${block.decisionId}`,
           );
       }
       await retirePlan(d, planId);
@@ -415,6 +415,6 @@ async function pickPlan(d: FmDeps, planIds: string[], reqHash: string): Promise<
     .where("title", "=", "files_plan")
     .execute();
   const hit = rows.find((r) => (r.content as { op?: string; requestHash?: string }).requestHash === reqHash);
-  if (!hit) throw new FilesError("plan_stale", "没有与该组请求一致的 planId,请重新预览");
+  if (!hit) throw new FilesError("plan_stale", "没有与该组请求一致的 planId,重新预览");
   return hit.id;
 }

apps/server/src/modules/file-manager/probe.ts

@@ -117,7 +117,7 @@ export async function scrape(
     .where("media_entity_id", "=", e.id)
     .where("status", "=", "active")
     .executeTakeFirst();
-  if (!registered) throw new FilesError("bad_request", "作品还没有已登记资产;未登记文件请先识别并整理入库,再刮削");
+  if (!registered) throw new FilesError("bad_request", "作品没有已登记资产。先识别并整理入库,再刮削");
   const { runId } = await d.ctx.engine.enqueue(
     "refreshMetadata",
     { mediaEntityId: e.id },

apps/server/src/modules/file-manager/transfer.ts

@@ -95,17 +95,16 @@ export async function transfer(
   const t = await resolveIn(d, body.target.root, body.target.path);
   if (!t.lst?.isDirectory() || t.isSymlink) throw new FilesError("bad_request", "目标必须是已存在的目录");
   if (!t.def.libraryRootId || !(await isWritableTarget(t.def, t.rootReal)))
-    throw new FilesError("not_writable", `目标根 ${t.def.name} 不可写(仅 managed 库根可作为目标)`);
+    throw new FilesError("not_writable", `目标根 ${t.def.name} 不可写,只能选 managed 库根`);
 
   const sources: Resolved[] = [];
   for (const it of body.items) {
     const s = await resolveIn(d, it.root, it.path);
-    if (s.rel === "") throw new FilesError("bad_request", "不能移动/复制根目录本身");
-    if (mode === "move" && !s.def.modifiable)
-      throw new FilesError("not_writable", `源根 ${s.def.name} 为只读登记,不能移动(可复制)`);
+    if (s.rel === "") throw new FilesError("bad_request", "根目录不能移动或复制");
+    if (mode === "move" && !s.def.modifiable) throw new FilesError("not_writable", `源根 ${s.def.name} 只读,只能复制`);
     if (within(t.abs, s.abs)) throw new FilesError("bad_request", `目标在源目录之内: ${s.rel}`);
     if (dirname(s.abs) === t.abs) throw new FilesError("bad_request", `源已在目标目录中: ${s.rel}`);
-    if (s.isSymlink) throw new FilesError("bad_request", `不移动符号链接本身: ${s.rel}`);
+    if (s.isSymlink) throw new FilesError("bad_request", `不能移动符号链接: ${s.rel}`);
     sources.push(s);
   }
   const names = sources.map((s) => basename(s.abs));
@@ -149,7 +148,7 @@ export async function transfer(
     const reason = planned.reason ?? "plan_failed";
     throw new FilesError(
       reason.startsWith("library_root_offline") ? "root_unavailable" : "bad_request",
-      `无法生成搬运计划:${reason}`,
+      `无法生成计划:${reason}`,
     );
   }
   const planFiles = planned.plan.organize.files;
@@ -190,9 +189,9 @@ export async function transfer(
   const allowCross = (await d.ctx.settings.get("organize")).allowCrossVolumeMove;
   const crossBlocked = mode === "move" && !allowCross && pairs.some((p) => p.crossDevice);
   const warnings: string[] = [];
-  if (crossBlocked) warnings.push("跨卷移动未开启(设置 → 整理 → 允许跨卷 Move),执行会被拒绝;可改用复制");
+  if (crossBlocked) warnings.push("未开启跨卷移动,执行会失败。改用复制,或在 设置 → 整理 中开启");
   if (conflictSrc.size > 0) warnings.push(`${conflictSrc.size} 个文件在目标已存在,不覆盖,执行时记为失败`);
-  if (truncated) warnings.push("源文件数超过上限,请分批操作");
+  if (truncated) warnings.push("源文件数超过上限,分批操作");
   const base = { mode, pairs, totalBytes, freeBytes, spaceOk, hnrBlocks, truncated, warnings };
 
   if (body.dryRun) {
@@ -219,19 +218,19 @@ export async function transfer(
       throw new FilesError("plan_stale", `源在预览后发生变化(大小/修改时间/文件清单): ${s.rel}`);
   }
   if (plan.content.files && hashJson(plan.content.files) !== hashJson(filePairs))
-    throw new FilesError("plan_stale", "重新计算的前后路径与预览不一致(目标已变化),请重新预览");
-  if (truncated) throw new FilesError("bad_request", "源目录文件数超过上限,请分批操作");
+    throw new FilesError("plan_stale", "目标已变化,与预览不一致。重新预览");
+  if (truncated) throw new FilesError("bad_request", "源目录文件数超过上限,分批操作");
   if (!spaceOk) throw new FilesError("bad_request", `目标卷空间不足:需要 ${needBytes},可用 ${freeBytes}`);
   if (crossBlocked)
     throw new FilesError(
       "bad_request",
-      "跨卷移动未开启(settings.organize.allowCrossVolumeMove),请改用复制或开启后重试",
+      "未开启跨卷移动(settings.organize.allowCrossVolumeMove)。改用复制,或开启后重试",
     );
   if (mode === "move") {
     if (hnrBlocks.length > 0)
       throw new FilesError(
         "download_active",
-        `源属于纳管下载任务(${[...new Set(hnrBlocks.map((h) => h.taskId))].join(", ")}),裸移动会让下载器丢失文件;请用整理入库(Move 会按 H&R 判定并移交)`,
+        `源属于下载任务 ${[...new Set(hnrBlocks.map((h) => h.taskId))].join(", ")},直接移动会让下载器丢失文件。改用整理入库,它会按做种义务决定能否移动`,
       );
     if (!isAdmin(principal)) {
       // 每个源按其(目录则为其下)已登记资产求作品集合,逐一核对授权;任一不覆盖 → 整体拒绝并列出未授权项
@@ -273,7 +272,7 @@ export async function transfer(
   }
   if (!rec.recordId || rec.status === "failed") {
     await markTask(db, taskId, "failed", { error: rec.reason ?? rec.status });
-    throw new FilesError("bad_request", `搬运计划不可执行:${rec.reason ?? rec.status}`);
+    throw new FilesError("bad_request", `计划不可执行:${rec.reason ?? rec.status}`);
   }
   const recordId = rec.recordId;
   await db.updateTable("organization_record").set({ task_id: taskId }).where("id", "=", recordId).execute();

apps/server/src/modules/file-manager/trash.ts

@@ -155,13 +155,13 @@ const BLOCK_ERR: Record<
   NonNullable<FileDeleteCheck["blocked"]>,
   [ConstructorParameters<typeof FilesError>[0], string]
 > = {
-  download_active: ["download_active", "属于纳管下载任务(未完成或做种义务未满足)"],
-  is_root: ["bad_request", "不能删除根本身或只读登记根下的内容"],
+  download_active: ["download_active", "属于未完成或做种义务未满足的下载任务"],
+  is_root: ["bad_request", "不能删除根目录或只读根下的内容"],
   needs_retire: ["needs_retire", "含已登记资产,需勾选“同时退役资产”"],
   needs_unbind: ["needs_unbind", "是作品/季的绑定目录,需勾选“解除绑定”"],
-  root_unavailable: ["root_unavailable", "根不可用,不当作已删除"],
+  root_unavailable: ["root_unavailable", "根不可用"],
   not_found: ["not_found", "不存在"],
-  escape: ["path_escape", "路径逃出根"],
+  escape: ["path_escape", "路径指向根外"],
 };
 
 export async function deleteFiles(
@@ -171,7 +171,7 @@ export async function deleteFiles(
 ): Promise<FilesDeleteResult> {
   if (body.mode === "permanent") {
     if (!d.options.allowPermanentDelete)
-      throw new FilesError("permanent_disabled", "永久删除未开启(FILES_ALLOW_PERMANENT_DELETE),请使用回收站");
+      throw new FilesError("permanent_disabled", "未开启永久删除(FILES_ALLOW_PERMANENT_DELETE)。改用回收站");
     if (!isAdminSession(principal)) throw new FilesError("forbidden", "永久删除只允许控制台管理员会话");
   }
   const downloads = await managedDownloads(d);
@@ -276,8 +276,8 @@ export async function deleteFiles(
         for (const s of slots)
           await upsertDecision(d.ao, trx, {
             kind: "other",
-            title: `Slot 满足资产已被删除:${s.name}`,
-            summary: "文件管理删除了满足该 Slot 的资产(进回收站或永久删除),Slot 退回 attention,请确认是否重新获取",
+            title: `版本目标的文件已删除:${s.name}`,
+            summary: "满足该版本目标的资产已在文件管理中删除,版本目标改为需关注。确认是否重新获取",
             subjectType: "acquisition_slot",
             subjectId: s.id,
             dedupeKey: `files_delete_slot:${s.id}`,
@@ -396,7 +396,7 @@ async function moveToTrash(
     if (check.size > d.options.trashCrossMaxBytes)
       throw new FilesError(
         "bad_request",
-        `无法同卷移入回收站,且大小 ${check.size} 超过跨卷上限 ${d.options.trashCrossMaxBytes};请使用永久删除`,
+        `无法同卷移入回收站,且大小 ${check.size} 超过跨卷上限 ${d.options.trashCrossMaxBytes}。改用永久删除`,
       );
     await rm(join(ctx.rootReal!, TRASH_DIR, stamp, id), { recursive: true, force: true }).catch(() => undefined);
     trashPath = join(resolve(d.options.dataDir), "trash", stamp, id, check.path);
@@ -487,10 +487,10 @@ export async function mkdirWithin(rootReal: string, rel: string): Promise<void>
       throw e;
     });
     if (st?.isSymbolicLink())
-      throw new FilesError("path_escape", `还原路径中的 ${relOfRoot(rootReal, cur)} 是符号链接,拒绝`);
+      throw new FilesError("path_escape", `还原路径中的 ${relOfRoot(rootReal, cur)} 是符号链接,不能还原`);
     if (st && !st.isDirectory()) throw new FilesError("exists", `还原路径中的 ${relOfRoot(rootReal, cur)} 不是目录`);
     if (!st) await mkdir(cur);
-    if (!within(await realpath(cur), rootReal)) throw new FilesError("path_escape", `还原路径逃出根: ${rel}`);
+    if (!within(await realpath(cur), rootReal)) throw new FilesError("path_escape", `还原路径指向根外: ${rel}`);
   }
 }
 const relOfRoot = (root: string, p: string) => (p === root ? "" : p.slice(root.length + 1));
@@ -509,7 +509,7 @@ export async function restoreTrash(
     throw new FilesError("bad_request", "还原目标必须是已存在的目录");
   // "还原到…"只能进可写的 managed 库根(与 move/copy 的目标规则一致;register_only / 下载根拒绝,验收 07 S-5)
   if (target && !(await isWritableTarget(target.def, target.rootReal)))
-    throw new FilesError("not_writable", `还原目标根 ${target.def.name} 不可写(仅 managed 库根可作为目标)`);
+    throw new FilesError("not_writable", `还原目标根 ${target.def.name} 不可写,只能选 managed 库根`);
   for (const id of body.ids) {
     try {
       const row = await d.ctx.db.selectFrom("trash_item").selectAll().where("id", "=", id).executeTakeFirst();
@@ -547,7 +547,7 @@ export async function restoreTrash(
         if (bytes > d.options.trashCrossMaxBytes)
           throw new FilesError(
             "too_large",
-            `跨卷还原大小 ${bytes} 超过上限 ${d.options.trashCrossMaxBytes};请在同卷还原,或手工处理 ${row.trash_path}`,
+            `跨卷还原大小 ${bytes} 超过上限 ${d.options.trashCrossMaxBytes}。在同卷还原,或手工处理 ${row.trash_path}`,
           );
         await copyTree(d, row.trash_path, dst, files);
         await rm(row.trash_path, { recursive: true });