dsh-disk-manager 0.1.0

package/core/classify.mjs

@@ -0,0 +1,127 @@
+import { classify as ruleClassify, isCategory, CATEGORY_META } from "./riskmap.mjs";
+import { loadClassifyCache, saveClassifyCache } from "../config.mjs";
+
+/**
+ * classify.mjs —— 分类引擎,三级:
+ *   1) 静态规则库 riskmap(确定,零成本)
+ *   2) 本地分类缓存 classify-cache(用户之前确认过的,跳过 LLM)
+ *   3) LLM 兜底:特征包 -> LLM 判断类别 -> 人工确认 -> 回写缓存
+ *
+ * 红线(E)强规则:任何 config/storage/memory/database/.openviking/.qclaw 特征,
+ * 即使 LLM 判错,也不自动执行(由 safety.mjs 最终兜底)。
+ */
+
+/** 把目录特征包组装成给 LLM 的提示文本 */
+function buildLlmPrompt(feature) {
+  const subs = (feature.subdirs || []).join("、") || "(空)";
+  return `你是一个 Windows 磁盘清理参谋。下面是一个占用 ${feature.sizeMB ?? "?"} MB 的目录,请判断它属于哪一类。
+
+目录名: ${feature.name}
+完整路径: ${feature.path}
+一级子目录: ${subs}
+
+类别定义:
+A 无忧缓存 —— Cache/GPUCache/Code Cache/Temp/log/updater 等,可再生,可删或 junction 搬
+B 官方可改址 —— 软件自己支持改存储位置(Docker/npm/pnpm/浏览器profile等)
+C 可junction搬 —— 软件不支持改址但数据纯可再生(视频剪辑/聊天/Notion/游戏客户端等)
+D 冷废弃软件 —— 很久没用的大体积软件
+E 配置/记忆(红线) —— Config/Storage/IndexedDB/MEMORY/数据库/.openviking/.qclaw 等,绝不能动
+
+只返回一个 JSON,不要其他文字:
+{"category":"A|B|C|D|E","confidence":"high|medium|low","reason":"一句话依据","recommendedAction":"建议动作"}`;
+}
+
+/**
+ * LLM 兜底判断。通过 ctx.llm? 调用 DSH 自带通道。
+ * 若 DSH 通道不可用,返回 { category:null, needUser:true },让前端请求人工确认。
+ */
+async function llmClassify(ctx, feature) {
+  try {
+    const prompt = buildLlmPrompt(feature);
+    if (!ctx.llm || typeof ctx.llm.call !== "function") {
+      throw new Error("DSH LLM 通道不可用");
+    }
+    const resp = await ctx.llm.call(prompt);
+    const text = typeof resp === "string" ? resp : resp?.content ?? JSON.stringify(resp);
+    const match = text.match(/\{[\s\S]*\}/);
+    if (!match) throw new Error("LLM 返回无 JSON");
+    const parsed = JSON.parse(match[0]);
+    const cat = String(parsed.category || "").trim().toUpperCase();
+    if (!isCategory(cat)) throw new Error(`LLM 返回非法类别: ${cat}`);
+    return {
+      category: cat,
+      confidence: parsed.confidence || "medium",
+      reason: parsed.reason || "LLM 判断",
+      recommendedAction: parsed.recommendedAction || "",
+      source: "llm",
+    };
+  } catch (e) {
+    return { category: null, confidence: "low", reason: `LLM 失败: ${e.message}`, source: "llm-failed", needUser: true };
+  }
+}
+
+/**
+ * 主分类入口。
+ * @param {object} entry 扫描条目 { name, path, sizeMB, subdirs, lastAccess }
+ * @param {object} opts  { config, ctx, targetDrive }
+ * @returns {object} 最终分类,含 category/source/confidence/reason/needUser
+ */
+export async function classifyEntry(entry, opts) {
+  const { config, ctx } = opts;
+  const cache = loadClassifyCache();
+
+  // 1) 静态规则库
+  const rule = ruleClassify(entry);
+  if (rule.category) {
+    // 规则判为 E 或其他,且用户曾确认过则直接采纳 confirm;否则用规则
+    if (rule.confidence === "high") {
+      return { ...rule, source: "rule" };
+    }
+  }
+
+  // 2) 本地分类缓存(基于目录名特征签名)
+  const sig = featureSignature(entry);
+  const cached = cache[entry.name] || cache[sig];
+  if (cached && isCategory(cached.category)) {
+    return { category: cached.category, reason: cached.reason || "本地缓存", confidence: cached.confidence || "medium", source: "cache" };
+  }
+
+  // 3) LLM 兜底
+  const feature = { name: entry.name, path: entry.path, sizeMB: entry.sizeMB, subdirs: entry.subdirs };
+  const llm = await llmClassify(ctx, feature);
+  if (llm.category) {
+    // 强红线:LLM 判错但特征命中红线 -> 回退 E
+    if (looksLikeRedline(feature)) {
+      return { category: "E", reason: "特征命中红线,LLM 判断被回退为 E", confidence: "high", source: "redline-override", llm: llm.category };
+    }
+    return { ...llm, needUser: true, source: "llm" };
+  }
+
+  // LLM 失败 -> 需要人工
+  return { category: null, confidence: "low", reason: llm.reason || "无法自动分类,请人工指定", source: "unclassified", needUser: true };
+}
+
+/** 强红线:特征命中 config/storage/memory/database/.点目录 等 */
+function looksLikeRedline(feature) {
+  const n = feature.name.toLowerCase();
+  if (n.startsWith(".")) return true; // .openviking/.qclaw/.config 等点目录一律红线
+  return /memory|sqlite|database|indexeddb|\.openviking|\.qclaw|storage/.test(n);
+}
+
+/** 目录分类签名:名称 + 是否有 cache/config/storage 大字样 */
+function featureSignature(entry) {
+  const n = entry.name.toLowerCase();
+  return `${n}|${/cache|temp|log|updater/i.test(n) ? "c" : "-"}|${/config|setting|prefer/i.test(n) ? "s" : "-"}|${/storage|indexeddb|memory|database/.test(n) ? "d" : "-"}`;
+}
+
+/** 用户确认后回写本地缓存 */
+export function recordUserDecision(entry, category, reason = "") {
+  if (!isCategory(category)) return;
+  const cache = loadClassifyCache();
+  const sig = featureSignature(entry);
+  cache[entry.name] = { category, reason, confidence: "high", confirmedAt: new Date().toISOString() };
+  cache[sig] = { category, reason, confidence: "high", confirmedAt: new Date().toISOString() };
+  saveClassifyCache(cache);
+}
+
+export { CATEGORY_META };

package/core/executor.mjs

@@ -0,0 +1,110 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, renameSync } from "node:fs";
+import { join, dirname } from "node:path";
+
+/**
+ * executor.mjs —— 执行引擎。
+ * 动作:
+ *   delete  删缓存(仅 A)
+ *   junction 把目录物理搬到目标盘,C 盘原位建 junction(仅 A/C)
+ *   redirect 引导用户走官方设置改址(B),或直接设环境变量
+ *
+ * 所有操作都用 -LiteralPath / 关闭软件前提;每步返回 before/after 供 undo。
+ * 注意:junction 需要目标盘的父目录存在、且源目录可用(软件已关闭)。
+ */
+
+function ps(Script) {
+  return execFileSync("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", Script], {
+    maxBuffer: 256 * 1024 * 1024,
+    timeout: 600000,
+    encoding: "utf8",
+  }).toString();
+}
+
+function dirSizeMB(p) {
+  try {
+    const s = ps(`$ErrorActionPreference='SilentlyContinue'; [math]::Round(((Get-ChildItem -LiteralPath '${p.replace(/'/g, "''")}' -Recurse -Force -File -ErrorAction SilentlyContinue | Measure-Object -Property Length -Sum).Sum)/1MB,1)`);
+    const n = Number(s.trim());
+    return isNaN(n) ? null : n;
+  } catch {
+    return null;
+  }
+}
+
+/** 删除类操作:仅信任调用方已将 category 过滤为 A */
+async function deleteDir(action, config) {
+  const p = action.path;
+  if (!p || !existsSync(p)) return { ok: false, message: "路径不存在" };
+  const before = dirSizeMB(p);
+  try {
+    rmSync(p, { recursive: true, force: true });
+    return { ok: true, message: `已删除 ${p}`, before, after: 0 };
+  } catch (e) {
+    return { ok: false, message: `删除失败(可能被占用): ${e.message}`, before };
+  }
+}
+
+/**
+ * junction 搬家:物理 Move-Item 到 target,再在源位置建 junction。
+ * target 由调用方按 "D:\\AppCache\\<软件>" 拼好传入(action.target)。
+ */
+async function junctionMove(action, config) {
+  const src = action.path;
+  const dst = action.target; // 完整目标,如 D:\AppCache\Notion\Partitions
+  if (!src || !dst || !existsSync(src)) return { ok: false, message: "源路径不存在或未给目标" };
+  if (!/^[A-Za-z]:\\/.test(dst)) return { ok: false, message: "目标盘格式无效" };
+  const before = dirSizeMB(src);
+  try {
+    const script = `
+$ErrorActionPreference='Stop'
+$src='${src.replace(/'/g, "''")}'
+$dst='${dst.replace(/'/g, "''")}'
+New-Item -ItemType Directory -Path (Split-Path $dst -Parent) -Force | Out-Null
+if (Test-Path -LiteralPath $dst) { Remove-Item -LiteralPath $dst -Recurse -Force }
+Move-Item -LiteralPath $src -Destination $dst -Force
+New-Item -ItemType Junction -Path $src -Target $dst -Force | Out-Null
+(Get-Item -LiteralPath $src -Force).LinkType
+`;
+    const link = ps(script).trim();
+    if (link !== "Junction") {
+      return { ok: false, message: `junction 建立失败(link=${link})`, before };
+    }
+    return { ok: true, message: `已搬到 ${dst} 并建立 junction`, before, after: 0, target: dst };
+  } catch (e) {
+    return { ok: false, message: `junction 搬移失败: ${e.message}`, before };
+  }
+}
+
+/** B 类:引导改址。这里不直接改软件,返回指引文案;同时可对支持环境变量的设好变量 */
+async function redirectGuide(action, config) {
+  const name = action.name || action.path;
+  const drive = config.targetDrive || "D";
+  let hint = `请打开 ${name} 的设置,把数据/缓存位置改到 ${drive}: 盘,然后重启该软件。`;
+  if (/npm|node/i.test(name)) hint = `在终端执行: npm config set cache "${drive}:\\npm-cache"`;
+  else if (/pnpm/i.test(name)) hint = `在终端执行: pnpm config set store-dir "${drive}:\\pnpm-store"`;
+  else if (/pip/i.test(name)) hint = `设置环境变量 PIP_CACHE_DIR="${drive}:\\pip-cache",或 pip config set global.cache-dir`;
+  else if (/docker|wsl/i.test(name)) hint = `Docker Desktop → Settings → Resources → Advanced → Disk image location 改为 ${drive}:\\docker\\DockerDesktopWSL,Apply & Restart。`;
+  return { ok: true, message: `引导改址(未自动改)`, hint, before: dirSizeMB(action.path), after: null };
+}
+
+/** 冷废弃软件(D):只提示,不执行任何删除/搬迁 */
+async function abandonHint(action) {
+  return { ok: true, message: `提示:你可能很久没用了。要不要卸载?`, hint: action.path };
+}
+
+const BASE = "D:\\AppCache";
+
+/** 对一条 action 分派到具体执行器 */
+export async function dispatch(action, config) {
+  const map = {
+    delete: deleteDir,
+    junction: junctionMove,
+    redirect: redirectGuide,
+    abandon: abandonHint,
+  };
+  const fn = map[action.action];
+  if (!fn) return { ok: false, message: `未知动作 ${action.action}` };
+  return fn(action, config);
+}
+
+export { dirSizeMB, BASE };

package/core/riskmap.mjs

@@ -0,0 +1,310 @@
+/**
+ * riskmap.mjs —— 静态规则库:把目录名/特征映射到 A/B/C/D/E 五类。
+ *
+ * 五类定义:
+ *   A 无忧缓存   —— Cache/GPUCache/Code Cache/CachedData/Temp/log/*.updater,可再生,可删或junction搬
+ *   B 官方可改址 —— 软件自己支持改存储位置(Docker/npm/pnpm/pip/浏览器profile/下载目录),走官方设置
+ *   C 可junction —— 软件不支持改址但数据纯可再生(剪映Cache/Notion离线库/Trae/Cursor缓存),junction搬
+ *   D 冷废弃软件 —— 大体积 + 超过 abandonDays 未使用,提示"你很久没用它了",只提醒不自动删
+ *   E 配置/记忆  —— Config/Storage/IndexedDB/MEMORY/数据库/.openviking/.qclaw,红线,只展示不执行
+ *
+ * 分类引擎(safety.mjs/executor.mjs 依赖)优先级:
+ *   1) 红线特征(E)优先 —— 命中即判 E,即使 LLM 判错也不自动执行
+ *   2) 用户黑名单 -> E
+ *   3) 静态规则库
+ *   4) 本地分类缓存 classify-cache
+ *   5) LLM 兜底 + 人工确认
+ */
+
+/** 判断 feature 提取后是否命中"无法访问/受保护",这类直接跳过 */
+const PROTECTED = ["AccessDenied", "NotFound"];
+
+/**
+ * 程序本体/系统目录:这些是软件主程序或系统组件,属于"保护",一律 E(只展示)。
+ * 不删不搬。即使叫 cache 之类也不动 —— 优先级高于一切。
+ */
+const RULE_PROTECTED = [
+  "programs",
+  "program files",
+  "package cache",
+  "packages",
+  "microsoft",
+  "windows",
+  "programdata",
+  "system32",
+  "brother", // 打印机驱动
+  "intel corporation",
+  "nvidia corporation",
+  "comms",
+  "connecteddevicesplatform",
+  "elevateddiagnostics",
+  "peerdistrepub",
+  "engine",
+  "unrealengine",
+  "godot",
+  "steam", // Steam 客户端本体+游戏数据,保护
+  "battle.net", // 暴雪客户端本体
+  "blizzard entertainment",
+  "neteaseui",
+  "unicom",
+  "tssgame",
+];
+
+/** 目录名小写后 -> 类别 的精确规则 */
+const RULE_EXACT = {
+  "programs": "E",
+  "packages": "E",
+  "microsoft": "E",
+  "windows": "E",
+  // ---- A 无忧缓存 ----
+  "cache": "A",
+  "gpu cache": "A", // Common: "GPUCache"
+  "code cache": "A",
+  "cacheddata": "A",
+  "cachedprofilesdata": "A",
+  "cachedextensionvsixs": "A",
+  "blob_storage": "A",
+  "session storage": "A",
+  "local storage": "A",
+  "shared dictionary": "A",
+  "dictionaries": "A",
+  "webstorage": "A",
+  "crashpad": "A",
+  "crashdumps": "A",
+  "d3dscache": "A",
+  "log": "A",
+  "logs": "A",
+  "network": "A",
+  "dawnwebgpucache": "A",
+  "dawngraphitecache": "A",
+  "videdecodestats": "A",
+  "temp": "A",
+  "cache_data": "A",
+  "gpucache": "A",
+  "updates": "A",
+  "patch": "A",
+  "update": "A", // 更新残留(非软件本体)
+  "nointerrupt": "A",
+  "logs_bytype": "A",
+  "cache_media": "A",
+
+  // ---- E 配置/记忆(红线) ----
+  "preferences": "E",
+  "prefs": "E",
+  "settings": "E",
+  "config": "E",
+  "configure": "E",
+  "indexeddb": "E",
+  "storage": "E",
+  "profile": "E",
+  "profiles": "E",
+  "user data": "E",
+  "default": "E", // Chrome 默认 profile 下,默认 E,但其中 Cache 子目录再被规则引擎细分
+  "mem": "E",
+  "memory": "E",
+  "databases": "E",
+  "database": "E",
+  "sqlite": "E",
+  "keystore": "E",
+  "cookies": "E",
+  "login data": "E",
+  "bookmarks": "E",
+  "history": "E",
+  "top sites": "E",
+  "extensions": "E",
+  "session": "E",
+  "sessions": "E",
+  "localdata": "E",
+  "local state": "E",
+  "rust_data": "E",
+  ".qclaw": "E",
+  ".openviking": "E",
+  ".dsh": "E",
+  ".agents": "E",
+  ".config": "E",
+  ".local": "E",
+};
+
+/**
+ * 目录名子串规则(包含即命中)。注意顺序:越具体越靠前。
+ * 键->值:[类别, 说明]
+ */
+const RULE_CONTAINS = [
+  // updater 家族 -> A(更新残留,可再生;注意与软件本体区分,通常目录本身即更新包)
+  ["-updater", "A", "更新器下载的安装包残留,可删"],
+  ["_updater", "A", "更新器残留,可删"],
+  ["electron-updater", "A", "更新器残留,可删"],
+  ["desktop-updater", "A", "更新器残留,可删"],
+
+  // 缓存家族 -> A
+  ["cache", "A", "缓存目录,可再生"],
+  ["gpucache", "A", "GPU 缓存"],
+  ["codecache", "A", "代码缓存"],
+  ["cacheddata", "A", "缓存数据"],
+  ["cachedprofiles", "A", "缓存 profile"],
+
+  // npm/pnpm/pip/uv 包缓存 -> B(可用官方设置改址)
+  ["npm-cache", "B", "npm 缓存,可 npm config set cache 改址"],
+  ["npm_cache", "B", "npm 缓存,可改址"],
+  ["pnpm-cache", "B", "pnpm 缓存,可改址"],
+  ["pnpm-store", "B", "pnpm store,可改址"],
+  ["pnpm-store", "B", "pnpm store"],
+  ["uv", "B", "uv 包缓存"],
+  ["pip", "B", "pip 缓存"],
+  ["node-gyp", "B", "node-gyp 缓存"], // 偏可改址,但保底也算可再生
+  ["_npx", "B", "npx 缓存,可改址"],
+  ["_cacache", "B", "npm 内部缓存"],
+  ["ms-playwright", "B", "Playwright 浏览器,可设 PLAYWRIGHT_BROWSERS_PATH"],
+
+  // 官方可改址的大户软件 -> B(它们有专属设置)
+  ["docker", "B", "Docker,可在设置改 Disk image location"],
+  ["wsl", "B", "WSL 发行版,可用 wsl --import 迁盘"],
+
+  // 浏览器 profile/data —— 主体 E(有书签/登录),但其 Cache 子目录规则引擎会再判 A
+  ["user data", "E", "用户数据,含配置/登录,勿动非缓存部分"],
+  ["profile", "E", "Profile 数据"],
+  ["storage", "E", "存储数据"],
+  ["indexeddb", "E", "IndexedDB,含应用数据"],
+  ["memory", "E", "记忆库"],
+  ["sqlite", "E", "SQLite 数据库"],
+  ["localstorage", "E", "本地存储"],
+  ["local storage", "E", "本地存储"],
+  ["config", "E", "配置"],
+  ["settings", "E", "设置"],
+  ["preferences", "E", "偏好设置"],
+
+  // 游戏/语音类大客户端的缓存 -> A/C(可再生),如 YY/duowan
+  ["duowan", "C", "多玩/YY 客户端数据,可junction搬"],
+  ["yy", "C", "YY 客户端数据,可junction搬"],
+  ["heybox", "C", "游戏盒缓存,可junction搬"],
+  ["tencent", "C", "腾讯系客户端缓存,可junction搬(仅缓存部分)"],
+  ["xwechat", "C", "微信缓存,可junction搬(仅缓存部分)"],
+  ["wechat", "C", "微信"],
+  ["qqmusic", "C", "QQ音乐缓存"],
+  ["battle.net", "C", "暴雪客户端"],
+  ["steam", "C", "Steam 数据"],
+  ["doubao", "C", "豆包缓存"],
+  ["notion", "C", "Notion 离线库,可junction搬"],
+  ["trae", "C", "Trae 缓存"],
+  ["cursor", "C", "Cursor 缓存"],
+  ["bigfoot", "C", "bigfoot 缓存"],
+  ["douyin", "C", "抖音缓存"],
+  ["xmind", "C", "Xmind 数据"],
+  ["chatglm", "C", "ChatGLM"],
+  ["dingtalk", "C", "钉钉缓存"],
+  ["obsidian", "C", "Obsidian 数据"],
+  ["typora", "C", "Typora"],
+
+  // 剪映/视频剪辑 -> C
+  ["jianyingpro", "C", "剪映缓存,可junction搬"],
+  ["剪映", "C", "剪映"],
+  ["wangxin", "C", "剪映"],
+  ["capcut", "C", "剪映国际版"],
+
+  // Android/Arduino 等开发者工具 SDK(大,可再生但本机要用则保留,倾向 C 提示) —— 这类更适合"C 可junction/保留"
+  ["android", "C", "Android SDK,可junction搬或仅提示"],
+  ["arduino", "C", "Arduino 数据"],
+
+  // 数据库服务 -> B/E,倾向 E(服务数据别乱动)
+  ["mongo", "E", "MongoDB 数据"],
+  ["redis", "E", "Redis 数据"],
+  ["postgres", "E", "PostgreSQL 数据"],
+  ["mysql", "E", "MySQL 数据"],
+];
+
+/** 从目录名提取规范键(小写、去空格) */
+function normKey(name) {
+  return name.toLowerCase();
+}
+
+/**
+ * 提取一个目录的特征包,供 classify/LLM 使用。
+ * 返回 { name, path, sizeMB, subdirs:[...], hasCache, hasConfig, hasStorage, hasDatabase }
+ */
+function extractFeature(entry) {
+  const lower = entry.name.toLowerCase();
+  return {
+    name: entry.name,
+    path: entry.path,
+    sizeMB: entry.sizeMB,
+    subdirs: entry.subdirs || [],
+    hasCache: /cache|gpucache|codecache|temp|log|updater/i.test(lower),
+    hasConfig: /config|setting|prefer|profile/i.test(lower),
+    hasStorage: /storage|indexeddb|localstorage|sqlite|database|memory/i.test(lower),
+    hasData: /user ?data|workspace|session|vault/i.test(lower),
+  };
+}
+
+/**
+ * 主分类函数:给定条目特征返回 { category, reason, confidence }。
+ * confidence: "high"(规则库/红线) | "medium" | "low"(需 LLM+人工)
+ */
+export function classify(entry) {
+  const f = extractFeature(entry);
+  const key = normKey(f.name);
+  const zone = entry.zone || "appdata";
+
+  // 0) 程序本体/系统目录 —— 保护,优先级最高,一律 E
+  if (RULE_PROTECTED.some((p) => key.includes(p))) {
+    return { category: "E", reason: "程序本体/系统目录,保护,只展示", confidence: "high" };
+  }
+
+  // 0.1) 用户 profile 个人文件区(Downloads/Documents/Desktop 等) —— 绝不自动删,只提醒
+  if (zone === "user") {
+    // 点目录(.xxx)、配置/存储/记忆特征一律优先红线 E(而非 P),因为这些常是工具配置/记忆库
+    if (f.name.toLowerCase().startsWith(".") || f.hasStorage || f.hasConfig || /memory|sqlite|database|indexeddb|config|storage/.test(key)) {
+      return { category: "E", reason: "用户区里的点目录/配置/记忆,红线保护", confidence: "high" };
+    }
+    // 排除已知纯缓存子目录(仍可删/可搬)
+    if (f.hasCache && !/download|document|desktop|picture|video|music/.test(key)) {
+      return { category: "C", reason: "用户区里的缓存子目录,可junction搬", confidence: "high" };
+    }
+    return { category: "P", reason: "个人文件(用户自己的数据),只提醒大文件,绝不自动删", confidence: "high" };
+  }
+
+  // 0.2) Program Files 里的软件 —— 程序本体判 E 保护,但 >180 天未用会再提示冷废弃(类 D)
+  if (zone === "program") {
+    // 更新残留/缓存子目录仍可处理
+    if (f.hasCache || /-updater|_updater|electron-updater/.test(key)) {
+      return { category: "A", reason: "软件更新残留/缓存,可删", confidence: "high" };
+    }
+    return { category: "E", reason: "已安装软件,保护不自动删", confidence: "high" };
+  }
+
+  // 1) 红线优先:E —— 任何 config/storage/memory/database/.openviking/.qclaw 特征都判 E
+  if (f.hasStorage || f.name.toLowerCase().startsWith(".") || /memory|sqlite|database|indexeddb/.test(f.name.toLowerCase())) {
+    // 注意:若子目录纯是 cache,仍可细分。这里对顶层这个"父目录"给 E 是保守策略。
+    return { category: "E", reason: "命中红线特征(存储/记忆/数据库/点目录)", confidence: "high" };
+  }
+
+  // 2) 精确规则
+  if (RULE_EXACT[key]) {
+    const cat = RULE_EXACT[key];
+    return { category: cat, reason: "精确规则命中", confidence: "high" };
+  }
+
+  // 3) 包含规则(先过 A 家族,再 E 家族等)
+  for (const [sub, cat, note] of RULE_CONTAINS) {
+    if (key.includes(sub)) {
+      return { category: cat, reason: note, confidence: "high" };
+    }
+  }
+
+  // 4) 未命中 -> 触发 LLM 兜底(由 classify.mjs 处理),这里返回 low 让上层决定
+  return { category: null, reason: "未命中规则库,需 LLM 判断", confidence: "low" };
+}
+
+export function isCategory(cat) {
+  return ["A", "B", "C", "D", "E", "P"].includes(cat);
+}
+
+export const CATEGORY_META = {
+  A: { label: "无忧缓存", color: "green", action: "删 或 junction 搬", auto: true },
+  B: { label: "官方可改址", color: "blue", action: "改软件设置到其他盘", auto: false },
+  C: { label: "可junction搬", color: "cyan", action: "junction 搬到其他盘", auto: true },
+  D: { label: "冷废弃软件", color: "orange", action: "提示你可能没用它了", auto: false },
+  E: { label: "配置/记忆·红线", color: "red", action: "只展示,不执行", auto: false },
+  P: { label: "个人文件", color: "purple", action: "只提醒大文件,可手动搬,绝不自动删", auto: false },
+};
+
+export { PROTECTED, extractFeature };

package/core/safety.mjs

@@ -0,0 +1,119 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { configDir } from "../config.mjs";
+
+/**
+ * safety.mjs —— 强红线 + dry-run 预览 + undo 日志。
+ * 负责: 1) 红线判定(E 类永不执行)  2) E 类降级需二次确认
+ *       3) 执行前 dry-run 生成"将做什么"  4) 写 undo 日志供回滚
+ */
+
+const REDLINE_CATEGORY = "E";
+
+/** 单条待执行操作的 undo 记录结构 */
+function undoPath() {
+  return join(configDir(), "undo.log.json");
+}
+
+function readUndo() {
+  try {
+    if (existsSync(undoPath())) return JSON.parse(readFileSync(undoPath(), "utf8"));
+  } catch {
+    /* ignore */
+  }
+  return [];
+}
+
+function appendUndo(entry) {
+  const arr = readUndo();
+  arr.push({ ...entry, ts: new Date().toISOString() });
+  try {
+    mkdirSync(configDir(), { recursive: true });
+    writeFileSync(undoPath(), JSON.stringify(arr, null, 2), "utf8");
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * 校验一个条目能否执行。
+ * @returns { ok:boolean, reason?:string, downgradeRequired?:boolean }
+ */
+export function canExecute(item, config) {
+  const cat = item.category;
+
+  // 用户黑名单/配置黑名单 -> 禁止
+  if (item.path && config.blacklist?.some((b) => item.path.includes(b))) {
+    return { ok: false, reason: "命中用户黑名单" };
+  }
+
+  // E 红线:默认禁止
+  if (cat === REDLINE_CATEGORY) {
+    return { ok: false, reason: "配置/记忆红线(E),默认不执行", downgradeRequired: true };
+  }
+
+  // P 个人文件:用户自己的数据,绝不自动删;只允许手动 junction 搬/提醒,删除一律禁止
+  if (cat === "P") {
+    if (item.action === "delete") return { ok: false, reason: "个人文件(P),绝不自动删除" };
+    if (item.action === "junction") {
+      if (!config.targetDrive) return { ok: false, reason: "搬移需先选择目标盘" };
+      return { ok: true };
+    }
+    // 其余(remind/提示)允许
+    return { ok: true };
+  }
+
+  // 未分类(null)-> 禁止
+  if (!cat || cat === "unclassified") {
+    return { ok: false, reason: "尚未分类,需先确认" };
+  }
+
+  // A/C 可自动;必须已选目标盘(针对搬)
+  if ((cat === "A" || cat === "C") && !config.targetDrive && !["delete"].includes(item.action)) {
+    return { ok: false, reason: "搬移需先选择目标盘" };
+  }
+
+  return { ok: true };
+}
+
+/**
+ * 生成 dry-run 预览:列出"将对每个条目做什么",不真正执行。
+ * 对 E/未确认的条目标"NOP(红线/未分类)"。
+ */
+export function preview(actions, config) {
+  return actions.map((a) => {
+    const chk = canExecute(a, config);
+    if (!chk.ok) {
+      return { ...a, will: "NOP", status: chk.reason };
+    }
+    let will = "DELETE";
+    if (a.category === "B") will = "REDIRECT(改软件设置)";
+    if (a.category === "C") will = "JUNCTION(搬到磁盘)";
+    if (a.action === "delete") will = "DELETE";
+    if (a.action === "junction") will = "JUNCTION";
+    if (a.action === "redirect") will = "REDIRECT";
+    return { ...a, will, status: "OK" };
+  });
+}
+
+/**
+ * 执行一条操作。返回 { ok, message, undo? }。
+ * 由 executor.mjs 调用;这里只负责安全门 + undo 记录。
+ */
+export async function runAction(action, config, executorFn) {
+  const chk = canExecute(action, config);
+  if (!chk.ok) return { ok: false, message: chk.reason };
+
+  const result = await executorFn(action, config);
+  if (result.ok && config.undoLog) {
+    appendUndo({ action: action.action, category: action.category, path: action.path, target: action.target, before: result.before, after: result.after });
+  }
+  return result;
+}
+
+export function readUndoLog() {
+  return readUndo();
+}
+
+export { undoPath, appendUndo };