@mison/wecom-cleaner 1.0.0 → 1.1.0

package/src/config.js

@@ -4,6 +4,25 @@ import { ensureDir, expandHome, readJson, writeJson } from './utils.js';
 import { normalizeRecycleRetention } from './recycle-maintenance.js';
 
 const ALLOWED_THEMES = new Set(['auto', 'light', 'dark']);
+const ALLOWED_OUTPUTS = new Set(['json', 'text']);
+const ALLOWED_CONFLICT_STRATEGIES = new Set(['skip', 'overwrite', 'rename']);
+const ALLOWED_EXTERNAL_ROOT_SOURCES = new Set(['preset', 'configured', 'auto', 'all']);
+const ALLOWED_GOVERNANCE_TIERS = new Set(['safe', 'caution', 'protected']);
+const ACTION_FLAG_MAP = new Map([
+  ['--cleanup-monthly', 'cleanup_monthly'],
+  ['--analysis-only', 'analysis_only'],
+  ['--space-governance', 'space_governance'],
+  ['--recycle-maintain', 'recycle_maintain'],
+  ['--doctor', 'doctor'],
+]);
+const MODE_TO_ACTION_MAP = new Map([
+  ['cleanup_monthly', 'cleanup_monthly'],
+  ['analysis_only', 'analysis_only'],
+  ['space_governance', 'space_governance'],
+  ['recycle_maintain', 'recycle_maintain'],
+  ['restore', 'restore'],
+  ['doctor', 'doctor'],
+]);
 
 export class CliArgError extends Error {
   constructor(message) {
@@ -23,6 +42,42 @@ function normalizeTheme(theme) {
   return normalized;
 }
 
+function normalizeOutput(output) {
+  if (typeof output !== 'string') {
+    return null;
+  }
+  const normalized = output.trim().toLowerCase();
+  if (!ALLOWED_OUTPUTS.has(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+
+function parseCsvList(rawValue) {
+  return String(rawValue || '')
+    .split(/[,\n;]/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parsePositiveInteger(flag, rawValue) {
+  const num = Number.parseInt(String(rawValue || ''), 10);
+  if (!Number.isFinite(num) || num < 1) {
+    throw new CliArgError(`参数 ${flag} 的值必须是 >= 1 的整数: ${rawValue}`);
+  }
+  return num;
+}
+
+function parseEnumValue(flag, rawValue, allowedSet) {
+  const normalized = String(rawValue || '')
+    .trim()
+    .toLowerCase();
+  if (!allowedSet.has(normalized)) {
+    throw new CliArgError(`参数 ${flag} 的值无效: ${rawValue}`);
+  }
+  return normalized;
+}
+
 export function defaultConfig() {
   const stateRoot = DEFAULT_STATE_ROOT;
   const recycleRetention = normalizeRecycleRetention({
@@ -91,9 +146,35 @@ export function parseCliArgs(argv) {
     dryRunDefault: null,
     mode: null,
     theme: null,
+    output: null,
+    dryRun: null,
+    yes: false,
+    saveConfig: false,
     jsonOutput: false,
     force: false,
+    interactive: false,
+    action: null,
+    actionFromMode: false,
+    actionFlagCount: 0,
+    restoreBatchId: null,
+    accounts: null,
+    months: null,
+    cutoffMonth: null,
+    categories: null,
+    includeNonMonthDirs: null,
+    externalRoots: null,
+    externalRootsSource: null,
+    targets: null,
+    tiers: null,
+    suggestedOnly: null,
+    allowRecentActive: null,
+    conflict: null,
+    retentionEnabled: null,
+    retentionMaxAgeDays: null,
+    retentionMinKeepBatches: null,
+    retentionSizeThresholdGB: null,
   };
+  const actionValues = [];
 
   const takeValue = (flag, index) => {
     const value = argv[index + 1];
@@ -116,6 +197,12 @@ export function parseCliArgs(argv) {
 
   for (let i = 0; i < argv.length; i += 1) {
     const token = argv[i];
+    if (ACTION_FLAG_MAP.has(token)) {
+      parsed.action = ACTION_FLAG_MAP.get(token);
+      parsed.actionFlagCount += 1;
+      actionValues.push(parsed.action);
+      continue;
+    }
     if (token === '--root') {
       parsed.rootDir = takeValue(token, i);
       i += 1;
@@ -146,6 +233,14 @@ export function parseCliArgs(argv) {
       i += 1;
       continue;
     }
+    if (token === '--restore-batch') {
+      parsed.restoreBatchId = takeValue(token, i);
+      parsed.action = 'restore';
+      parsed.actionFlagCount += 1;
+      actionValues.push('restore');
+      i += 1;
+      continue;
+    }
     if (token === '--theme') {
       const theme = normalizeTheme(takeValue(token, i));
       if (!theme) {
@@ -155,6 +250,28 @@ export function parseCliArgs(argv) {
       i += 1;
       continue;
     }
+    if (token === '--output') {
+      const output = normalizeOutput(takeValue(token, i));
+      if (!output) {
+        throw new CliArgError(`参数 --output 的值无效: ${argv[i + 1]}`);
+      }
+      parsed.output = output;
+      i += 1;
+      continue;
+    }
+    if (token === '--dry-run') {
+      parsed.dryRun = parseBooleanFlag(token, takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--yes') {
+      parsed.yes = true;
+      continue;
+    }
+    if (token === '--save-config') {
+      parsed.saveConfig = true;
+      continue;
+    }
     if (token === '--json') {
       parsed.jsonOutput = true;
       continue;
@@ -163,11 +280,140 @@ export function parseCliArgs(argv) {
       parsed.force = true;
       continue;
     }
+    if (token === '--interactive') {
+      parsed.interactive = true;
+      continue;
+    }
+    if (token === '--accounts') {
+      parsed.accounts = parseCsvList(takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--months') {
+      parsed.months = parseCsvList(takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--cutoff-month') {
+      parsed.cutoffMonth = takeValue(token, i);
+      i += 1;
+      continue;
+    }
+    if (token === '--categories') {
+      parsed.categories = parseCsvList(takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--include-non-month-dirs') {
+      parsed.includeNonMonthDirs = parseBooleanFlag(token, takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--external-roots') {
+      parsed.externalRoots = parseCsvList(takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--external-roots-source') {
+      const sourceValues = parseCsvList(takeValue(token, i)).map((item) => item.toLowerCase());
+      if (sourceValues.length === 0) {
+        throw new CliArgError('参数 --external-roots-source 至少需要一个值');
+      }
+      for (const source of sourceValues) {
+        if (!ALLOWED_EXTERNAL_ROOT_SOURCES.has(source)) {
+          throw new CliArgError(`参数 --external-roots-source 的值无效: ${source}`);
+        }
+      }
+      parsed.externalRootsSource = sourceValues;
+      i += 1;
+      continue;
+    }
+    if (token === '--targets') {
+      parsed.targets = parseCsvList(takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--tiers') {
+      const values = parseCsvList(takeValue(token, i)).map((item) => item.toLowerCase());
+      if (values.length === 0) {
+        throw new CliArgError('参数 --tiers 至少需要一个值');
+      }
+      for (const tier of values) {
+        if (!ALLOWED_GOVERNANCE_TIERS.has(tier)) {
+          throw new CliArgError(`参数 --tiers 的值无效: ${tier}`);
+        }
+      }
+      parsed.tiers = values;
+      i += 1;
+      continue;
+    }
+    if (token === '--suggested-only') {
+      parsed.suggestedOnly = parseBooleanFlag(token, takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--allow-recent-active') {
+      parsed.allowRecentActive = parseBooleanFlag(token, takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--conflict') {
+      parsed.conflict = parseEnumValue(token, takeValue(token, i), ALLOWED_CONFLICT_STRATEGIES);
+      i += 1;
+      continue;
+    }
+    if (token === '--retention-enabled') {
+      parsed.retentionEnabled = parseBooleanFlag(token, takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--retention-max-age-days') {
+      parsed.retentionMaxAgeDays = parsePositiveInteger(token, takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--retention-min-keep-batches') {
+      parsed.retentionMinKeepBatches = parsePositiveInteger(token, takeValue(token, i));
+      i += 1;
+      continue;
+    }
+    if (token === '--retention-size-threshold-gb') {
+      parsed.retentionSizeThresholdGB = parsePositiveInteger(token, takeValue(token, i));
+      i += 1;
+      continue;
+    }
     if (token.startsWith('-')) {
       throw new CliArgError(`不支持的参数: ${token}`);
     }
   }
 
+  if (parsed.months && parsed.cutoffMonth) {
+    throw new CliArgError('参数 --months 与 --cutoff-month 不能同时使用');
+  }
+
+  if (parsed.actionFlagCount > 1 || new Set(actionValues).size > 1) {
+    throw new CliArgError('动作参数冲突：一次只能指定一个动作（如 --cleanup-monthly）');
+  }
+
+  if (parsed.mode && parsed.action) {
+    throw new CliArgError('参数 --mode 不能与动作参数同时使用');
+  }
+
+  if (parsed.mode && !parsed.action) {
+    const mapped = MODE_TO_ACTION_MAP.get(String(parsed.mode || '').trim());
+    if (mapped) {
+      parsed.action = mapped;
+      parsed.actionFromMode = true;
+    }
+  }
+
+  if (parsed.jsonOutput) {
+    if (parsed.output && parsed.output !== 'json') {
+      throw new CliArgError('参数 --json 与 --output text 不能同时使用');
+    }
+    parsed.output = 'json';
+  }
+
   return parsed;
 }
 

package/src/doctor.js

@@ -331,7 +331,7 @@ export async function runDoctor({ config, aliases, projectRoot, appVersion }) {
       '回收区健康',
       recycleOverThreshold ? STATUS_WARN : STATUS_PASS,
       `批次 ${recycleStats.totalBatches} 个，容量 ${recycleStats.totalBytes} bytes，阈值 ${thresholdBytes} bytes`,
-      recycleOverThreshold ? '建议执行回收区治理（--mode recycle_maintain）。' : ''
+      recycleOverThreshold ? '建议执行回收区治理（--recycle-maintain）。' : ''
     )
   );
 

package/src/lock.js

@@ -63,11 +63,12 @@ export async function breakLock(lockPath) {
   await fs.rm(lockPath, { force: true });
 }
 
-export async function acquireLock(stateRoot, mode) {
+export async function acquireLock(stateRoot, mode, options = {}) {
+  const allowStaleBreak = options.allowStaleBreak !== false;
   const lockPath = resolveLockPath(stateRoot);
   await fs.mkdir(path.dirname(lockPath), { recursive: true });
 
-  const payload = {
+  const payloadBase = {
     pid: process.pid,
     mode: String(mode || 'unknown'),
     startedAt: Date.now(),
@@ -75,28 +76,55 @@ export async function acquireLock(stateRoot, mode) {
     version: process.env.npm_package_version || null,
   };
 
-  try {
-    await writeLockFile(lockPath, payload);
-  } catch (error) {
-    if (error && error.code !== 'EEXIST') {
-      throw error;
-    }
+  let recoveredFromStale = false;
+  let staleLockInfo = null;
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const payload = recoveredFromStale
+      ? {
+          ...payloadBase,
+          recoveredFromStale: true,
+          recoveredAt: Date.now(),
+          staleLockPid: staleLockInfo?.pid || null,
+        }
+      : payloadBase;
+
+    try {
+      await writeLockFile(lockPath, payload);
+      return {
+        lockPath,
+        lockInfo: payload,
+        async release() {
+          await fs.rm(lockPath, { force: true }).catch(() => {});
+        },
+      };
+    } catch (error) {
+      if (error && error.code !== 'EEXIST') {
+        throw error;
+      }
 
-    const lockInfo = await readLockInfo(lockPath);
-    const lockPid = Number.parseInt(String(lockInfo?.pid || ''), 10);
-    const isStale = !isProcessRunning(lockPid);
-    throw new LockHeldError('检测到另一个实例正在运行', {
-      lockPath,
-      lockInfo,
-      isStale,
-    });
+      const lockInfo = await readLockInfo(lockPath);
+      const lockPid = Number.parseInt(String(lockInfo?.pid || ''), 10);
+      const isStale = !isProcessRunning(lockPid);
+
+      if (isStale && allowStaleBreak && attempt === 0) {
+        staleLockInfo = lockInfo;
+        recoveredFromStale = true;
+        await fs.rm(lockPath, { force: true }).catch(() => {});
+        continue;
+      }
+
+      throw new LockHeldError('检测到另一个实例正在运行', {
+        lockPath,
+        lockInfo,
+        isStale,
+      });
+    }
   }
 
-  return {
+  throw new LockHeldError('检测到锁文件冲突，且自动恢复失败', {
     lockPath,
-    lockInfo: payload,
-    async release() {
-      await fs.rm(lockPath, { force: true }).catch(() => {});
-    },
-  };
+    lockInfo: staleLockInfo,
+    isStale: Boolean(staleLockInfo),
+  });
 }

package/src/native-bridge.js

@@ -5,7 +5,7 @@ import { createHash, randomUUID } from 'node:crypto';
 
 const NATIVE_CACHE_DIR = 'native-cache';
 const MANIFEST_RELATIVE_PATH = path.join('native', 'manifest.json');
-const DEFAULT_DOWNLOAD_BASE_URL = 'https://raw.githubusercontent.com/MisonL/wecom-cleaner/v1.0.0/native/bin';
+const DEFAULT_DOWNLOAD_REPO_BASE_URL = 'https://raw.githubusercontent.com/MisonL/wecom-cleaner';
 const DEFAULT_DOWNLOAD_TIMEOUT_MS = 15_000;
 const DEFAULT_PROBE_TIMEOUT_MS = 3_000;
 
@@ -219,6 +219,20 @@ function resolveManifestVersion(manifest) {
   return null;
 }
 
+function resolveReleaseTag(version) {
+  const normalized = String(version || '').trim();
+  if (!normalized) {
+    return null;
+  }
+  return normalized.startsWith('v') ? normalized : `v${normalized}`;
+}
+
+function resolveDefaultDownloadBaseUrl(manifest) {
+  const releaseTag = resolveReleaseTag(resolveManifestVersion(manifest));
+  const ref = releaseTag || 'main';
+  return `${DEFAULT_DOWNLOAD_REPO_BASE_URL}/${ref}/native/bin`;
+}
+
 function resolveDownloadUrl({ target, manifest, manifestTarget }) {
   const fileName = manifestTarget?.binaryName || target.binaryName;
   const overrideBaseUrl = getDownloadBaseUrlOverride();
@@ -239,7 +253,7 @@ function resolveDownloadUrl({ target, manifest, manifestTarget }) {
     return `${manifestBaseUrl}/${target.targetTag}/${fileName}`;
   }
 
-  return `${DEFAULT_DOWNLOAD_BASE_URL}/${target.targetTag}/${fileName}`;
+  return `${resolveDefaultDownloadBaseUrl(manifest)}/${target.targetTag}/${fileName}`;
 }
 
 async function verifySha256OrReason(filePath, expectedSha256) {

package/src/recycle-maintenance.js

@@ -201,7 +201,11 @@ export function selectBatchesForMaintenance(batches, policy, now = Date.now()) {
 export async function maintainRecycleBin({ indexPath, recycleRoot, policy, dryRun, onProgress }) {
   const normalizedPolicy = normalizeRecycleRetention(policy);
   const now = Date.now();
-  const before = await collectRecycleStats({ indexPath, recycleRoot });
+  const before = await collectRecycleStats({
+    indexPath,
+    recycleRoot,
+    createIfMissing: !dryRun,
+  });
   const selected = selectBatchesForMaintenance(before.batches, normalizedPolicy, now);
   const thresholdBytes = selected.thresholdBytes;
 

package/src/restore.js

@@ -262,6 +262,21 @@ async function validateRestoreEntryPath({ originalPath, recyclePath, scope, vali
   return null;
 }
 
+function buildRestoreAuditMeta(entry = {}) {
+  return {
+    accountId: entry.accountId || null,
+    accountShortId: entry.accountShortId || null,
+    userName: entry.userName || null,
+    corpName: entry.corpName || null,
+    categoryKey: entry.categoryKey || null,
+    categoryLabel: entry.categoryLabel || null,
+    monthKey: entry.monthKey || null,
+    targetKey: entry.targetKey || null,
+    tier: entry.tier || null,
+    sizeBytes: Number(entry.sizeBytes || 0),
+  };
+}
+
 export async function listRestorableBatches(indexPath, options = {}) {
   const recycleRoot = typeof options.recycleRoot === 'string' ? options.recycleRoot : null;
   const restoredSet = new Set();
@@ -354,6 +369,7 @@ export async function restoreBatch({
     const recyclePath = entry.recyclePath;
     const originalPath = entry.sourcePath;
     const scope = typeof entry.scope === 'string' && entry.scope ? entry.scope : 'cleanup_monthly';
+    const auditMeta = buildRestoreAuditMeta(entry);
     const invalidPathReason = await validateRestoreEntryPath({
       originalPath,
       recyclePath,
@@ -370,6 +386,7 @@ export async function restoreBatch({
         batchId: batch.batchId,
         recyclePath,
         sourcePath: originalPath,
+        ...auditMeta,
         status: 'skipped_invalid_path',
         error_type: ERROR_TYPES.PATH_VALIDATION_FAILED,
         invalid_reason: invalidPathReason,
@@ -391,6 +408,7 @@ export async function restoreBatch({
         batchId: batch.batchId,
         recyclePath,
         sourcePath: originalPath,
+        ...auditMeta,
         status: 'skipped_missing_recycle',
         error_type: ERROR_TYPES.PATH_NOT_FOUND,
         profile_root: profileRoot,
@@ -436,6 +454,7 @@ export async function restoreBatch({
           batchId: batch.batchId,
           recyclePath,
           sourcePath: originalPath,
+          ...auditMeta,
           status: 'skipped_conflict',
           error_type: ERROR_TYPES.CONFLICT,
           profile_root: profileRoot,
@@ -464,6 +483,7 @@ export async function restoreBatch({
         recyclePath,
         sourcePath: originalPath,
         restoredPath: targetPath,
+        ...auditMeta,
         status: 'dry_run',
         dryRun: true,
         conflict_strategy: conflictStrategy,
@@ -493,6 +513,7 @@ export async function restoreBatch({
         recyclePath,
         sourcePath: originalPath,
         restoredPath: targetPath,
+        ...auditMeta,
         status: 'success',
         dryRun: false,
         profile_root: profileRoot,
@@ -516,6 +537,7 @@ export async function restoreBatch({
         batchId: batch.batchId,
         recyclePath,
         sourcePath: originalPath,
+        ...auditMeta,
         status: 'failed',
         error_type: classifyErrorType(error instanceof Error ? error.message : String(error)),
         dryRun: false,

package/src/scanner.js

@@ -31,6 +31,17 @@ const EXTERNAL_SOURCE_AUTO = 'auto';
 const EXTERNAL_STORAGE_SCAN_MAX_DEPTH_DEFAULT = 2;
 const EXTERNAL_STORAGE_SCAN_MAX_VISITS_DEFAULT = 400;
 const EXTERNAL_STORAGE_CACHE_TTL_MS_DEFAULT = 15_000;
+const EXTERNAL_STORAGE_KNOWN_CATEGORY_DIRS = new Set(
+  CACHE_CATEGORIES.map((item) => {
+    const relativePath = String(item?.relativePath || '');
+    if (!relativePath.startsWith('Caches/')) {
+      return null;
+    }
+    const suffix = relativePath.slice('Caches/'.length);
+    const [head] = suffix.split(/[\\/]+/).filter(Boolean);
+    return head ? head.toLowerCase() : null;
+  }).filter(Boolean)
+);
 const EXTERNAL_STORAGE_SCAN_SKIP_NAMES = new Set([
   '.',
   '..',
@@ -150,6 +161,45 @@ async function isDirectoryPath(targetPath) {
   return Boolean(stat?.isDirectory());
 }
 
+async function detectExternalStorageMarkers(cacheRoot) {
+  const entries = await listDirectoryEntries(cacheRoot);
+  const categoryDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const knownCategoryDirs = categoryDirs.filter((name) =>
+    EXTERNAL_STORAGE_KNOWN_CATEGORY_DIRS.has(name.toLowerCase())
+  );
+
+  let monthLikeCategoryCount = 0;
+  for (const categoryName of knownCategoryDirs) {
+    const childDirs = await listSubDirectories(path.join(cacheRoot, categoryName));
+    if (childDirs.some((dirName) => normalizeMonthKey(dirName))) {
+      monthLikeCategoryCount += 1;
+    }
+  }
+
+  return {
+    knownCategoryCount: knownCategoryDirs.length,
+    monthLikeCategoryCount,
+  };
+}
+
+async function isLikelyExternalStorageRoot(rootPath, options = {}) {
+  const strictMarkers = options.strictMarkers === true;
+  const cacheRoot = path.join(rootPath, EXTERNAL_STORAGE_CACHE_RELATIVE);
+  if (!(await isDirectoryPath(cacheRoot))) {
+    return false;
+  }
+
+  if (!strictMarkers) {
+    return true;
+  }
+
+  const markers = await detectExternalStorageMarkers(cacheRoot);
+  if (markers.monthLikeCategoryCount >= 1) {
+    return true;
+  }
+  return markers.knownCategoryCount >= 2;
+}
+
 function normalizeExternalStorageRootCandidate(rawPath) {
   const input = String(rawPath || '').trim();
   if (!input) {
@@ -169,13 +219,13 @@ function normalizeExternalStorageRootCandidate(rawPath) {
   return normalized;
 }
 
-async function resolveExternalStorageRoot(rawPath) {
+async function resolveExternalStorageRoot(rawPath, options = {}) {
   const root = normalizeExternalStorageRootCandidate(rawPath);
   if (!root) {
     return null;
   }
-  const cacheRoot = path.join(root, EXTERNAL_STORAGE_CACHE_RELATIVE);
-  if (!(await isDirectoryPath(cacheRoot))) {
+  const likely = await isLikelyExternalStorageRoot(root, options);
+  if (!likely) {
     return null;
   }
   return root;
@@ -227,10 +277,7 @@ function collectBuiltInStorageRootCandidates(options = {}) {
 async function collectDefaultExternalSearchBaseRoots() {
   const bases = new Set();
   const home = os.homedir();
-  bases.add(home);
   bases.add(path.join(home, 'Documents'));
-  bases.add(path.join(home, 'Desktop'));
-  bases.add(path.join(home, 'Downloads'));
 
   const volumeEntries = await fs.readdir('/Volumes', { withFileTypes: true }).catch(() => []);
   for (const entry of volumeEntries) {
@@ -623,10 +670,11 @@ export async function detectExternalStorageRoots(options = {}) {
     autoDetectedRootCount: 0,
     truncatedRoots: [],
     visitedDirs: 0,
+    autoRejectedRootCount: 0,
   };
 
   for (const candidate of builtInCandidates) {
-    const root = await resolveExternalStorageRoot(candidate);
+    const root = await resolveExternalStorageRoot(candidate, { strictMarkers: true });
     if (!root || seen.has(root)) {
       continue;
     }
@@ -636,7 +684,7 @@ export async function detectExternalStorageRoots(options = {}) {
   }
 
   for (const candidate of configuredRoots) {
-    const root = await resolveExternalStorageRoot(candidate);
+    const root = await resolveExternalStorageRoot(candidate, { strictMarkers: false });
     if (!root || seen.has(root)) {
       continue;
     }
@@ -651,16 +699,26 @@ export async function detectExternalStorageRoots(options = {}) {
         ? options.searchBaseRoots
         : await collectDefaultExternalSearchBaseRoots();
     const autoScan = await findExternalStorageRootsByStructure(baseRoots, options);
-    autoDetectMeta = autoScan.meta;
+    autoDetectMeta = {
+      ...autoScan.meta,
+      autoRejectedRootCount: 0,
+    };
     for (const root of autoScan.roots) {
-      const normalized = await resolveExternalStorageRoot(root);
+      const normalized = await resolveExternalStorageRoot(root, { strictMarkers: true });
       if (!normalized || seen.has(normalized)) {
+        if (!normalized) {
+          autoDetectMeta.autoRejectedRootCount += 1;
+        }
         continue;
       }
       seen.add(normalized);
       resolved.push(normalized);
       sourceByRoot.set(normalized, EXTERNAL_SOURCE_AUTO);
     }
+    autoDetectMeta.autoDetectedRootCount = Math.max(
+      0,
+      autoScan.roots.length - autoDetectMeta.autoRejectedRootCount
+    );
   }
 
   resolved.sort();
@@ -687,6 +745,7 @@ export async function detectExternalStorageRoots(options = {}) {
   const meta = {
     searchedRootsCount: autoDetectMeta.searchedRootsCount,
     autoDetectedRootCount: autoDetectMeta.autoDetectedRootCount,
+    autoRejectedRootCount: autoDetectMeta.autoRejectedRootCount,
     truncatedRoots: autoDetectMeta.truncatedRoots,
     visitedDirs: autoDetectMeta.visitedDirs,
     resolvedRootCount: resolved.length,