tanmi-dock 1.0.3 → 1.0.5-beta

package/dist/commands/check.js

@@ -9,14 +9,91 @@ import { getDiskInfo, formatSize } from '../utils/disk.js';
 import * as config from '../core/config.js';
 import { getRegistry } from '../core/registry.js';
 import * as store from '../core/store.js';
-import { KNOWN_PLATFORM_VALUES } from '../core/platform.js';
-import { info, warn, success, error, hint, blank, title, separator, colorize, debug, } from '../utils/logger.js';
+import { GENERAL_PLATFORM, KNOWN_PLATFORM_VALUES, SHARED_PLATFORM } from '../core/platform.js';
+import { SpaceService } from '../core/space/service.js';
+import { CleanupJournal } from '../core/space/cleanup-journal.js';
+import { MigrationJournal } from '../core/space/migration-journal.js';
+import { withGlobalLock } from '../utils/global-lock.js';
+import { info, warn, success, error, hint, blank, title, separator, colorize, debug, withStdoutLogsSuppressed, } from '../utils/logger.js';
 import { selectWithCancel, checkboxWithCancel, confirmWithCancel, PROMPT_CANCELLED, } from '../utils/prompt.js';
+function createSpaceProgressRenderer(label) {
+    let lineWidth = 0;
+    let lastReported = -1;
+    const close = () => {
+        if (lineWidth > 0 && process.stdout.isTTY) {
+            process.stdout.write(`\r${' '.repeat(lineWidth)}\r`);
+        }
+        lineWidth = 0;
+    };
+    return {
+        update(progress) {
+            if (progress.phase === 'completed') {
+                close();
+                return;
+            }
+            const message = progress.phase === 'measure-store'
+                ? `${label}: 正在汇总 Store 总占用...`
+                : `${label}: ${progress.completedCommits}/${progress.totalCommits} 个版本`;
+            if (process.stdout.isTTY) {
+                const padded = message.padEnd(Math.max(lineWidth, message.length));
+                lineWidth = padded.length;
+                process.stdout.write(`\r${padded}`);
+                return;
+            }
+            const interval = Math.max(1, Math.ceil(progress.totalCommits / 10));
+            const shouldReport = progress.phase === 'measure-store' ||
+                progress.completedCommits === 0 ||
+                progress.completedCommits === progress.totalCommits ||
+                progress.completedCommits - lastReported >= interval;
+            if (shouldReport && progress.completedCommits !== lastReported) {
+                info(message);
+                lastReported = progress.completedCommits;
+            }
+        },
+        close,
+    };
+}
+function createCheckProgressRenderer() {
+    const spaceProgress = createSpaceProgressRenderer('[3/3] 正在审计 Store 空间');
+    return (progress) => {
+        if (progress.stage === 'space' && progress.state === 'progress') {
+            spaceProgress.update(progress.progress);
+            return;
+        }
+        if (progress.stage === 'space')
+            spaceProgress.close();
+        const indexes = { environment: 1, integrity: 2, space: 3 };
+        if (progress.state === 'started') {
+            const messages = {
+                environment: '正在检查运行环境...',
+                integrity: '正在核对项目与依赖...',
+                space: '正在审计 Store 空间...',
+            };
+            info(`[${indexes[progress.stage]}/3] ${messages[progress.stage]}`);
+        }
+        else if (progress.state === 'completed') {
+            const messages = {
+                environment: '运行环境检查完成',
+                integrity: '项目与依赖核对完成',
+                space: 'Store 空间审计完成',
+            };
+            info(`[${indexes[progress.stage]}/3] ${messages[progress.stage]}`);
+        }
+        else if (progress.state === 'failed') {
+            const labels = {
+                environment: '运行环境',
+                integrity: '项目与依赖',
+                space: 'Store 空间',
+            };
+            warn(`[${indexes[progress.stage]}/3] ${labels[progress.stage]}检查失败: ${progress.error ?? '未知错误'}`);
+        }
+    };
+}
 // ============ 命令创建 ============
 export function createCheckCommand() {
     return new Command('check')
         .description('健康检查（环境诊断 + 数据一致性验证）')
-        .option('--fix', '直接修复所有问题')
+        .option('--fix', '直接修复所有可修复问题')
         .option('--dry-run', '只显示问题，不修复')
         .option('--json', '输出 JSON 格式')
         .option('--force', '跳过确认')
@@ -27,7 +104,26 @@ export function createCheckCommand() {
 }
 // ============ 主流程 ============
 async function runCheck(options) {
-    const result = await collectAllIssues({ integrity: options.integrity });
+    if (options.json) {
+        await withStdoutLogsSuppressed(() => runCheckInternal(options));
+        return;
+    }
+    await runCheckInternal(options);
+}
+async function runCheckInternal(options) {
+    debug(`[check] 命令输入: fix=${options.fix}, dryRun=${options.dryRun}, json=${options.json}, force=${options.force}, integrity=${options.integrity}`);
+    if (options.dryRun) {
+        const cfg = await config.load({ migrate: false });
+        if (cfg && config.checkConfigVersion(cfg) === 'migrate') {
+            error('配置需要迁移；dry-run 不会修改配置，请先运行一次普通命令完成迁移');
+            return;
+        }
+    }
+    const result = await collectAllIssues({
+        integrity: options.integrity,
+        readOnly: options.dryRun,
+        onProgress: options.json ? undefined : createCheckProgressRenderer(),
+    });
     // JSON 输出
     if (options.json) {
         console.log(JSON.stringify(result, null, 2));
@@ -35,13 +131,15 @@ async function runCheck(options) {
     }
     // 渲染报告
     renderReport(result);
-    const hasIssues = result.summary.integrityIssues > 0;
+    const hasIntegrityIssues = result.summary.integrityIssues > 0;
+    const hasReportedIssues = hasIntegrityIssues || result.summary.spaceIssues > 0;
+    const hasRepairableIssues = hasIntegrityIssues || hasSpaceCalibrationChoice(result.space);
     const hasEnvErrors = result.summary.envErrors > 0;
     // dry-run 模式
     if (options.dryRun) {
-        if (hasIssues) {
+        if (hasRepairableIssues) {
             blank();
-            hint('运行 td check --fix 修复问题');
+            hint('运行 td check --fix 修复可修复问题');
         }
         return;
     }
@@ -52,21 +150,90 @@ async function runCheck(options) {
         return;
     }
     // 无问题
-    if (!hasIssues) {
+    if (!hasRepairableIssues) {
+        if (hasReportedIssues) {
+            debug('[check] 检查结果只包含无自动修复动作的问题');
+        }
         return;
     }
     // --fix 模式：直接修复
     if (options.fix) {
-        await fixAllIssues(result.integrity, { force: options.force });
+        await fixAllIssues(result.integrity, result.space, {
+            force: options.force,
+            calibrateSpace: hasSpaceCalibrationChoice(result.space),
+            deleteUnregistered: false,
+            verifyStoreIntegrity: options.integrity,
+        });
+        renderUncachedDependencyHint(result.integrity);
         return;
     }
     // 交互模式
-    await interactiveCheck(result.integrity, options);
+    await interactiveCheck(result, options);
 }
 // ============ 数据收集 ============
-async function collectAllIssues(options) {
-    const environment = await checkEnvironment();
+async function collectAllIssues(options = {}) {
+    debug(`[check] 健康检查开始: integrity=${options.integrity ?? false}, readOnly=${options.readOnly ?? false}, progress=${options.onProgress ? 'enabled' : 'disabled'}`);
+    options.onProgress?.({ stage: 'environment', state: 'started' });
+    const environment = await checkEnvironment(options?.readOnly);
+    options.onProgress?.({ stage: 'environment', state: 'completed' });
+    options.onProgress?.({ stage: 'integrity', state: 'started' });
     const integrity = await checkIntegrity(options);
+    options.onProgress?.({ stage: 'integrity', state: 'completed' });
+    const space = { issues: [] };
+    options.onProgress?.({ stage: 'space', state: 'started' });
+    try {
+        const registry = getRegistry();
+        await registry.load({ migrate: !options?.readOnly });
+        const storePath = await store.getStorePath();
+        debug(`[space] audit 开始: store=${storePath}, source=td-check`);
+        const spaceService = new SpaceService(registry, storePath);
+        const snapshot = await spaceService.buildSnapshot('audit', undefined, (progress) => options.onProgress?.({ stage: 'space', state: 'progress', progress }));
+        space.snapshotId = snapshot.id;
+        space.totals = snapshot.totals;
+        space.issues = snapshot.issues;
+        space.calibrationPlan = spaceService.buildCalibrationPlan(snapshot);
+        const cleanupLogs = await CleanupJournal.inspectPending();
+        for (const journal of cleanupLogs.journals) {
+            const data = journal.getData();
+            space.issues.push({
+                kind: 'recovery-log',
+                id: { libName: 'cleanup-journal', commit: data.planId },
+                message: `存在待恢复清理日志，组状态: ${data.groups.map((group) => `${group.index}:${group.state}`).join(', ')}`,
+            });
+        }
+        for (const filePath of cleanupLogs.corruptedFiles) {
+            space.issues.push({
+                kind: 'recovery-log',
+                id: { libName: 'cleanup-journal', commit: path.basename(filePath) },
+                message: `清理日志损坏，已保留原文件: ${filePath}`,
+            });
+        }
+        try {
+            const migrations = await MigrationJournal.listPending();
+            for (const migration of migrations) {
+                const data = migration.getData();
+                space.issues.push({
+                    kind: 'recovery-log',
+                    id: { libName: 'migration-journal', commit: data.id },
+                    message: `存在待恢复迁移: ${data.sourcePath} -> ${data.destinationPath}，阶段 ${data.phase}`,
+                });
+            }
+        }
+        catch (migrationError) {
+            space.issues.push({
+                kind: 'recovery-log',
+                id: { libName: 'migration-journal', commit: 'corrupted' },
+                message: migrationError.message,
+            });
+        }
+        debug(`[space] audit 完成: snapshot=${snapshot.id}, physical=${snapshot.totals.physical.bytes}, registered=${snapshot.totals.registered.bytes}, difference=${snapshot.totals.differenceBytes}, issues=${space.issues.length}, pendingCleanupLogs=${cleanupLogs.journals.length}, corruptedCleanupLogs=${cleanupLogs.corruptedFiles.length}`);
+        options.onProgress?.({ stage: 'space', state: 'completed' });
+    }
+    catch (err) {
+        space.error = err.message;
+        debug(`[space] audit 失败: error=${space.error}`);
+        options.onProgress?.({ stage: 'space', state: 'failed', error: space.error });
+    }
     // 计算汇总
     // 错误：检查项失败（ok === false），排除仅作为警告的项
     // 警告：目前只有 disk 有 warn 字段（空间 < 5GB 但不影响功能）
@@ -80,22 +247,27 @@ async function collectAllIssues(options) {
     const integrityIssues = integrity.invalidProjects.length +
         integrity.danglingLinks.length +
         integrity.orphanLibraries.length +
-        integrity.missingLibraries.length +
         integrity.staleReferences.length +
         integrity.corruptedStores.length;
-    const reclaimableSize = integrity.orphanLibraries.reduce((sum, lib) => sum + lib.size, 0);
-    return {
+    const reclaimableSize = space.totals?.reclaimable.bytes
+        ?? integrity.orphanLibraries.reduce((sum, lib) => sum + lib.size, 0);
+    const result = {
         environment,
         integrity,
+        space,
         summary: {
             envErrors,
             envWarnings,
             integrityIssues,
+            uncachedDependencies: integrity.missingLibraries.length,
             reclaimableSize,
+            spaceIssues: space.issues.length,
         },
     };
+    debug(`[check] 健康检查完成: envErrors=${envErrors}, envWarnings=${envWarnings}, integrityIssues=${integrityIssues}, uncachedDependencies=${integrity.missingLibraries.length}, spaceIssues=${space.issues.length}, spaceSnapshot=${space.snapshotId ?? 'none'}, spaceError=${space.error ?? 'none'}`);
+    return result;
 }
-async function checkEnvironment() {
+async function checkEnvironment(readOnly = false) {
     const codepacEnvironment = await checkCodepacEnvironment();
     const result = {
         codepac: { ok: false, message: '', details: codepacEnvironment },
@@ -111,7 +283,7 @@ async function checkEnvironment() {
         details: codepacEnvironment,
     };
     // 2. 配置
-    const cfg = await config.load();
+    const cfg = await config.load({ migrate: !readOnly });
     result.config = {
         ok: !!cfg,
         message: cfg ? '已初始化' : '未初始化，运行 td init',
@@ -179,7 +351,7 @@ async function checkIntegrity(options) {
     let storePath;
     try {
         registry = getRegistry();
-        await registry.load();
+        await registry.load({ migrate: !options?.readOnly });
         storePath = await store.getStorePath();
     }
     catch (err) {
@@ -188,6 +360,7 @@ async function checkIntegrity(options) {
         return result;
     }
     const projects = registry.listProjects();
+    debug(`[check] 数据一致性检查开始: store=${storePath}, projects=${projects.length}, integrity=${options?.integrity ?? false}, readOnly=${options?.readOnly ?? false}`);
     // 1. 检查项目和链接
     for (const project of projects) {
         const projectHash = registry.hashPath(project.path);
@@ -207,6 +380,25 @@ async function checkIntegrity(options) {
             if (!verifyPlatform) {
                 continue;
             }
+            const libraryKey = registry.getLibraryKey(dep.libName, dep.commit);
+            const library = registry.getLibrary(libraryKey);
+            const hasGeneralStoreEntry = registry
+                .getLibraryStoreKeys(dep.libName, dep.commit)
+                .some((storeKey) => registry.getStore(storeKey)?.platform === GENERAL_PLATFORM);
+            const isGeneral = library?.isGeneral === true ||
+                library?.platforms.includes(GENERAL_PLATFORM) === true ||
+                hasGeneralStoreEntry;
+            const cachePlatform = isGeneral ? GENERAL_PLATFORM : verifyPlatform;
+            const cacheExists = await store.exists(dep.libName, dep.commit, cachePlatform);
+            if (!cacheExists) {
+                result.missingLibraries.push({
+                    libName: dep.libName,
+                    commit: dep.commit,
+                    project: project.path,
+                });
+                debug(`[check] 本地依赖缓存缺失: project=${project.path}, lib=${dep.libName}, commit=${dep.commit}, platform=${cachePlatform}, link=${linkPath}`);
+                continue;
+            }
             try {
                 const stat = await fs.lstat(linkPath);
                 if (stat.isSymbolicLink()) {
@@ -219,21 +411,19 @@ async function checkIntegrity(options) {
                         result.danglingLinks.push({
                             path: linkPath,
                             projectHash,
-                            dep: { libName: dep.libName, commit: dep.commit },
+                            dep: {
+                                libName: dep.libName,
+                                commit: dep.commit,
+                                platform: dep.platform,
+                                linkedPath: dep.linkedPath,
+                                ...(dep.scope ? { scope: dep.scope } : {}),
+                            },
                         });
                     }
                 }
             }
             catch {
-                // 链接不存在，检查库是否在 Store
-                const exists = await store.exists(dep.libName, dep.commit, verifyPlatform);
-                if (!exists) {
-                    result.missingLibraries.push({
-                        libName: dep.libName,
-                        commit: dep.commit,
-                        project: project.path,
-                    });
-                }
+                // Store 缓存存在但项目链接缺失，后续引用检查会报告失效引用。
             }
         }
     }
@@ -348,7 +538,7 @@ async function checkIntegrity(options) {
     if (options?.integrity) {
         const stores = registry.listStores();
         for (const entry of stores) {
-            if (entry.fileCount != null) {
+            if (entry.fileCount != null && entry.contentHash) {
                 // 有 fileCount 的做 fullVerify
                 const expectedData = {
                     size: entry.size,
@@ -368,24 +558,19 @@ async function checkIntegrity(options) {
                 }
             }
             else {
-                // 无 fileCount 的做回填（captureIntegrity）
-                try {
-                    const integrity = await store.captureIntegrity(entry.libName, entry.commit, entry.platform);
-                    const storeKey = registry.getStoreKey(entry.libName, entry.commit, entry.platform);
-                    registry.updateStore(storeKey, {
-                        size: integrity.size,
-                        fileCount: integrity.fileCount,
-                        contentHash: integrity.contentHash,
-                    });
-                }
-                catch {
-                    debug(`[check] 回填完整性数据失败: ${entry.libName}:${entry.commit}:${entry.platform}`);
-                }
+                result.corruptedStores.push({
+                    libName: entry.libName,
+                    commit: entry.commit,
+                    platform: entry.platform,
+                    kind: 'missing_integrity_record',
+                    reason: 'missing integrity record',
+                    expected: { size: entry.size },
+                    actual: { fileCount: 0, size: 0 },
+                });
             }
         }
-        // 保存回填的数据
-        await registry.save();
     }
+    debug(`[check] 数据一致性检查完成: invalidProjects=${result.invalidProjects.length}, danglingLinks=${result.danglingLinks.length}, orphanLibraries=${result.orphanLibraries.length}, uncachedDependencies=${result.missingLibraries.length}, staleReferences=${result.staleReferences.length}, corruptedStores=${result.corruptedStores.length}`);
     return result;
 }
 // ============ 报告渲染 ============
@@ -415,10 +600,9 @@ function renderReport(result) {
     renderCheck('孤立库', integ.orphanLibraries.length === 0, integ.orphanLibraries.length === 0
         ? '无'
         : `${integ.orphanLibraries.length} 个未登记 (${formatSize(result.summary.reclaimableSize)})`, false);
-    renderCheck('缺失库', integ.missingLibraries.length === 0, integ.missingLibraries.length === 0
+    renderCheck('本地未缓存依赖', integ.missingLibraries.length === 0, integ.missingLibraries.length === 0
         ? '无'
-        : `${integ.missingLibraries.length} 个 (需 td link 下载)`, true // 显示为警告而非错误，因为需要用户手动下载
-    );
+        : `${integ.missingLibraries.length} 项（项目需要时可运行 td link）`, integ.missingLibraries.length > 0);
     renderCheck('引用关系', integ.staleReferences.length === 0, integ.staleReferences.length === 0
         ? '一致'
         : `${integ.staleReferences.length} 个失效引用`, false);
@@ -426,10 +610,32 @@ function renderReport(result) {
         ? '完整'
         : `${integ.corruptedStores.length} 个损坏的 Store 条目`, false);
     blank();
+    info('空间一致性');
+    separator();
+    if (result.space.error) {
+        renderCheck('空间审计', false, result.space.error, false);
+    }
+    else if (result.space.totals) {
+        const totals = result.space.totals;
+        renderCheck('空间审计', result.space.issues.length === 0, result.space.issues.length === 0
+            ? `实际占用 ${formatSize(totals.physical.bytes)}，登记容量一致`
+            : `${result.space.issues.length} 个差异，实际 ${formatSize(totals.physical.bytes)}，登记 ${formatSize(totals.registered.bytes)}`, false);
+        for (const issue of result.space.issues.slice(0, 20)) {
+            debug(`[space] audit 差异: kind=${issue.kind}, lib=${issue.id.libName}, commit=${issue.id.commit}, platform=${issue.platform ?? 'all'}, registered=${issue.registeredBytes ?? 'unknown'}, measured=${issue.measuredBytes ?? 'unknown'}, message=${issue.message}`);
+        }
+        if (result.space.issues.length > 20) {
+            debug(`[space] audit 差异省略: remaining=${result.space.issues.length - 20}`);
+        }
+    }
+    blank();
     separator();
     // 汇总
-    const { envErrors, envWarnings, integrityIssues, reclaimableSize } = result.summary;
-    if (envErrors === 0 && envWarnings === 0 && integrityIssues === 0) {
+    const { envErrors, envWarnings, integrityIssues, uncachedDependencies, reclaimableSize, spaceIssues, } = result.summary;
+    if (envErrors === 0 &&
+        envWarnings === 0 &&
+        integrityIssues === 0 &&
+        uncachedDependencies === 0 &&
+        spaceIssues === 0) {
         success('系统健康，无问题');
     }
     else {
@@ -440,6 +646,10 @@ function renderReport(result) {
             parts.push(`${envWarnings} 个警告`);
         if (integrityIssues > 0)
             parts.push(`${integrityIssues} 个数据问题`);
+        if (uncachedDependencies > 0)
+            parts.push(`${uncachedDependencies} 项本地未缓存依赖`);
+        if (spaceIssues > 0)
+            parts.push(`${spaceIssues} 个空间差异`);
         if (reclaimableSize > 0)
             parts.push(`可回收 ${formatSize(reclaimableSize)}`);
         warn(`发现问题: ${parts.join(', ')}`);
@@ -499,43 +709,55 @@ function renderCheck(name, ok, message, isWarning) {
     }
 }
 // ============ 交互式修复 ============
-async function interactiveCheck(issues, options) {
+function hasSpaceCalibrationChoice(space) {
+    const plan = space.calibrationPlan;
+    return Boolean(plan && (plan.actions.length > 0 || plan.unregistered.deletableCount > 0));
+}
+function renderUncachedDependencyHint(issues) {
+    if (issues.missingLibraries.length === 0)
+        return;
     blank();
-    const action = await selectWithCancel({
-        message: '选择操作',
-        choices: [
-            { name: '修复所有问题', value: 'fix-all' },
-            { name: '选择性修复', value: 'select' },
-            { name: '查看详情', value: 'detail' },
-            { name: colorize('← 退出', 'dim'), value: 'exit' },
-        ],
-    });
-    // ESC 取消 = 退出
-    if (action === PROMPT_CANCELLED) {
-        info('已取消');
+    hint(`${issues.missingLibraries.length} 项本地未缓存依赖已保留；项目需要这些依赖时可运行 td link`);
+}
+async function interactiveCheck(result, options) {
+    while (true) {
+        blank();
+        const action = await selectWithCancel({
+            message: '选择操作',
+            choices: [
+                { name: '修复所有可修复问题', value: 'fix-all' },
+                { name: '选择性修复', value: 'select' },
+                { name: '查看详情', value: 'detail' },
+                { name: colorize('← 退出', 'dim'), value: 'exit' },
+            ],
+        });
+        if (action === PROMPT_CANCELLED) {
+            info('已取消');
+            return;
+        }
+        debug(`[check] 交互操作: action=${action}`);
+        if (action === 'detail') {
+            showDetails(result);
+            continue;
+        }
+        if (action === 'exit')
+            return;
+        if (action === 'select') {
+            await selectiveFix(result, options);
+            return;
+        }
+        await fixAllIssues(result.integrity, result.space, {
+            force: true,
+            calibrateSpace: hasSpaceCalibrationChoice(result.space),
+            deleteUnregistered: false,
+            verifyStoreIntegrity: options.integrity,
+        });
+        renderUncachedDependencyHint(result.integrity);
         return;
     }
-    switch (action) {
-        case 'fix-all':
-            await fixAllIssues(issues, { force: true });
-            // 缺失库无法自动修复，需要提示用户
-            if (issues.missingLibraries.length > 0) {
-                blank();
-                hint(`缺失库 (${issues.missingLibraries.length} 个) 需要通过 td link 重新下载`);
-            }
-            break;
-        case 'select':
-            await selectiveFix(issues, options);
-            break;
-        case 'detail':
-            showDetails(issues);
-            await interactiveCheck(issues, options);
-            break;
-        case 'exit':
-            break;
-    }
-}
-async function selectiveFix(issues, options) {
+}
+async function selectiveFix(result, options) {
+    const issues = result.integrity;
     // 构建选项
     const choices = [];
     if (issues.invalidProjects.length > 0) {
@@ -574,6 +796,13 @@ async function selectiveFix(issues, options) {
             checked: true,
         });
     }
+    if (hasSpaceCalibrationChoice(result.space)) {
+        choices.push({
+            name: `校准 ${result.space.issues.length} 个空间差异`,
+            value: 'spaceCalibration',
+            checked: true,
+        });
+    }
     if (choices.length === 0) {
         success('没有可修复的问题');
         return;
@@ -601,7 +830,8 @@ async function selectiveFix(issues, options) {
         orphanLibraries: selected.includes('orphanLibraries')
             ? issues.orphanLibraries
             : [],
-        missingLibraries: [], // 缺失库无法修复
+        // 本地未缓存依赖是用户允许的缓存状态，修复流程不下载也不移除依赖记录。
+        missingLibraries: [],
         staleReferences: selected.includes('staleReferences')
             ? issues.staleReferences
             : [],
@@ -609,14 +839,76 @@ async function selectiveFix(issues, options) {
             ? issues.corruptedStores
             : [],
     };
-    await fixAllIssues(toFix, { force: options.force });
-    // 缺失库无法自动修复，需要提示用户
-    if (issues.missingLibraries.length > 0) {
+    const calibrateSpace = selected.includes('spaceCalibration');
+    let deleteUnregistered = false;
+    const spacePlan = result.space.calibrationPlan;
+    if (calibrateSpace &&
+        spacePlan &&
+        spacePlan.unregistered.totalCount > 0 &&
+        spacePlan.unregistered.deletableCount > 0) {
+        blank();
+        const unregisteredAction = await selectWithCancel({
+            message: '未登记平台如何处理?',
+            choices: [
+                {
+                    name: '暂不处理',
+                    value: 'keep',
+                    description: `保留全部 ${spacePlan.unregistered.totalCount} 项内容`,
+                },
+                {
+                    name: '删除无项目引用的内容',
+                    value: 'delete-unreferenced',
+                    description: `删除 ${spacePlan.unregistered.deletableCount} 项，保留 ${spacePlan.unregistered.protectedCount} 项`,
+                },
+            ],
+        });
+        if (unregisteredAction === PROMPT_CANCELLED) {
+            info('已取消');
+            return;
+        }
+        deleteUnregistered = unregisteredAction === 'delete-unreferenced';
+    }
+    debug(`[check] 选择性修复输入: selected=${selected.join(',')}, calibrateSpace=${calibrateSpace}, unregisteredAction=${deleteUnregistered ? 'delete-unreferenced' : 'keep'}`);
+    await fixAllIssues(toFix, result.space, {
+        force: options.force,
+        calibrateSpace,
+        deleteUnregistered,
+        verifyStoreIntegrity: options.integrity,
+    });
+    renderUncachedDependencyHint(issues);
+}
+function formatSignedSize(bytes) {
+    const sign = bytes > 0 ? '+' : bytes < 0 ? '-' : '';
+    return `${sign}${formatSize(Math.abs(bytes))}`;
+}
+function showSpaceDetails(space) {
+    if (space.error) {
+        info('空间审计:');
+        warn(`  ${space.error}`);
         blank();
-        hint(`缺失库 (${issues.missingLibraries.length} 个) 需要通过 td link 重新下载`);
+        return;
+    }
+    const plan = space.calibrationPlan;
+    if (!plan || space.issues.length === 0)
+        return;
+    info(`空间差异 (${space.issues.length}):`);
+    info(`  登记容量变化  ${plan.summary.changedCount} 项，合计 ${formatSignedSize(plan.summary.changedDifferenceBytes)}`);
+    info(`  缺失登记      ${plan.summary.missingCount} 项，登记容量 ${formatSize(plan.summary.missingRegisteredBytes)}`);
+    info(`  重复共享登记  ${plan.summary.duplicateSharedCount} 项`);
+    info(`  未登记平台    ${plan.unregistered.totalCount} 项，合计 ${formatSize(plan.unregistered.totalBytes)}`);
+    if (plan.unregistered.protectedCount > 0) {
+        info(`  引用保护        ${plan.unregistered.protectedCount} 项`);
+    }
+    const otherIssues = space.issues.filter((issue) => !['changed', 'missing', 'duplicate-record', 'unregistered'].includes(issue.kind));
+    if (otherIssues.length > 0)
+        info(`  其他空间异常  ${otherIssues.length} 项`);
+    if (plan.summary.ignoredArtifactCount > 0) {
+        info(`  系统文件        ${plan.summary.ignoredArtifactCount} 项，将忽略并保留`);
     }
+    blank();
 }
-function showDetails(issues) {
+function showDetails(result) {
+    const issues = result.integrity;
     blank();
     title('问题详情');
     blank();
@@ -642,7 +934,7 @@ function showDetails(issues) {
         blank();
     }
     if (issues.missingLibraries.length > 0) {
-        info(`缺失库 (${issues.missingLibraries.length}):`);
+        info(`本地未缓存依赖 (${issues.missingLibraries.length}):`);
         for (const lib of issues.missingLibraries) {
             hint(`  - ${lib.libName}/${lib.commit.slice(0, 7)} (引用自 ${lib.project})`);
         }
@@ -669,22 +961,61 @@ function showDetails(issues) {
         }
         blank();
     }
+    showSpaceDetails(result.space);
 }
-async function fixAllIssues(issues, options) {
-    const totalIssues = issues.invalidProjects.length +
+function integrityRepairCount(issues) {
+    return (issues.invalidProjects.length +
         issues.danglingLinks.length +
         issues.orphanLibraries.length +
         issues.staleReferences.length +
-        issues.corruptedStores.length;
-    if (totalIssues === 0) {
+        issues.corruptedStores.length);
+}
+function retainCurrentIssues(selected, current, keyOf) {
+    const selectedKeys = new Set(selected.map(keyOf));
+    return current.filter((issue) => selectedKeys.has(keyOf(issue)));
+}
+/**
+ * 只保留用户确认过且在取得全局锁后仍然存在的问题。
+ * 新出现的问题不会被本次修复附带处理。
+ */
+async function revalidateIntegritySelection(selected, verifyStoreIntegrity) {
+    const current = await checkIntegrity({ integrity: verifyStoreIntegrity });
+    const revalidated = {
+        invalidProjects: retainCurrentIssues(selected.invalidProjects, current.invalidProjects, (issue) => JSON.stringify([issue.hash, issue.path])),
+        danglingLinks: retainCurrentIssues(selected.danglingLinks, current.danglingLinks, (issue) => JSON.stringify([
+            issue.path,
+            issue.projectHash,
+            issue.dep.libName,
+            issue.dep.commit,
+            issue.dep.platform,
+            issue.dep.linkedPath,
+            issue.dep.scope ?? '',
+        ])),
+        orphanLibraries: retainCurrentIssues(selected.orphanLibraries, current.orphanLibraries, (issue) => JSON.stringify([issue.libName, issue.commit, issue.path])),
+        missingLibraries: [],
+        staleReferences: retainCurrentIssues(selected.staleReferences, current.staleReferences, (issue) => JSON.stringify([issue.libKey, issue.projectHash])),
+        corruptedStores: retainCurrentIssues(selected.corruptedStores, current.corruptedStores, (issue) => JSON.stringify([issue.libName, issue.commit, issue.platform, issue.kind ?? 'integrity'])),
+    };
+    debug(`[check] 锁内重新检查完成: selected=${integrityRepairCount(selected)}, retained=${integrityRepairCount(revalidated)}, currentUncachedDependencies=${current.missingLibraries.length}, invalidProjects=${revalidated.invalidProjects.length}, danglingLinks=${revalidated.danglingLinks.length}, orphanLibraries=${revalidated.orphanLibraries.length}, staleReferences=${revalidated.staleReferences.length}, corruptedStores=${revalidated.corruptedStores.length}`);
+    return revalidated;
+}
+async function fixAllIssues(issues, space, options) {
+    const totalIssues = integrityRepairCount(issues);
+    const spaceIssueCount = options.calibrateSpace ? space.issues.length : 0;
+    if (totalIssues === 0 && spaceIssueCount === 0) {
         success('没有需要修复的问题');
         return;
     }
+    debug(`[check] 修复请求: integrityIssues=${totalIssues}, calibrateSpace=${options.calibrateSpace}, reportedSpaceIssues=${spaceIssueCount}, unregisteredAction=${options.deleteUnregistered ? 'delete-unreferenced' : 'keep'}, force=${options.force}, sourceSnapshot=${space.snapshotId ?? 'none'}`);
     // 确认
     if (!options.force) {
         blank();
+        const targets = [
+            ...(totalIssues > 0 ? [`${totalIssues} 个数据问题`] : []),
+            ...(spaceIssueCount > 0 ? [`${spaceIssueCount} 个空间差异`] : []),
+        ];
         const confirmed = await confirmWithCancel({
-            message: `确认修复以上 ${totalIssues} 个问题?`,
+            message: `确认处理${targets.join('和')}?`,
             default: false,
         });
         if (confirmed === PROMPT_CANCELLED || !confirmed) {
@@ -696,19 +1027,167 @@ async function fixAllIssues(issues, options) {
     separator();
     info('正在修复...');
     blank();
+    await withGlobalLock(async () => {
+        if (totalIssues > 0) {
+            info('正在重新确认待修复的数据问题...');
+            const revalidated = await revalidateIntegritySelection(issues, options.verifyStoreIntegrity);
+            if (integrityRepairCount(revalidated) === 0) {
+                success('待修复的数据问题状态已变化，本次无需处理');
+            }
+            else {
+                const repairResult = await applyAllIssueFixes(revalidated);
+                if (repairResult.failed > 0)
+                    process.exitCode = 1;
+            }
+        }
+        if (options.calibrateSpace) {
+            try {
+                await applySpaceCalibration(space, options.deleteUnregistered);
+            }
+            catch (err) {
+                const message = err.message;
+                error(`空间校准失败: ${message}`);
+                debug(`[check] 空间校准异常: sourceSnapshot=${space.snapshotId ?? 'none'}, deleteUnregistered=${options.deleteUnregistered}, error=${message}`);
+                process.exitCode = 1;
+            }
+        }
+    });
+}
+async function applySpaceCalibration(sourceSpace, deleteUnregistered) {
+    const registry = getRegistry();
+    await registry.load();
+    const storePath = await store.getStorePath();
+    const service = new SpaceService(registry, storePath);
+    const cleanupExecutor = service.createCleanupExecutor();
+    const recovered = await cleanupExecutor.recoverPending();
+    debug(`[check] 空间校准开始: store=${storePath}, sourceSnapshot=${sourceSpace.snapshotId ?? 'none'}, sourceIssues=${sourceSpace.issues.length}, unregisteredAction=${deleteUnregistered ? 'delete-unreferenced' : 'keep'}, recovered=${recovered}`);
+    if (recovered > 0)
+        info(`恢复了 ${recovered} 个中断清理记录`);
+    const planningProgress = createSpaceProgressRenderer('正在重新核对空间差异');
+    let snapshot;
+    try {
+        snapshot = await service.buildSnapshot('audit', undefined, planningProgress.update);
+    }
+    finally {
+        planningProgress.close();
+    }
+    const plan = service.buildCalibrationPlan(snapshot);
+    const willDelete = deleteUnregistered && plan.unregistered.deletableCount > 0;
+    debug(`[check] 空间校准计划: plan=${plan.id}, snapshot=${snapshot.id}, metadataActions=${plan.actions.length}, changed=${plan.summary.changedCount}, missing=${plan.summary.missingCount}, duplicates=${plan.summary.duplicateSharedCount}, unregistered=${plan.unregistered.totalCount}, deletable=${plan.unregistered.deletableCount}, protected=${plan.unregistered.protectedCount}, willDelete=${willDelete}`);
+    if (plan.actions.length === 0 && !willDelete) {
+        if (plan.unregistered.totalCount > 0) {
+            success(`登记数据无需调整，保留 ${plan.unregistered.totalCount} 项未登记平台`);
+        }
+        else {
+            success('空间登记与 Store 实际状态一致');
+        }
+        return;
+    }
+    const stageProgress = {
+        'validate-plan': createSpaceProgressRenderer('正在验证校准计划'),
+        'verify-result': createSpaceProgressRenderer('正在验证校准结果'),
+    };
+    let calibrationResult;
+    try {
+        calibrationResult = await service.createCalibrationExecutor().execute(plan, {
+            deleteUnregistered,
+            onProgress: (stage, progress) => stageProgress[stage].update(progress),
+        });
+    }
+    finally {
+        stageProgress['validate-plan'].close();
+        stageProgress['verify-result'].close();
+    }
+    const remainingPlan = service.buildCalibrationPlan(calibrationResult.finalSnapshot);
+    const cleanupFailed = calibrationResult.cleanup != null && calibrationResult.cleanup.status !== 'completed';
+    if (cleanupFailed) {
+        process.exitCode = 1;
+        warn(`空间校准部分完成: 更新 ${calibrationResult.metadataActionCount} 项登记数据，未登记平台删除成功 ${calibrationResult.cleanup.succeeded.length} 项、失败 ${calibrationResult.cleanup.failed.length} 项`);
+        for (const failure of calibrationResult.cleanup.failed) {
+            error(`未登记平台删除失败: ${failure.id.libName}/${failure.id.commit.slice(0, 7)}/${failure.platform ?? 'all'} - ${failure.message}`);
+        }
+    }
+    else {
+        success(`空间校准完成: 更新 ${calibrationResult.metadataActionCount} 项登记数据`);
+    }
+    if (calibrationResult.cleanup && !cleanupFailed) {
+        info(`未登记平台清理: 删除 ${calibrationResult.cleanup.succeeded.length} 项，释放 ${formatSize(calibrationResult.cleanup.released.bytes)}`);
+    }
+    if (remainingPlan.unregistered.totalCount > 0) {
+        info(`保留未登记平台: ${remainingPlan.unregistered.totalCount} 项`);
+    }
+    if (remainingPlan.actions.length > 0) {
+        process.exitCode = 1;
+        warn(`重新检查仍发现 ${remainingPlan.actions.length} 项登记差异，请查看详细日志`);
+    }
+    debug(`[check] 空间校准完成: plan=${plan.id}, finalSnapshot=${calibrationResult.finalSnapshot.id}, metadataActions=${calibrationResult.metadataActionCount}, cleanupStatus=${calibrationResult.cleanup?.status ?? 'skipped'}, cleanupSucceeded=${calibrationResult.cleanup?.succeeded.length ?? 0}, cleanupFailed=${calibrationResult.cleanup?.failed.length ?? 0}, remainingMetadata=${remainingPlan.actions.length}, remainingUnregistered=${remainingPlan.unregistered.totalCount}, finalDifference=${calibrationResult.finalSnapshot.totals.differenceBytes}`);
+}
+function commitKey(libName, commit) {
+    return JSON.stringify([libName, commit]);
+}
+function buildCorruptedSelections(corrupted, includeShared) {
+    const grouped = new Map();
+    for (const item of corrupted) {
+        const key = commitKey(item.libName, item.commit);
+        const group = grouped.get(key) ?? {
+            id: { libName: item.libName, commit: item.commit },
+            platforms: new Set(),
+        };
+        if (!includeShared)
+            group.platforms.add(item.platform);
+        grouped.set(key, group);
+    }
+    return [...grouped.values()].map((group) => ({
+        id: group.id,
+        platforms: includeShared ? 'all' : [...group.platforms],
+        ...(includeShared ? { includeShared: true } : {}),
+    }));
+}
+async function executeRepairPlan(spaceService, executor, selections, options) {
+    if (selections.length === 0)
+        return null;
+    const plan = await spaceService.buildCleanupPlan({
+        reason: 'repair',
+        selections,
+        requireUnreferenced: options.requireUnreferenced,
+        allowUnknownContent: options.allowUnknownContent,
+    });
+    for (const warningMessage of plan.warnings)
+        warn(`[space] ${warningMessage}`);
+    debug(`[check] 调用统一清理执行器: category=${options.category}, plan=${plan.id}, selections=${selections.length}, groups=${plan.groups.length}, expected=${plan.expectedRelease.bytes}`);
+    if (plan.groups.length === 0)
+        return null;
+    const result = await executor.execute(plan);
+    debug(`[check] 清理执行返回: category=${options.category}, plan=${plan.id}, status=${result.status}, succeeded=${result.succeeded.length}, failed=${result.failed.length}, released=${result.released.bytes}`);
+    return result;
+}
+function resolvedIssueCount(result, issues) {
+    if (!result)
+        return 0;
+    return issues.filter((issue) => result.succeeded.some((group) => group.id.libName === issue.libName
+        && group.id.commit === issue.commit
+        && (group.platform == null || issue.platform == null || group.platform === issue.platform))).length;
+}
+async function applyAllIssueFixes(issues) {
     const registry = getRegistry();
     await registry.load();
     const storePath = await store.getStorePath();
+    const spaceService = new SpaceService(registry, storePath);
+    const executor = spaceService.createCleanupExecutor();
+    const recovered = await executor.recoverPending();
+    debug(`[check] 修复开始: invalidProjects=${issues.invalidProjects.length}, danglingLinks=${issues.danglingLinks.length}, orphanLibraries=${issues.orphanLibraries.length}, staleReferences=${issues.staleReferences.length}, corruptedStores=${issues.corruptedStores.length}, recovered=${recovered}`);
     let fixed = 0;
+    let failed = 0;
     // 1. 清理无效项目
     for (const p of issues.invalidProjects) {
         try {
             registry.removeProject(p.hash);
-            success(`[ok] 清理项目: ${p.path}`);
+            success(`清理项目: ${p.path}`);
             fixed++;
         }
         catch (err) {
             error(`[err] 清理项目失败: ${p.path} - ${err.message}`);
+            failed++;
         }
     }
     // 2. 移除悬挂链接
@@ -717,7 +1196,11 @@ async function fixAllIssues(issues, options) {
             await fs.unlink(link.path);
             const project = registry.getProject(link.projectHash);
             if (project) {
-                project.dependencies = project.dependencies.filter((d) => !(d.libName === link.dep.libName && d.commit === link.dep.commit));
+                project.dependencies = project.dependencies.filter((dependency) => !(dependency.libName === link.dep.libName &&
+                    dependency.commit === link.dep.commit &&
+                    dependency.platform === link.dep.platform &&
+                    dependency.linkedPath === link.dep.linkedPath &&
+                    (dependency.scope ?? '') === (link.dep.scope ?? '')));
                 registry.updateProject(link.projectHash, {
                     dependencies: project.dependencies,
                 });
@@ -727,24 +1210,32 @@ async function fixAllIssues(issues, options) {
         }
         catch (err) {
             error(`[err] 移除链接失败: ${link.path} - ${err.message}`);
+            failed++;
         }
     }
-    // 3. 删除孤立库
-    for (const lib of issues.orphanLibraries) {
-        try {
-            await fs.rm(lib.path, { recursive: true, force: true });
-            // 如果删除后 libName 目录为空，也一并删除
-            const libDir = path.dirname(lib.path);
-            const remaining = await fs.readdir(libDir).catch(() => ['placeholder']);
-            if (remaining.length === 0) {
-                await fs.rm(libDir, { recursive: true, force: true }).catch(() => { });
-            }
-            success(`[ok] 删除孤立库: ${lib.libName}/${lib.commit.slice(0, 7)}`);
-            fixed++;
+    // 3. 删除孤立库。显式修复允许清理该版本中的未登记内容。
+    const orphanSelections = [...new Map(issues.orphanLibraries.map((lib) => [
+            commitKey(lib.libName, lib.commit),
+            { id: { libName: lib.libName, commit: lib.commit }, platforms: 'all' },
+        ])).values()];
+    try {
+        const result = await executeRepairPlan(spaceService, executor, orphanSelections, {
+            requireUnreferenced: true,
+            allowUnknownContent: true,
+            category: 'orphan-library',
+        });
+        fixed += resolvedIssueCount(result, issues.orphanLibraries);
+        for (const group of result?.succeeded ?? []) {
+            success(`[ok] 删除孤立库: ${group.id.libName}/${group.id.commit.slice(0, 7)}`);
         }
-        catch (err) {
-            error(`[err] 删除孤立库失败: ${lib.libName}/${lib.commit.slice(0, 7)} - ${err.message}`);
+        for (const failure of result?.failed ?? []) {
+            error(`[err] 删除孤立库失败: ${failure.id.libName}/${failure.id.commit.slice(0, 7)} - ${failure.message}`);
         }
+        failed += result?.failed.length ?? (orphanSelections.length > 0 ? 1 : 0);
+    }
+    catch (err) {
+        error(`[err] 删除孤立库失败: ${err.message}`);
+        failed++;
     }
     // 4. 移除失效引用
     for (const ref of issues.staleReferences) {
@@ -754,6 +1245,7 @@ async function fixAllIssues(issues, options) {
             const colonIndex = ref.libKey.lastIndexOf(':');
             if (colonIndex === -1) {
                 error(`[err] 无效的 libKey: ${ref.libKey}`);
+                failed++;
                 continue;
             }
             const libName = ref.libKey.slice(0, colonIndex);
@@ -767,37 +1259,62 @@ async function fixAllIssues(issues, options) {
         }
         catch (err) {
             error(`[err] 移除引用失败: ${ref.libKey} - ${err.message}`);
+            failed++;
         }
     }
-    // 5. 清理损坏的 Store 条目
-    for (const item of issues.corruptedStores) {
+    // 5. 清理损坏的 Store 条目。共享冲突整版本处理，其他问题按平台处理。
+    const orphanKeys = new Set(issues.orphanLibraries.map((item) => commitKey(item.libName, item.commit)));
+    const sharedCorruptions = issues.corruptedStores.filter((item) => (item.kind === 'shared_platform_conflict' || item.platform === SHARED_PLATFORM)
+        && !orphanKeys.has(commitKey(item.libName, item.commit)));
+    const sharedCorruptionKeys = new Set(sharedCorruptions.map((item) => commitKey(item.libName, item.commit)));
+    const platformCorruptions = issues.corruptedStores.filter((item) => !orphanKeys.has(commitKey(item.libName, item.commit))
+        && !sharedCorruptionKeys.has(commitKey(item.libName, item.commit)));
+    for (const cleanup of [
+        {
+            items: issues.corruptedStores.filter((item) => sharedCorruptionKeys.has(commitKey(item.libName, item.commit))),
+            selections: buildCorruptedSelections(sharedCorruptions, true),
+            allowUnknownContent: false,
+            category: 'shared-corruption',
+        },
+        {
+            items: platformCorruptions,
+            selections: buildCorruptedSelections(platformCorruptions, false),
+            allowUnknownContent: false,
+            category: 'corrupted-platform',
+        },
+    ]) {
         try {
-            if (item.kind === 'shared_platform_conflict') {
-                const storeKeys = registry.getLibraryStoreKeys(item.libName, item.commit);
-                for (const storeKey of storeKeys) {
-                    registry.removeStore(storeKey);
-                }
-                const commitPath = path.join(storePath, item.libName, item.commit);
-                await fs.rm(commitPath, { recursive: true, force: true });
-                success(`[ok] 清理损坏 Store: ${item.libName}/${item.commit.slice(0, 7)} (移除整个 commit 缓存)`);
+            const result = await executeRepairPlan(spaceService, executor, cleanup.selections, {
+                requireUnreferenced: false,
+                allowUnknownContent: cleanup.allowUnknownContent,
+                category: cleanup.category,
+            });
+            fixed += resolvedIssueCount(result, cleanup.items);
+            for (const group of result?.succeeded ?? []) {
+                const suffix = group.platform ? `/${group.platform}` : ' (移除整个 commit 缓存)';
+                success(`清理损坏 Store: ${group.id.libName}/${group.id.commit.slice(0, 7)}${suffix}`);
             }
-            else {
-                const storeKey = registry.getStoreKey(item.libName, item.commit, item.platform);
-                registry.removeStore(storeKey);
-                const platformPath = path.join(storePath, item.libName, item.commit, item.platform);
-                await fs.rm(platformPath, { recursive: true, force: true });
-                success(`[ok] 清理损坏 Store: ${item.libName}/${item.commit.slice(0, 7)}/${item.platform}`);
+            for (const failure of result?.failed ?? []) {
+                error(`清理损坏 Store 失败: ${failure.id.libName}/${failure.id.commit.slice(0, 7)}/${failure.platform ?? 'all'} - ${failure.message}`);
             }
-            fixed++;
+            failed += result?.failed.length ?? (cleanup.selections.length > 0 ? 1 : 0);
         }
         catch (err) {
-            error(`[err] 清理损坏 Store 失败: ${item.libName}/${item.commit.slice(0, 7)}/${item.platform} - ${err.message}`);
+            error(`清理损坏 Store 失败: category=${cleanup.category} - ${err.message}`);
+            failed++;
         }
     }
     await registry.save();
     blank();
     separator();
-    success(`修复完成: ${fixed} 个问题已解决`);
+    if (failed > 0) {
+        warn(`修复部分完成: 解决 ${fixed} 个问题，失败 ${failed} 项操作`);
+    }
+    else {
+        success(`修复完成: ${fixed} 个问题已解决`);
+    }
+    debug(`[check] 修复完成: fixed=${fixed}, failed=${failed}`);
+    return { fixed, failed };
 }
 // ============ 工具函数 ============
 async function getDirSizeRecursive(dirPath) {
@@ -845,6 +1362,12 @@ export async function verifyIntegrity() {
 export async function collectCheckResultForTest(options) {
     return collectAllIssues(options);
 }
+export async function runCheckForTest(options) {
+    await runCheck(options);
+}
+export async function interactiveCheckForTest(result, options) {
+    await interactiveCheck(result, options);
+}
 /**
  * 修复问题（兼容旧 repair 命令）
  */
@@ -852,16 +1375,22 @@ export async function repairIssues(options) {
     const result = await collectAllIssues();
     // 渲染报告
     renderReport(result);
-    const hasIssues = result.summary.integrityIssues > 0;
+    const hasIssues = result.summary.integrityIssues > 0 || hasSpaceCalibrationChoice(result.space);
     if (!hasIssues) {
         return;
     }
     if (options.dryRun) {
         blank();
-        hint('运行 td check --fix 修复问题');
+        hint('运行 td check --fix 修复可修复问题');
         return;
     }
-    await fixAllIssues(result.integrity, { force: options.force });
+    await fixAllIssues(result.integrity, result.space, {
+        force: options.force,
+        calibrateSpace: hasSpaceCalibrationChoice(result.space),
+        deleteUnregistered: false,
+        verifyStoreIntegrity: false,
+    });
+    renderUncachedDependencyHint(result.integrity);
 }
 /**
  * 校验所有 Store 条目的文件完整性
@@ -902,7 +1431,7 @@ export async function checkStoreIntegrity() {
                 });
             }
         }
-        if (entry.fileCount != null) {
+        if (entry.fileCount != null && entry.contentHash) {
             const expectedData = {
                 size: entry.size,
                 fileCount: entry.fileCount,
@@ -921,22 +1450,17 @@ export async function checkStoreIntegrity() {
             }
         }
         else {
-            // 无 fileCount 的做回填
-            try {
-                const integrity = await store.captureIntegrity(entry.libName, entry.commit, entry.platform);
-                const storeKey = registry.getStoreKey(entry.libName, entry.commit, entry.platform);
-                registry.updateStore(storeKey, {
-                    size: integrity.size,
-                    fileCount: integrity.fileCount,
-                    contentHash: integrity.contentHash,
-                });
-            }
-            catch {
-                debug(`[check] 回填完整性数据失败: ${entry.libName}:${entry.commit}:${entry.platform}`);
-            }
+            corrupted.push({
+                libName: entry.libName,
+                commit: entry.commit,
+                platform: entry.platform,
+                kind: 'missing_integrity_record',
+                reason: 'missing integrity record',
+                expected: { size: entry.size },
+                actual: { fileCount: 0, size: 0 },
+            });
         }
     }
-    await registry.save();
     return corrupted;
 }
 /**
@@ -948,30 +1472,42 @@ export async function checkStoreIntegrity() {
 export async function fixCorruptedStores(corrupted) {
     if (corrupted.length === 0)
         return;
+    await withGlobalLock(() => applyCorruptedStoreFixes(corrupted));
+}
+async function applyCorruptedStoreFixes(corrupted) {
     const registry = getRegistry();
     await registry.load();
     const storePath = await store.getStorePath();
-    for (const item of corrupted) {
-        try {
-            if (item.kind === 'shared_platform_conflict') {
-                const storeKeys = registry.getLibraryStoreKeys(item.libName, item.commit);
-                for (const storeKey of storeKeys) {
-                    registry.removeStore(storeKey);
-                }
-                const commitPath = path.join(storePath, item.libName, item.commit);
-                await fs.rm(commitPath, { recursive: true, force: true });
-                success(`[ok] 清理损坏 Store: ${item.libName}/${item.commit.slice(0, 7)} (移除整个 commit 缓存)`);
-            }
-            else {
-                const storeKey = registry.getStoreKey(item.libName, item.commit, item.platform);
-                registry.removeStore(storeKey);
-                const platformPath = path.join(storePath, item.libName, item.commit, item.platform);
-                await fs.rm(platformPath, { recursive: true, force: true });
-                success(`[ok] 清理损坏 Store: ${item.libName}/${item.commit.slice(0, 7)}/${item.platform}`);
-            }
+    const spaceService = new SpaceService(registry, storePath);
+    const executor = spaceService.createCleanupExecutor();
+    const recovered = await executor.recoverPending();
+    debug(`[check] 兼容修复入口开始: corruptedStores=${corrupted.length}, recovered=${recovered}`);
+    const sharedCorruptions = corrupted.filter((item) => item.kind === 'shared_platform_conflict' || item.platform === SHARED_PLATFORM);
+    const sharedCorruptionKeys = new Set(sharedCorruptions.map((item) => commitKey(item.libName, item.commit)));
+    const platformCorruptions = corrupted.filter((item) => !sharedCorruptionKeys.has(commitKey(item.libName, item.commit)));
+    for (const cleanup of [
+        {
+            selections: buildCorruptedSelections(sharedCorruptions, true),
+            allowUnknownContent: false,
+            category: 'shared-corruption',
+        },
+        {
+            selections: buildCorruptedSelections(platformCorruptions, false),
+            allowUnknownContent: false,
+            category: 'corrupted-platform',
+        },
+    ]) {
+        const result = await executeRepairPlan(spaceService, executor, cleanup.selections, {
+            requireUnreferenced: false,
+            allowUnknownContent: cleanup.allowUnknownContent,
+            category: cleanup.category,
+        });
+        for (const group of result?.succeeded ?? []) {
+            const suffix = group.platform ? `/${group.platform}` : ' (移除整个 commit 缓存)';
+            success(`清理损坏 Store: ${group.id.libName}/${group.id.commit.slice(0, 7)}${suffix}`);
         }
-        catch (err) {
-            error(`[err] 清理损坏 Store 失败: ${item.libName}/${item.commit.slice(0, 7)}/${item.platform} - ${err.message}`);
+        for (const failure of result?.failed ?? []) {
+            error(`清理损坏 Store 失败: ${failure.id.libName}/${failure.id.commit.slice(0, 7)}/${failure.platform ?? 'all'} - ${failure.message}`);
         }
     }
     await registry.save();