dsh-lost-and-found 0.1.1

package/config.mjs

@@ -0,0 +1,189 @@
+/**
+ * 文件快速寻回 · 配置与默认值
+ *
+ * 设计要点（与用户确认过的架构一致）：
+ *  - 用户配置的唯一真相来源是 DSH 设置命名空间 dsh-lost-and-found（设置页可改）。
+ *  - 扫描在独立子进程里跑，子进程读不到 DSH 设置，因此 host 在派生它之前
+ *    会把一份「运行快照」写到 ~/.dsh-lost-and-found/run.json。
+ *  - 用户数据目录只放运行快照/日志，索引库默认在 %LOCALAPPDATA%\dsh-lost-and-found\。
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/** 每个扫描目录的内容深度策略 */
+export const POLICY = Object.freeze({
+  FULL: "full",       // 记元数据 + 抽正文 + 摘要 + 看图
+  SUMMARY: "summary", // 记元数据 + 摘要，不保留正文原文
+  META: "meta",       // 只记元数据（文件名/类型/大小/时间/位置）
+});
+
+export const POLICY_LABEL = Object.freeze({
+  [POLICY.FULL]: "完整（正文+摘要+看图）",
+  [POLICY.SUMMARY]: "只摘要（不留正文原文）",
+  [POLICY.META]: "只记基本信息",
+});
+
+export const DEFAULT_CONFIG = Object.freeze({
+  enabled: true,
+  /** 空 = 用默认路径 %LOCALAPPDATA%\dsh-lost-and-found\index.db */
+  dbPath: "",
+  /** 自动扫描间隔（天）。0 = 关闭自动扫描，只能手动扫。 */
+  intervalDays: 1,
+  /** 首次安装时收录「最近 N 天」的文件。仅当 firstScanMode="window" 时生效。 */
+  firstRunWindowDays: 7,
+  /**
+   * 一个扫描目录「第一次被扫」时收多久的文件：
+   *   full   = 收录该目录里的全部历史文件（默认；否则后加入的目录会大面积漏收）
+   *   window = 只收最近 firstRunWindowDays 天
+   *   none   = 只收今后新增
+   */
+  firstScanMode: "full",
+  /** 单个文件超过该体积(MB)只记元数据，不抽正文 */
+  maxFileMB: 50,
+  /** 巡查白名单外的新目录（每天提示一次） */
+  patrolEnabled: true,
+  /** 每次看图配额（供「待描述图片」流程使用） */
+  imageQuotaPerRun: 20,
+  /** 每日备份保留份数，0 = 不备份 */
+  backupKeep: 7,
+  /** 扫描目录列表：[{ path, policy }] */
+  roots: [],
+  /** 追加的排除目录名（小写比较） */
+  extraExcludeDirs: [],
+  /** 追加的排除路径片段（不区分大小写包含匹配） */
+  extraExcludePatterns: [],
+});
+
+/** 默认剪枝目录名：命中则整棵子树不下钻 */
+export const DEFAULT_PRUNE_DIRS = [
+  "node_modules", ".git", ".svn", ".hg", ".pnpm-store", ".npm", ".cache", ".codex",
+  ".gradle", ".m2", ".cargo", ".rustup", ".vscode-server", ".pnpm", ".backup", ".trash",
+  "appcache", "cache", "caches", "temp", "tmp", "logs", "apm_record",
+  "$recycle.bin", "system volume information",
+  "appdata", "windows", "winsxs", "program files", "program files (x86)", "programdata",
+  "__pycache__", ".venv", "venv", "site-packages", ".next", ".nuxt", "dist", "build", "obj",
+];
+
+/** 默认排除路径片段（包含匹配，不区分大小写）：主要针对聊天软件/网盘的缓存区 */
+export const DEFAULT_EXCLUDE_PATTERNS = [
+  "\\msg\\attach\\",
+  "\\msg\\media\\",
+  "\\filestorage\\cache\\",
+  "\\filestorage\\img\\",
+  "\\filestorage\\video\\",
+  "\\filestorage\\favorite\\",
+  "\\$recycle.bin\\",
+  "\\system volume information\\",
+  // re: 前缀 = 正则（不区分大小写）。聊天软件的「内部数据区」整棵剪掉：
+  // 这些目录里是会话数据库与缩略图缓存，会被反复改写，对「找回文件」毫无价值。
+  "re:\\\\xwechat_files\\\\[^\\\\]+\\\\(db_storage|msg\\\\attach|msg\\\\media|temp|crash|global_config|emoticon|sns|favorite|apm_record|config|log)\\\\",
+  "re:\\\\(wechat files|tencent files)\\\\[^\\\\]+\\\\(filecache|image|video|favorite|config|cache)\\\\",
+  "re:\\\\appdata\\\\(local|roaming)\\\\[^\\\\]+\\\\(cache|caches|temp|logs?)\\\\",
+];
+
+/** 默认跳过的文件名/后缀（临时件、系统件、会话库日志） */
+export const SKIP_FILE_RE = [
+  /^desktop\.ini$/i,
+  /^thumbs\.db$/i,
+  /^\.ds_store$/i,
+  /^~\$/,
+  /\.tmp$/i,
+  /\.crdownload$/i,
+  /\.part$/i,
+  /\.partial$/i,
+  /\.download$/i,
+  /\.db-(wal|shm|journal)$/i,
+  /\.sqlite-(wal|shm|journal)$/i,
+  // 聊天/网盘的缩略图与哈希命名缓存（真正收到的原图/原文件不在此列）
+  /_thumb\.(jpg|jpeg|png|webp)$/i,
+  /^[0-9a-f]{16,}\.(jpg|jpeg|png|dat|mp4|webp)$/i,
+];
+
+/** 用户数据目录（运行快照、日志） */
+export function dataDir() {
+  return join(homedir(), ".dsh-lost-and-found");
+}
+
+export function runSnapshotPath() {
+  return join(dataDir(), "run.json");
+}
+
+export function ensureDataDir() {
+  mkdirSync(dataDir(), { recursive: true });
+  return dataDir();
+}
+
+/** 默认索引库路径（发布版默认；不硬编码盘符） */
+export function defaultDbPath() {
+  const base = process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local");
+  return join(base, "dsh-lost-and-found", "index.db");
+}
+
+export function resolveDbPath(config) {
+  const p = (config && config.dbPath ? String(config.dbPath) : "").trim();
+  return p || defaultDbPath();
+}
+
+/** 规整扫描目录列表：去空、去重、补默认策略 */
+export function normalizeRoots(roots) {
+  const out = [];
+  const seen = new Set();
+  for (const raw of Array.isArray(roots) ? roots : []) {
+    const path = typeof raw === "string" ? raw : raw && raw.path;
+    if (!path || typeof path !== "string") continue;
+    const clean = path.trim().replace(/[\\/]+$/, "");
+    if (!clean) continue;
+    const key = clean.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const policy = raw && raw.policy && POLICY[String(raw.policy).toUpperCase()]
+      ? raw.policy
+      : (raw && Object.values(POLICY).includes(raw.policy) ? raw.policy : POLICY.FULL);
+    out.push({ path: clean, policy });
+  }
+  return out;
+}
+
+export function writeRunSnapshot(payload) {
+  ensureDataDir();
+  const p = runSnapshotPath();
+  writeFileSync(p, JSON.stringify(payload, null, 2), "utf8");
+  return p;
+}
+
+export function readRunSnapshot() {
+  try {
+    const p = runSnapshotPath();
+    if (!existsSync(p)) return null;
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** 递归合并（设置页回填的扁平值覆盖默认值） */
+export function mergeDeep(base, patch) {
+  if (patch === undefined || patch === null) return base;
+  if (typeof patch !== "object" || Array.isArray(patch)) return patch;
+  const out = { ...base };
+  for (const [k, v] of Object.entries(patch)) {
+    out[k] = typeof v === "object" && v !== null && !Array.isArray(v) && typeof out[k] === "object" && out[k] !== null
+      ? mergeDeep(out[k], v)
+      : v;
+  }
+  return out;
+}
+
+/** 把配置里的排除规则合成为实际使用的两份清单 */
+export function buildExcludes(config) {
+  const dirs = new Set(DEFAULT_PRUNE_DIRS);
+  for (const d of config.extraExcludeDirs || []) {
+    if (d && String(d).trim()) dirs.add(String(d).trim().toLowerCase());
+  }
+  const patterns = [...DEFAULT_EXCLUDE_PATTERNS];
+  for (const p of config.extraExcludePatterns || []) {
+    if (p && String(p).trim()) patterns.push(String(p).trim().toLowerCase());
+  }
+  return { dirs, patterns: patterns.map((p) => p.toLowerCase()) };
+}

package/cordis.patch.yml

@@ -0,0 +1,5 @@
+# dsh-lost-and-found bundle patch layer.
+# 安装本包到 profile 后, host 端加载主入口(文件快速寻回:扫描/索引/检索)。
+- insert:
+    - id: dsh-lost-and-found
+      name: dsh-lost-and-found

package/core/classify.mjs

@@ -0,0 +1,102 @@
+/**
+ * 文件快速寻回 · 分类与来源标注
+ *
+ * 关于「是谁创建的文件」：Windows 不记录可信的作者信息（NTFS Owner 只反映系统账户，
+ * 你这台机器上几乎所有东西都是同一账户），因此这里不做「作者判定」，
+ * 而是做可判定的「来源推断」：文件是从哪类目录出现的。
+ * 这是与用户确认过的口径 —— 索引「最近出现在我地盘上的新文件」。
+ */
+
+const CATEGORY_BY_EXT = new Map(Object.entries({
+  // 文档
+  ".doc": "文档", ".docx": "文档", ".rtf": "文档", ".odt": "文档", ".wps": "文档",
+  ".md": "文本", ".txt": "文本", ".log": "文本",
+  // 表格 / 演示
+  ".xls": "表格", ".xlsx": "表格", ".xlsm": "表格", ".csv": "表格", ".et": "表格",
+  ".ppt": "演示", ".pptx": "演示", ".pps": "演示", ".ppsx": "演示", ".dps": "演示",
+  // PDF / 电子书
+  ".pdf": "PDF", ".epub": "电子书", ".mobi": "电子书", ".azw3": "电子书", ".caj": "电子书",
+  // 图片
+  ".jpg": "图片", ".jpeg": "图片", ".png": "图片", ".gif": "图片", ".webp": "图片",
+  ".bmp": "图片", ".heic": "图片", ".tif": "图片", ".tiff": "图片", ".svg": "图片",
+  ".psd": "图片", ".ai": "图片", ".raw": "图片", ".cr2": "图片",
+  // 音视频
+  ".mp3": "音频", ".wav": "音频", ".flac": "音频", ".m4a": "音频", ".aac": "音频", ".ogg": "音频",
+  ".mp4": "视频", ".mkv": "视频", ".avi": "视频", ".mov": "视频", ".wmv": "视频", ".flv": "视频", ".webm": "视频",
+  // 压缩包
+  ".zip": "压缩包", ".rar": "压缩包", ".7z": "压缩包", ".tar": "压缩包", ".gz": "压缩包", ".bz2": "压缩包", ".xz": "压缩包",
+  // 安装包 / 程序
+  ".exe": "安装包", ".msi": "安装包", ".apk": "安装包", ".dmg": "安装包", ".pkg": "安装包", ".deb": "安装包",
+  ".dll": "程序", ".sys": "程序", ".so": "程序", ".bat": "脚本", ".cmd": "脚本", ".ps1": "脚本", ".sh": "脚本",
+  // 代码
+  ".js": "代码", ".mjs": "代码", ".cjs": "代码", ".ts": "代码", ".tsx": "代码", ".jsx": "代码",
+  ".py": "代码", ".java": "代码", ".c": "代码", ".cpp": "代码", ".h": "代码", ".cs": "代码",
+  ".go": "代码", ".rs": "代码", ".rb": "代码", ".php": "代码", ".html": "代码", ".css": "代码",
+  ".json": "代码", ".xml": "代码", ".yml": "代码", ".yaml": "代码", ".sql": "代码", ".vue": "代码",
+  // 其他
+  ".ttf": "字体", ".otf": "字体", ".woff": "字体", ".woff2": "字体",
+  ".db": "数据库", ".sqlite": "数据库", ".sqlite3": "数据库", ".mdb": "数据库",
+  ".lnk": "快捷方式", ".url": "快捷方式", ".iso": "镜像", ".vhd": "镜像", ".vhdx": "镜像",
+  ".psd1": "代码", ".canvas": "其他",
+}));
+
+export const CATEGORY_ORDER = [
+  "文档", "表格", "演示", "PDF", "文本", "电子书", "图片", "视频", "音频",
+  "压缩包", "代码", "脚本", "安装包", "程序", "字体", "数据库", "镜像", "快捷方式", "其他",
+];
+
+export function categoryOf(ext) {
+  if (!ext) return "其他";
+  return CATEGORY_BY_EXT.get(String(ext).toLowerCase()) || "其他";
+}
+
+/** 能读正文的类型（P1 内容抽取用） */
+export const TEXT_EXTRACTABLE = new Set([
+  "文档", "表格", "演示", "PDF", "文本", "代码", "脚本",
+]);
+
+export const ORIGIN = Object.freeze({
+  DOWNLOAD: "我下载",
+  CHAT: "聊天收到",
+  TOOL: "工具/AI 产出",
+  DESKTOP: "桌面",
+  USER: "本地创建",
+  UNKNOWN: "未知",
+});
+
+const ORIGIN_RULES = [
+  [ORIGIN.CHAT, ["xwechat_files", "wechat", "微信", "\\qq\\", "tencent files", "\\msg\\file\\", "企业微信", "wxid_"]],
+  [ORIGIN.DOWNLOAD, ["download", "下载", "baidunetdiskdownload", "softboxdownload", "hrappstoredownload", "\\tmp\\download", "浏览器下载"]],
+  [ORIGIN.TOOL, ["deepseekharness", "\\.dsh\\", "错题本", "简历库", "openviking", "\\.agents\\", "dsh-plugin"]],
+  [ORIGIN.DESKTOP, ["\\desktop\\", "\\桌面", "desk\\"]],
+];
+
+/** 路径 -> 来源推断（不区分大小写包含匹配） */
+export function originOf(fullPath) {
+  const p = String(fullPath || "").toLowerCase();
+  for (const [origin, keys] of ORIGIN_RULES) {
+    for (const k of keys) if (p.includes(k)) return origin;
+  }
+  return ORIGIN.UNKNOWN;
+}
+
+/**
+ * 噪音判定：程序内部件、缓存件、无后缀的内部数据。
+ * 这类文件仍然入库（保持索引诚实），但默认不参与检索 —— 否则「其他」类会淹没真正要找的东西。
+ * 需要时可在 file_find 里用 includeNoise=true 显式包含。
+ */
+export const NOISE_EXT = new Set([
+  ".node", ".ico", ".icns", ".pyc", ".pyo", ".class", ".obj", ".pdb", ".ilk", ".lib", ".exp",
+  ".pak", ".bin", ".dat", ".db", ".sqlite", ".sqlite3", ".db-wal", ".db-shm", ".db-journal",
+  ".tmp", ".bak", ".extra", ".log", ".lock", ".pid", ".cache", ".etl", ".dmp",
+]);
+
+const HASH_NAME_RE = /^[0-9a-f]{16,}\./i;
+
+export function isNoise({ ext, name } = {}) {
+  const e = String(ext || "").toLowerCase();
+  if (NOISE_EXT.has(e)) return 1;
+  if (!e) return 1; // 无后缀：绝大多数是程序内部数据
+  if (HASH_NAME_RE.test(String(name || ""))) return 1; // 哈希命名 = 缓存件
+  return 0;
+}

package/core/format.mjs

@@ -0,0 +1,40 @@
+/** 文件快速寻回 · 展示层格式化（给人看的话，不出现术语） */
+
+export function humanSize(bytes) {
+  const n = Number(bytes) || 0;
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / 1048576).toFixed(1)} MB`;
+  return `${(n / 1073741824).toFixed(2)} GB`;
+}
+
+export function relTime(ms, now = Date.now()) {
+  if (!ms) return "时间未知";
+  const d = now - ms;
+  const min = Math.round(d / 60000);
+  if (min < 1) return "刚刚";
+  if (min < 60) return `${min} 分钟前`;
+  const hr = Math.round(min / 60);
+  if (hr < 24) return `${hr} 小时前`;
+  const day = Math.round(hr / 24);
+  if (day < 30) return `${day} 天前`;
+  const mon = Math.round(day / 30);
+  if (mon < 12) return `${mon} 个月前`;
+  return `${Math.round(mon / 12)} 年前`;
+}
+
+export function absTime(ms) {
+  if (!ms) return "-";
+  const d = new Date(ms);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+/** 中间省略的长路径 */
+export function shortPath(p, max = 76) {
+  const s = String(p || "");
+  if (s.length <= max) return s;
+  const keepTail = Math.floor(max * 0.65);
+  const keepHead = max - keepTail - 3;
+  return `${s.slice(0, keepHead)}...${s.slice(s.length - keepTail)}`;
+}

package/core/run-scan.mjs

@@ -0,0 +1,211 @@
+/**
+ * 文件快速寻回 · 子进程入口（扫描 + 每周校验 + 野文件巡查）
+ *
+ * 为什么独立进程：扫描要遍历几万个文件、还要抽文档正文（P1），
+ * 放在 DSH 主进程里会拖慢界面。这里只做 IO，算完写库就退出。
+ * 同一时间只允许一个实例（PID 锁文件）。
+ *
+ * 用法：node core/run-scan.mjs [--trigger=auto|manual|settings] [--no-patrol]
+ * 运行快照来自 ~/.dsh-lost-and-found/run.json（由 host 在派生前写入）。
+ */
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  openDb, upsertFile, startScanRun, finishScanRun, syncRoots,
+  setMeta, backupDb, counts, verifyBatch, lastScanMs, markRootScanned,
+} from "../db.mjs";
+import { dataDir, readRunSnapshot, ensureDataDir, resolveDbPath, DEFAULT_CONFIG, mergeDeep } from "../config.mjs";
+import { scanRoots, patrolDrives } from "./scan.mjs";
+import { computeSinceMs, verifyDue, rootSinceMs } from "./schedule.mjs";
+
+const args = Object.fromEntries(process.argv.slice(2).map((a) => {
+  const m = a.match(/^--([^=]+)(?:=(.*))?$/);
+  return m ? [m[1], m[2] === undefined ? true : m[2]] : [a, true];
+}));
+
+function log(msg) {
+  try { process.stdout.write(`[lost-and-found] ${msg}\n`); } catch { /* ignore */ }
+}
+
+// ---------- 单实例锁 ----------
+const lockPath = join(dataDir(), "scan.lock");
+ensureDataDir();
+try {
+  if (existsSync(lockPath)) {
+    const pid = Number(readFileSync(lockPath, "utf8").trim());
+    if (pid && pid !== process.pid) {
+      try {
+        process.kill(pid, 0); // 还活着
+        log(`已有扫描在进行中(pid=${pid})，本次跳过`);
+        process.exit(0);
+      } catch {
+        rmSync(lockPath, { force: true }); // 陈旧锁
+      }
+    }
+  }
+} catch { /* ignore */ }
+writeFileSync(lockPath, String(process.pid), "utf8");
+
+let exitCode = 0;
+let db = null;
+let runId = null;
+try {
+  const snap = (args.snapshot ? JSON.parse(readFileSync(String(args.snapshot), "utf8")) : readRunSnapshot()) || {};
+  const config = mergeDeep(structuredClone(DEFAULT_CONFIG), snap.config || {});
+  const dbPath = snap.dbPath || resolveDbPath(config);
+  const trigger = args.trigger || snap.trigger || "manual";
+  const roots = Array.isArray(snap.roots) ? snap.roots : [];
+  const excludes = snap.excludes || { dirs: [], patterns: [] };
+  const now = Date.now();
+
+  db = openDb(dbPath);
+  syncRoots(db, roots);
+  setMeta(db, "db_path", dbPath);
+  runId = startScanRun(db, trigger, roots.map((r) => r.path));
+  setMeta(db, "run_state", "running");
+  setMeta(db, "run_started_ms", String(now));
+  setMeta(db, "run_trigger", String(trigger));
+  setMeta(db, "run_files", "0");
+
+  if (!roots.length) {
+    finishScanRun(db, runId, { note: "未配置扫描目录" });
+    setMeta(db, "run_state", "idle");
+    setMeta(db, "run_note", "还没设置要扫描的文件夹（请在设置页添加，或点「一键扫描」）");
+    log("未配置扫描目录，已退出");
+    rmSync(lockPath, { force: true });
+    process.exit(0);
+  }
+
+  // ---- 逐目录收录起点（修「按扫描按钮却收不全」的核心）----
+  // 绝不能用单一全局 sinceMs：那会让「后加入的目录」只收到全局锚点之后 6 小时的文件，
+  // 该目录更早的历史文件永久漏收。这里给每个目录算它自己的起点。
+  const forceFull = args.full === true || snap.forceFull === true;
+  const globalSince = Number(snap.sinceMs) || 0;
+  const scanList = roots.map((r) => {
+    let own;
+    try {
+      own = rootSinceMs({ db, root: r, config, now, forceFull });
+    } catch (e) {
+      log(`目录锚点计算失败，退回全局窗口 ${r.path}: ${e && e.message ? e.message : e}`);
+      own = globalSince || computeSinceMs(db, config, now);
+    }
+    return { ...r, sinceMs: own };
+  });
+  const sinceMs = scanList.length ? Math.min(...scanList.map((r) => Number(r.sinceMs) || 0)) : computeSinceMs(db, config, now);
+  log(`开始扫描 ${scanList.length} 个文件夹（逐目录锚点${forceFull ? "｜本次强制全量" : ""}）`);
+  for (const r of scanList) {
+    log(`  · ${r.path} → ${r.sinceMs > 0 ? `收录 ${new Date(r.sinceMs).toLocaleString()} 之后` : "收录全部历史文件"}`);
+  }
+
+  const stats = { added: 0, updated: 0, errors: 0, skippedDirs: 0, candidates: 0 };
+  let sinceFlush = 0;
+  const result = await scanRoots({
+    roots: scanList,
+    excludes,
+    sinceMs,
+    logger: log,
+    onCandidate(rec) {
+      try {
+        const r = upsertFile(db, rec);
+        if (r === "added") stats.added++; else stats.updated++;
+      } catch (e) {
+        stats.errors++;
+        log(`入库失败 ${rec.path}: ${e && e.message ? e.message : e}`);
+      }
+      if (++sinceFlush >= 200) {
+        sinceFlush = 0;
+        setMeta(db, "run_files", String(stats.added + stats.updated));
+      }
+    },
+  });
+  stats.errors += result.errors;
+  stats.skippedDirs = result.skippedDirs;
+  stats.candidates = result.candidates;
+
+  // ---- 只给「真的走完」的目录推进锚点 ----
+  // 中断/根目录不可读的目录保持原锚点（first_scan_done 仍为 0），下次扫描会继续补，
+  // 不会再出现「扫了一半却把锚点推到最新、剩余文件永久漏收」。
+  const rootsDone = [];
+  const rootsSkipped = [];
+  for (const r of result.roots || []) {
+    if (!r.completed) {
+      rootsSkipped.push(r.path);
+      log(`  ! 未扫完，本次不推进锚点：${r.path}`);
+      continue;
+    }
+    if (markRootScanned(db, r.path, now)) rootsDone.push(r.path);
+  }
+  log(`锚点已推进 ${rootsDone.length} 个目录${rootsSkipped.length ? `，保留 ${rootsSkipped.length} 个（未扫完）` : ""}`);
+
+  // ---- 每周一次的存在性校验（首次扫描不校验，那时还没有旧记录） ----
+  const isFirstScan = lastScanMs(db) === 0;
+  if (args.verify !== "false" && !isFirstScan && verifyDue(db, now)) {
+    const v = verifyBatch(db, Number(args.verifyLimit) || 800);
+    log(`校验扫描：检查 ${v.checked} 个已记录文件，其中 ${v.missing} 个已不在此处`);
+  }
+
+  // ---- 野文件巡查（白名单外的新目录） ----
+  if (config.patrolEnabled && args.patrol !== "false") {
+    const drives = (snap.drives && snap.drives.length ? snap.drives : ["C:", "D:"]).map((d) => (d.endsWith(":") ? d + "\\" : d));
+    const patrolSince = Number(snap.patrolSinceMs) || now - 86400000;
+    const { suggestions, stats: pstats } = await patrolDrives({
+      drives,
+      excludes,
+      sinceMs: patrolSince,
+      coveredRoots: roots.map((r) => r.path),
+      maxDepth: Number(args.patrolDepth) || 4,
+      minFiles: 3,
+    });
+    const stmt = db.prepare(`INSERT INTO patrol (dir, files, sample, first_seen_ms, last_seen_ms, status)
+      VALUES (?, ?, ?, ?, ?, 'new')
+      ON CONFLICT(dir) DO UPDATE SET files = excluded.files, sample = excluded.sample,
+        last_seen_ms = excluded.last_seen_ms, status = 'new'`);
+    for (const s of suggestions) {
+      try { stmt.run(s.dir, s.files, s.sample ?? null, now, now); } catch { /* ignore */ }
+    }
+    log(`野文件巡查：看了 ${pstats.scannedDirs} 个目录，发现 ${suggestions.length} 个白名单外有新文件的目录`);
+  }
+
+  finishScanRun(db, runId, {
+    added: stats.added, updated: stats.updated, missing: 0,
+    skippedDirs: stats.skippedDirs, errors: stats.errors,
+    note: `扫描 ${result.total} 个文件，命中新增 ${result.candidates} 个；锚点推进 ${rootsDone.length} 个目录`
+      + (rootsSkipped.length ? `，${rootsSkipped.length} 个未扫完` : ""),
+  });
+  setMeta(db, "last_scan_ms", String(Date.now()));
+  setMeta(db, "run_state", "idle");
+  setMeta(db, "run_note", null);
+  setMeta(db, "run_files", String(stats.added + stats.updated));
+
+  if (Number(config.backupKeep) > 0) {
+    const b = backupDb(dbPath, Number(config.backupKeep));
+    if (b) log(`已备份索引库到 ${b}`);
+  }
+
+  const c = counts(db);
+  log(`完成：新增 ${stats.added}，更新 ${stats.updated}，库内共 ${c.total} 个文件`);
+  console.log("===LAF_RUN_RESULT===");
+  console.log(JSON.stringify({
+    ok: true, trigger, scannedFiles: result.total, candidates: result.candidates,
+    added: stats.added, updated: stats.updated, skippedDirs: stats.skippedDirs,
+    errors: stats.errors, sinceMs, total: c.total, runId,
+    forceFull, rootsDone, rootsSkipped, roots: result.roots || [],
+  }, null, 2));
+} catch (e) {
+  exitCode = 1;
+  const msg = e && e.stack ? e.stack : String(e);
+  log(`扫描失败：${msg}`);
+  try {
+    if (db) {
+      setMeta(db, "run_state", "error");
+      setMeta(db, "run_note", msg.slice(0, 500));
+      if (runId) finishScanRun(db, runId, { errors: 1, note: msg.slice(0, 300) });
+    }
+  } catch { /* ignore */ }
+  console.log("===LAF_RUN_RESULT===");
+  console.log(JSON.stringify({ ok: false, error: msg.slice(0, 500) }, null, 2));
+} finally {
+  try { if (db) db.close(); } catch { /* ignore */ }
+  try { rmSync(lockPath, { force: true }); } catch { /* ignore */ }
+}
+process.exit(exitCode);