tanmi-dock 1.0.4 → 1.0.5-beta

package/dist/commands/check.js

@@ -9,18 +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, SHARED_PLATFORM } from '../core/platform.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, } from '../utils/logger.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', '跳过确认')
@@ -31,6 +104,14 @@ export function createCheckCommand() {
 }
 // ============ 主流程 ============
 async function runCheck(options) {
+    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') {
@@ -41,6 +122,7 @@ async function runCheck(options) {
     const result = await collectAllIssues({
         integrity: options.integrity,
         readOnly: options.dryRun,
+        onProgress: options.json ? undefined : createCheckProgressRenderer(),
     });
     // JSON 输出
     if (options.json) {
@@ -50,13 +132,14 @@ async function runCheck(options) {
     // 渲染报告
     renderReport(result);
     const hasIntegrityIssues = result.summary.integrityIssues > 0;
-    const hasIssues = hasIntegrityIssues || result.summary.spaceIssues > 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;
     }
@@ -67,35 +150,48 @@ async function runCheck(options) {
         return;
     }
     // 无问题
-    if (!hasIssues) {
-        return;
-    }
-    if (!hasIntegrityIssues) {
-        hint('空间差异需要通过详细检查确认，本次没有自动修改注册记录');
+    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) {
+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 snapshot = await new SpaceService(registry, storePath).buildSnapshot('audit');
+        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();
@@ -131,10 +227,12 @@ async function collectAllIssues(options) {
             });
         }
         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），排除仅作为警告的项
@@ -149,12 +247,11 @@ 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 = space.totals?.reclaimable.bytes
         ?? integrity.orphanLibraries.reduce((sum, lib) => sum + lib.size, 0);
-    return {
+    const result = {
         environment,
         integrity,
         space,
@@ -162,10 +259,13 @@ async function collectAllIssues(options) {
             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(readOnly = false) {
     const codepacEnvironment = await checkCodepacEnvironment();
@@ -260,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);
@@ -279,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()) {
@@ -291,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 缓存存在但项目链接缺失，后续引用检查会报告失效引用。
             }
         }
     }
@@ -452,6 +570,7 @@ async function checkIntegrity(options) {
             }
         }
     }
+    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;
 }
 // ============ 报告渲染 ============
@@ -481,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);
@@ -512,8 +630,12 @@ function renderReport(result) {
     blank();
     separator();
     // 汇总
-    const { envErrors, envWarnings, integrityIssues, reclaimableSize, spaceIssues } = result.summary;
-    if (envErrors === 0 && envWarnings === 0 && integrityIssues === 0 && spaceIssues === 0) {
+    const { envErrors, envWarnings, integrityIssues, uncachedDependencies, reclaimableSize, spaceIssues, } = result.summary;
+    if (envErrors === 0 &&
+        envWarnings === 0 &&
+        integrityIssues === 0 &&
+        uncachedDependencies === 0 &&
+        spaceIssues === 0) {
         success('系统健康，无问题');
     }
     else {
@@ -524,6 +646,8 @@ 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)
@@ -585,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) {
@@ -660,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;
@@ -687,7 +830,8 @@ async function selectiveFix(issues, options) {
         orphanLibraries: selected.includes('orphanLibraries')
             ? issues.orphanLibraries
             : [],
-        missingLibraries: [], // 缺失库无法修复
+        // 本地未缓存依赖是用户允许的缓存状态，修复流程不下载也不移除依赖记录。
+        missingLibraries: [],
         staleReferences: selected.includes('staleReferences')
             ? issues.staleReferences
             : [],
@@ -695,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();
@@ -728,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})`);
         }
@@ -755,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) {
@@ -782,7 +1027,100 @@ async function fixAllIssues(issues, options) {
     separator();
     info('正在修复...');
     blank();
-    await withGlobalLock(() => applyAllIssueFixes(issues));
+    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]);
@@ -839,6 +1177,7 @@ async function applyAllIssueFixes(issues) {
     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 {
@@ -848,6 +1187,7 @@ async function applyAllIssueFixes(issues) {
         }
         catch (err) {
             error(`[err] 清理项目失败: ${p.path} - ${err.message}`);
+            failed++;
         }
     }
     // 2. 移除悬挂链接
@@ -856,7 +1196,11 @@ async function applyAllIssueFixes(issues) {
             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,
                 });
@@ -866,6 +1210,7 @@ async function applyAllIssueFixes(issues) {
         }
         catch (err) {
             error(`[err] 移除链接失败: ${link.path} - ${err.message}`);
+            failed++;
         }
     }
     // 3. 删除孤立库。显式修复允许清理该版本中的未登记内容。
@@ -886,9 +1231,11 @@ async function applyAllIssueFixes(issues) {
         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) {
@@ -898,6 +1245,7 @@ async function applyAllIssueFixes(issues) {
             const colonIndex = ref.libKey.lastIndexOf(':');
             if (colonIndex === -1) {
                 error(`[err] 无效的 libKey: ${ref.libKey}`);
+                failed++;
                 continue;
             }
             const libName = ref.libKey.slice(0, colonIndex);
@@ -911,6 +1259,7 @@ async function applyAllIssueFixes(issues) {
         }
         catch (err) {
             error(`[err] 移除引用失败: ${ref.libKey} - ${err.message}`);
+            failed++;
         }
     }
     // 5. 清理损坏的 Store 条目。共享冲突整版本处理，其他问题按平台处理。
@@ -948,16 +1297,24 @@ async function applyAllIssueFixes(issues) {
             for (const failure of result?.failed ?? []) {
                 error(`清理损坏 Store 失败: ${failure.id.libName}/${failure.id.commit.slice(0, 7)}/${failure.platform ?? 'all'} - ${failure.message}`);
             }
+            failed += result?.failed.length ?? (cleanup.selections.length > 0 ? 1 : 0);
         }
         catch (err) {
             error(`清理损坏 Store 失败: category=${cleanup.category} - ${err.message}`);
+            failed++;
         }
     }
     await registry.save();
     blank();
     separator();
-    success(`修复完成: ${fixed} 个问题已解决`);
-    debug(`[check] 修复完成: fixed=${fixed}`);
+    if (failed > 0) {
+        warn(`修复部分完成: 解决 ${fixed} 个问题，失败 ${failed} 项操作`);
+    }
+    else {
+        success(`修复完成: ${fixed} 个问题已解决`);
+    }
+    debug(`[check] 修复完成: fixed=${fixed}, failed=${failed}`);
+    return { fixed, failed };
 }
 // ============ 工具函数 ============
 async function getDirSizeRecursive(dirPath) {
@@ -1005,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 命令）
  */
@@ -1012,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 条目的文件完整性