@nexusclawhq/cli 0.2.1

package/dist/nexus-cli/src/services/workspace-health.test.js

@@ -0,0 +1,808 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = __importDefault(require("node:test"));
+const workspace_health_1 = require("./workspace-health");
+const pack_registry_1 = require("./pack-registry");
+async function withTempDir(run) {
+    const tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'nexus-workspace-health-'));
+    try {
+        await run(tempDir);
+    }
+    finally {
+        node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    }
+}
+function createProvider(dimensionName, result) {
+    return {
+        dimensionName,
+        async check(_context) {
+            if (result instanceof Error) {
+                throw result;
+            }
+            return result;
+        },
+    };
+}
+(0, node_test_1.default)('WorkspaceHealthService aggregates all dimension errors and warnings without loss', async () => {
+    const service = new workspace_health_1.WorkspaceHealthService({
+        now: () => new Date('2026-04-18T00:00:00.000Z'),
+    });
+    service.registerProvider(createProvider('manifest', {
+        dimensionName: 'manifest',
+        status: 'warning',
+        errors: [],
+        warnings: ['manifest warning 1', 'manifest warning 2'],
+    }));
+    service.registerProvider(createProvider('package-drift', {
+        dimensionName: 'package-drift',
+        status: 'error',
+        errors: ['package error 1', 'package error 2'],
+        warnings: [],
+    }));
+    service.registerProvider(createProvider('source-drift', {
+        dimensionName: 'source-drift',
+        status: 'healthy',
+        errors: [],
+        warnings: [],
+    }));
+    const report = await service.checkHealth({
+        workspaceRoot: '/tmp/workspace',
+        environmentName: 'dev',
+        workspaceId: 'ws-1',
+    });
+    strict_1.default.equal(report.timestamp, '2026-04-18T00:00:00.000Z');
+    strict_1.default.equal(report.overallStatus, 'error');
+    strict_1.default.deepEqual(report.errors, ['package error 1', 'package error 2']);
+    strict_1.default.deepEqual(report.warnings, ['manifest warning 1', 'manifest warning 2']);
+    strict_1.default.equal(report.summary.totalErrors, 2);
+    strict_1.default.equal(report.summary.totalWarnings, 2);
+    strict_1.default.equal(report.summary.warningDimensions, 1);
+    strict_1.default.equal(report.summary.errorDimensions, 1);
+    strict_1.default.equal(report.summary.healthyDimensions, 1);
+});
+(0, node_test_1.default)('computeOverallHealthStatus always reflects the worst active dimension status', () => {
+    const statuses = ['healthy', 'warning', 'error', 'skipped'];
+    const severity = new Map([
+        ['healthy', 0],
+        ['warning', 1],
+        ['error', 2],
+    ]);
+    for (const left of statuses) {
+        for (const middle of statuses) {
+            for (const right of statuses) {
+                const combination = [left, middle, right].map((status) => ({ status }));
+                const overall = (0, workspace_health_1.computeOverallHealthStatus)(combination);
+                const active = [left, middle, right].filter((status) => status !== 'skipped');
+                const expected = active.length === 0
+                    ? 'healthy'
+                    : active.reduce((worst, current) => (severity.get(current) > severity.get(worst) ? current : worst));
+                strict_1.default.equal(overall, expected);
+            }
+        }
+    }
+});
+(0, node_test_1.default)('WorkspaceHealthService isolates provider failures from other dimensions', async () => {
+    const service = new workspace_health_1.WorkspaceHealthService();
+    service.registerProvider(createProvider('manifest', {
+        dimensionName: 'manifest',
+        status: 'healthy',
+        errors: [],
+        warnings: [],
+    }));
+    service.registerProvider(createProvider('package-drift', new Error('registry exploded')));
+    service.registerProvider(createProvider('source-drift', {
+        dimensionName: 'source-drift',
+        status: 'warning',
+        errors: [],
+        warnings: ['remote drift detected'],
+    }));
+    const report = await service.checkHealth({
+        workspaceRoot: '/tmp/workspace',
+    });
+    strict_1.default.equal(report.overallStatus, 'error');
+    strict_1.default.equal(report.dimensions.length, 3);
+    strict_1.default.deepEqual(report.dimensions.map((dimension) => ({
+        dimensionName: dimension.dimensionName,
+        status: dimension.status,
+    })), [
+        { dimensionName: 'manifest', status: 'healthy' },
+        { dimensionName: 'package-drift', status: 'error' },
+        { dimensionName: 'source-drift', status: 'warning' },
+    ]);
+    strict_1.default.deepEqual(report.dimensions[1]?.errors, ['registry exploded']);
+    strict_1.default.deepEqual(report.dimensions[2]?.warnings, ['remote drift detected']);
+});
+(0, node_test_1.default)('WorkspaceHealthService creates audit trails that preserve report summaries', async () => {
+    const service = new workspace_health_1.WorkspaceHealthService({
+        now: () => new Date('2026-04-18T08:00:00.000Z'),
+    });
+    service.registerProvider(createProvider('manifest', {
+        dimensionName: 'manifest',
+        status: 'warning',
+        errors: [],
+        warnings: ['manifest warning'],
+    }));
+    const report = await service.checkHealth({
+        workspaceRoot: '/tmp/workspace',
+        environmentName: 'test',
+    });
+    const auditTrail = service.createAuditTrail(report);
+    strict_1.default.equal(auditTrail.timestamp, report.timestamp);
+    strict_1.default.equal(auditTrail.workspaceRoot, '/tmp/workspace');
+    strict_1.default.equal(auditTrail.environmentName, 'test');
+    strict_1.default.equal(auditTrail.overallStatus, 'warning');
+    strict_1.default.deepEqual(auditTrail.summary, report.summary);
+    strict_1.default.deepEqual(auditTrail.dimensions, [
+        {
+            dimensionName: 'manifest',
+            status: 'warning',
+            skipped: false,
+            errors: [],
+            warnings: ['manifest warning'],
+        },
+    ]);
+});
+(0, node_test_1.default)('ManifestValidatorProvider integrates with workspace-contract validation and metadata', async () => {
+    await withTempDir(async (tempDir) => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(tempDir, 'nexus-project.yaml'), [
+            'schemaVersion: dx-workspace/v1',
+            'projectName: crm-demo',
+            'compatibleCoreVersion: 0.1.x',
+            'sourceRoots:',
+            '  - path: src/metadata',
+            '    kind: metadata-runtime',
+            '    writeTarget: true',
+            'localPackages: []',
+            'environments: []',
+        ].join('\n'));
+        const provider = new workspace_health_1.ManifestValidatorProvider();
+        const result = await provider.check({ workspaceRoot: tempDir });
+        strict_1.default.equal(result.status, 'healthy');
+        strict_1.default.deepEqual(result.warnings, []);
+        strict_1.default.deepEqual(result.errors, []);
+        strict_1.default.deepEqual(result.metadata, {
+            manifestPath: node_path_1.default.join(tempDir, 'nexus-project.yaml'),
+            format: 'yaml',
+            migrated: false,
+        });
+    });
+});
+(0, node_test_1.default)('ManifestValidatorProvider maps validation warnings to warning status', async () => {
+    const provider = new workspace_health_1.ManifestValidatorProvider({
+        loadWorkspaceManifest: () => ({
+            workspaceRoot: '/tmp/workspace',
+            manifestPath: '/tmp/workspace/nexus-project.yaml',
+            format: 'yaml',
+            migrated: false,
+            warnings: [],
+            manifest: {
+                schemaVersion: 'dx-workspace/v1',
+                projectName: 'crm-demo',
+                compatibleCoreVersion: '0.1.x',
+                sourceRoots: [],
+                localPackages: [],
+                environments: [],
+            },
+        }),
+        validateWorkspaceManifest: () => ({
+            valid: true,
+            errors: [],
+            warnings: ['defaultEnvironment is empty'],
+        }),
+    });
+    const result = await provider.check({ workspaceRoot: '/tmp/workspace' });
+    strict_1.default.equal(result.status, 'warning');
+    strict_1.default.deepEqual(result.errors, []);
+    strict_1.default.deepEqual(result.warnings, ['defaultEnvironment is empty']);
+    strict_1.default.deepEqual(result.metadata, {
+        manifestPath: '/tmp/workspace/nexus-project.yaml',
+        format: 'yaml',
+        migrated: false,
+    });
+});
+(0, node_test_1.default)('PackageDriftDetectorProvider skips when workspace id is unavailable', async () => {
+    const provider = new workspace_health_1.PackageDriftDetectorProvider();
+    const result = await provider.check({ workspaceRoot: '/tmp/workspace' });
+    strict_1.default.equal(result.status, 'skipped');
+    strict_1.default.equal(result.skipped, true);
+    strict_1.default.equal(result.skipReason, 'workspace-id not available');
+});
+(0, node_test_1.default)('PackageDriftDetectorProvider maps validation warnings and metadata from provider inputs', async () => {
+    const provider = new workspace_health_1.PackageDriftDetectorProvider({
+        loadWorkspaceManifest: () => ({
+            workspaceRoot: '/tmp/workspace',
+            manifestPath: '/tmp/workspace/nexus-project.yaml',
+            format: 'yaml',
+            migrated: false,
+            warnings: [],
+            manifest: {
+                schemaVersion: 'dx-workspace/v1',
+                projectName: 'crm-demo',
+                compatibleCoreVersion: '0.1.x',
+                sourceRoots: [],
+                localPackages: [],
+                environments: [],
+                packageRefs: ['core.baseline@1.0.0'],
+            },
+        }),
+        resolveRegistryRoot: () => '/tmp/workspace/registry',
+        validateRegistryInstall: () => ({
+            valid: false,
+            errors: ['workspace 安装版本漂移: core.baseline runtime=0.9.0 registry=1.0.0'],
+            warnings: [],
+        }),
+        apiClientFactory: () => ({
+            listInstalledMetadataPackages: async () => [
+                {
+                    id: 'pkg-1',
+                    workspaceId: 'ws-1',
+                    packageName: 'core.baseline',
+                    version: '0.9.0',
+                    installSource: 'registry',
+                    status: 'installed',
+                    installedAt: '2026-04-18T00:00:00.000Z',
+                    updatedAt: '2026-04-18T00:00:00.000Z',
+                    manifest: {
+                        schemaVersion: 'v1',
+                        name: 'core.baseline',
+                        packageType: 'core-baseline',
+                        packageClass: 'metadata',
+                        description: 'Core baseline metadata package for workspace health tests.',
+                        version: '0.9.0',
+                        dependencies: [],
+                        compatibleCoreVersion: '^1.0.0',
+                        installOrder: 100,
+                        includedMetadataKinds: ['objects'],
+                        includedSeedKinds: [],
+                        visibility: 'internal',
+                        releaseChannel: 'stable',
+                        kindSupport: [{ kind: 'objects', executionMode: 'installer-input-backed' }],
+                    },
+                },
+            ],
+        }),
+    });
+    const result = await provider.check({
+        workspaceRoot: '/tmp/workspace',
+        workspaceId: 'ws-1',
+    });
+    strict_1.default.equal(result.status, 'error');
+    strict_1.default.deepEqual(result.errors, ['workspace 安装版本漂移: core.baseline runtime=0.9.0 registry=1.0.0']);
+    strict_1.default.deepEqual(result.metadata, {
+        registryRoot: '/tmp/workspace/registry',
+        declaredPackages: [{ packageName: 'core.baseline', version: '1.0.0' }],
+        installedPackages: [{ packageName: 'core.baseline', version: '0.9.0', status: 'installed' }],
+    });
+});
+(0, node_test_1.default)('PackageDriftDetectorProvider integrates with registry install validation', async () => {
+    await withTempDir(async (tempDir) => {
+        const registryRoot = node_path_1.default.join(tempDir, 'workspace-packages');
+        const sourcePackageDir = node_path_1.default.join(tempDir, 'source-package');
+        node_fs_1.default.mkdirSync(registryRoot, { recursive: true });
+        node_fs_1.default.mkdirSync(sourcePackageDir, { recursive: true });
+        node_fs_1.default.writeFileSync(node_path_1.default.join(tempDir, 'nexus-project.yaml'), [
+            'schemaVersion: dx-workspace/v1',
+            'projectName: crm-demo',
+            'compatibleCoreVersion: 0.1.x',
+            'sourceRoots:',
+            '  - path: src/metadata',
+            '    kind: metadata-runtime',
+            '    writeTarget: true',
+            'localPackages: []',
+            'environments: []',
+            'registry:',
+            '  rootDirectory: workspace-packages',
+            'packageRefs:',
+            '  - core.baseline@1.0.0',
+        ].join('\n'));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(sourcePackageDir, 'package.yaml'), [
+            'schemaVersion: v1',
+            'name: core.baseline',
+            'packageType: core-baseline',
+            'packageClass: metadata',
+            'description: Core baseline metadata package for workspace health tests.',
+            'version: 1.0.0',
+            'dependencies: []',
+            'compatibleCoreVersion: ^1.0.0',
+            'installOrder: 100',
+            'includedMetadataKinds: [objects]',
+            'includedSeedKinds: []',
+            'visibility: internal',
+            'releaseChannel: stable',
+            'kindSupport:',
+            '  - kind: objects',
+            '    executionMode: installer-input-backed',
+        ].join('\n'));
+        (0, pack_registry_1.publishPackageToLocalRegistry)({
+            registryRoot,
+            packageDirectory: sourcePackageDir,
+            manifest: {
+                schemaVersion: 'v1',
+                name: 'core.baseline',
+                packageType: 'core-baseline',
+                packageClass: 'metadata',
+                description: 'Core baseline metadata package for workspace health tests.',
+                version: '1.0.0',
+                dependencies: [],
+                compatibleCoreVersion: '^1.0.0',
+                installOrder: 100,
+                includedMetadataKinds: ['objects'],
+                includedSeedKinds: [],
+                visibility: 'internal',
+                releaseChannel: 'stable',
+                kindSupport: [{ kind: 'objects', executionMode: 'installer-input-backed' }],
+            },
+        });
+        const provider = new workspace_health_1.PackageDriftDetectorProvider({
+            apiClientFactory: () => ({
+                listInstalledMetadataPackages: async () => [
+                    {
+                        id: 'pkg-1',
+                        workspaceId: 'ws-1',
+                        packageName: 'core.baseline',
+                        version: '0.9.0',
+                        installSource: 'registry',
+                        status: 'installed',
+                        installedAt: '2026-04-18T00:00:00.000Z',
+                        updatedAt: '2026-04-18T00:00:00.000Z',
+                        manifest: {
+                            schemaVersion: 'v1',
+                            name: 'core.baseline',
+                            packageType: 'core-baseline',
+                            packageClass: 'metadata',
+                            description: 'Core baseline metadata package for workspace health tests.',
+                            version: '0.9.0',
+                            dependencies: [],
+                            compatibleCoreVersion: '^1.0.0',
+                            installOrder: 100,
+                            includedMetadataKinds: ['objects'],
+                            includedSeedKinds: [],
+                            visibility: 'internal',
+                            releaseChannel: 'stable',
+                            kindSupport: [{ kind: 'objects', executionMode: 'installer-input-backed' }],
+                        },
+                    },
+                ],
+            }),
+        });
+        const result = await provider.check({
+            workspaceRoot: tempDir,
+            workspaceId: 'ws-1',
+        });
+        strict_1.default.equal(result.status, 'error');
+        strict_1.default.ok(result.errors.length > 0);
+        strict_1.default.ok(result.metadata);
+        strict_1.default.equal(result.metadata.registryRoot, registryRoot);
+    });
+});
+(0, node_test_1.default)('SourceDriftDetectorProvider skips when workspace id is unavailable', async () => {
+    const provider = new workspace_health_1.SourceDriftDetectorProvider();
+    const result = await provider.check({ workspaceRoot: '/tmp/workspace' });
+    strict_1.default.equal(result.status, 'skipped');
+    strict_1.default.equal(result.skipped, true);
+    strict_1.default.equal(result.skipReason, 'workspace-id not available');
+});
+(0, node_test_1.default)('SourceDriftDetectorProvider integrates with calculateSourceStatus counts', async () => {
+    await withTempDir(async (tempDir) => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(tempDir, 'nexus-project.yaml'), [
+            'schemaVersion: dx-workspace/v1',
+            'projectName: crm-demo',
+            'compatibleCoreVersion: 0.1.x',
+            'sourceRoots:',
+            '  - path: src/metadata',
+            '    kind: metadata-runtime',
+            '    writeTarget: true',
+            'localPackages: []',
+            'environments: []',
+        ].join('\n'));
+        const provider = new workspace_health_1.SourceDriftDetectorProvider({
+            apiClientFactory: () => ({
+                getSourceStatus: async () => ({
+                    remoteRevision: 'rev-1',
+                    baselineAvailable: false,
+                    files: [
+                        {
+                            path: 'objects/Account/object.json',
+                            hash: 'remote-hash',
+                            componentKey: 'object:Account',
+                        },
+                    ],
+                    baselineFiles: [],
+                    drift: {
+                        baselineAvailable: false,
+                        totalChanges: 0,
+                        humanSummary: [],
+                    },
+                    changedComponentCount: 1,
+                    tracking: null,
+                }),
+            }),
+        });
+        const result = await provider.check({
+            workspaceRoot: tempDir,
+            workspaceId: 'ws-1',
+        });
+        strict_1.default.equal(result.status, 'warning');
+        strict_1.default.deepEqual(result.errors, []);
+        strict_1.default.ok(result.warnings.includes('source remote-new: 1 file(s)'));
+        strict_1.default.ok(result.warnings.includes('source baseline-missing: 1 file(s)'));
+        strict_1.default.deepEqual(result.metadata, {
+            counts: {
+                synced: 0,
+                'local-new': 0,
+                'local-changed': 0,
+                'local-delete': 0,
+                'remote-new': 1,
+                'remote-changed': 0,
+                'remote-delete': 0,
+                conflict: 0,
+                drifted: 0,
+                'baseline-missing': 1,
+            },
+            changedComponentCount: 1,
+            remoteRevision: 'rev-1',
+            baselineRevision: null,
+        });
+    });
+});
+(0, node_test_1.default)('SourceDriftDetectorProvider marks conflicts as errors', async () => {
+    const provider = new workspace_health_1.SourceDriftDetectorProvider({
+        calculateSourceStatus: () => [
+            {
+                path: 'objects/Account/object.json',
+                componentKey: 'object:Account',
+                syncStatus: 'conflict',
+                driftStatus: 'drifted',
+                localHash: 'local',
+                remoteHash: 'remote',
+                lastSyncedHash: 'base',
+                baselineHash: 'base',
+            },
+        ],
+        apiClientFactory: () => ({
+            getSourceStatus: async () => ({
+                remoteRevision: 'rev-2',
+                baselineAvailable: true,
+                files: [],
+                baselineFiles: [],
+                drift: {
+                    baselineAvailable: true,
+                    totalChanges: 1,
+                    humanSummary: ['objects changed'],
+                },
+                changedComponentCount: 1,
+                tracking: null,
+            }),
+        }),
+    });
+    const result = await provider.check({
+        workspaceRoot: '/tmp/workspace',
+        workspaceId: 'ws-1',
+    });
+    strict_1.default.equal(result.status, 'error');
+    strict_1.default.ok(result.errors.includes('source conflict: 1 file(s)'));
+    strict_1.default.ok(result.errors.includes('conflict: objects/Account/object.json'));
+});
+(0, node_test_1.default)('EnvironmentStackAnalyzerProvider skips missing descriptors with explanation', async () => {
+    const provider = new workspace_health_1.EnvironmentStackAnalyzerProvider({
+        loadEnvironmentDescriptor: () => {
+            throw new Error('Environment descriptor "dev" was not found.');
+        },
+    });
+    const result = await provider.check({
+        workspaceRoot: '/tmp/workspace',
+        environmentName: 'dev',
+    });
+    strict_1.default.equal(result.status, 'skipped');
+    strict_1.default.equal(result.skipped, true);
+    strict_1.default.equal(result.skipReason, 'Environment descriptor "dev" was not found.');
+});
+(0, node_test_1.default)('EnvironmentStackAnalyzerProvider integrates with environment descriptor loading', async () => {
+    await withTempDir(async (tempDir) => {
+        node_fs_1.default.mkdirSync(node_path_1.default.join(tempDir, 'env'), { recursive: true });
+        node_fs_1.default.writeFileSync(node_path_1.default.join(tempDir, 'nexus-project.yaml'), [
+            'schemaVersion: dx-workspace/v1',
+            'projectName: crm-demo',
+            'compatibleCoreVersion: 0.1.x',
+            'sourceRoots:',
+            '  - path: src/metadata',
+            '    kind: metadata-runtime',
+            '    writeTarget: true',
+            'localPackages: []',
+            'defaultEnvironment: dev',
+            'environments:',
+            '  - name: dev',
+            '    path: env/dev.sandbox.yaml',
+        ].join('\n'));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(tempDir, 'env', 'dev.sandbox.yaml'), [
+            'schemaVersion: dx-environment/v1',
+            'name: dev',
+            'type: dev-sandbox',
+            'target:',
+            '  workspaceId: ws-1',
+            'packageStack:',
+            '  baseline:',
+            '    packageName: core.baseline',
+            '    packageType: core-baseline',
+            '  genericOverlay:',
+            '    packageName: overlay.generic-crm',
+            '    packageType: generic-overlay',
+            '  industryOverlay:',
+            '    packageName: industry.healthcare',
+            '    packageType: industry-overlay',
+            '  extensionPacks:',
+            '    - packageName: ext.analytics',
+            '      packageType: extension-pack',
+            '  demoPack:',
+            '    packageName: demo.trial',
+            '    packageType: demo-pack',
+            '  environmentProfile:',
+            '    packageName: profile.dev',
+            '    packageType: environment-profile',
+        ].join('\n'));
+        const provider = new workspace_health_1.EnvironmentStackAnalyzerProvider();
+        const result = await provider.check({
+            workspaceRoot: tempDir,
+            environmentName: 'dev',
+        });
+        strict_1.default.equal(result.status, 'healthy');
+        strict_1.default.deepEqual(result.errors, []);
+        strict_1.default.deepEqual(result.warnings, []);
+        strict_1.default.deepEqual(result.metadata, {
+            descriptorPath: node_path_1.default.join(tempDir, 'env', 'dev.sandbox.yaml'),
+            environmentName: 'dev',
+            environmentType: 'dev-sandbox',
+            baseline: { packageName: 'core.baseline', packageType: 'core-baseline' },
+            genericOverlay: { packageName: 'overlay.generic-crm', packageType: 'generic-overlay' },
+            industryOverlay: { packageName: 'industry.healthcare', packageType: 'industry-overlay' },
+            extensionPacks: [{ packageName: 'ext.analytics', packageType: 'extension-pack' }],
+            demoPack: { packageName: 'demo.trial', packageType: 'demo-pack' },
+            environmentProfile: { packageName: 'profile.dev', packageType: 'environment-profile' },
+        });
+    });
+});
+(0, node_test_1.default)('provider execution order does not affect individual provider results', async () => {
+    const providerA = createProvider('manifest', {
+        dimensionName: 'manifest',
+        status: 'healthy',
+        errors: [],
+        warnings: [],
+    });
+    const providerB = createProvider('package-drift', new Error('package drift failure'));
+    const providerC = createProvider('source-drift', {
+        dimensionName: 'source-drift',
+        status: 'warning',
+        errors: [],
+        warnings: ['source drift warning'],
+    });
+    const serviceA = new workspace_health_1.WorkspaceHealthService();
+    serviceA.registerProvider(providerA);
+    serviceA.registerProvider(providerB);
+    serviceA.registerProvider(providerC);
+    const serviceB = new workspace_health_1.WorkspaceHealthService();
+    serviceB.registerProvider(providerC);
+    serviceB.registerProvider(providerA);
+    serviceB.registerProvider(providerB);
+    const [reportA, reportB] = await Promise.all([
+        serviceA.checkHealth({ workspaceRoot: '/tmp/workspace' }),
+        serviceB.checkHealth({ workspaceRoot: '/tmp/workspace' }),
+    ]);
+    const normalize = (report) => ([...report.dimensions]
+        .map((dimension) => ({
+        dimensionName: dimension.dimensionName,
+        status: dimension.status,
+        errors: dimension.errors,
+        warnings: dimension.warnings,
+    }))
+        .sort((left, right) => left.dimensionName.localeCompare(right.dimensionName)));
+    strict_1.default.deepEqual(normalize(reportA), normalize(reportB));
+});
+(0, node_test_1.default)('formatHealthReport renders terminal output with dimension summaries and verbose details', () => {
+    const output = (0, workspace_health_1.formatHealthReport)({
+        timestamp: '2026-04-18T00:00:00.000Z',
+        workspaceRoot: '/tmp/workspace',
+        environmentName: 'dev',
+        workspaceId: 'ws-1',
+        overallStatus: 'warning',
+        errors: [],
+        warnings: ['source remote-new: 1 file(s)'],
+        dimensions: [
+            {
+                dimensionName: 'manifest',
+                status: 'healthy',
+                errors: [],
+                warnings: [],
+                metadata: {
+                    manifestPath: '/tmp/workspace/nexus-project.yaml',
+                    format: 'yaml',
+                },
+            },
+            {
+                dimensionName: 'source-drift',
+                status: 'warning',
+                errors: [],
+                warnings: ['source remote-new: 1 file(s)'],
+                metadata: {
+                    counts: {
+                        synced: 0,
+                        'local-new': 0,
+                        'local-changed': 0,
+                        'local-delete': 0,
+                        'remote-new': 1,
+                        'remote-changed': 0,
+                        'remote-delete': 0,
+                        conflict: 0,
+                        drifted: 0,
+                        'baseline-missing': 1,
+                    },
+                },
+            },
+        ],
+        summary: {
+            totalErrors: 0,
+            totalWarnings: 1,
+            healthyDimensions: 1,
+            warningDimensions: 1,
+            errorDimensions: 0,
+            skippedDimensions: 0,
+        },
+    }, {
+        verbose: true,
+        colors: {
+            healthy: (value) => `[green]${value}[/green]`,
+            warning: (value) => `[yellow]${value}[/yellow]`,
+            error: (value) => `[red]${value}[/red]`,
+            skipped: (value) => `[gray]${value}[/gray]`,
+        },
+    });
+    strict_1.default.match(output, /\[yellow]WORKSPACE HEALTH WARNING\[\/yellow]/);
+    strict_1.default.match(output, /\[green]\[HEALTHY] manifest\[\/green]/);
+    strict_1.default.match(output, /manifest: \/tmp\/workspace\/nexus-project.yaml \(yaml\)/);
+    strict_1.default.match(output, /\[yellow]\[WARNING] source-drift\[\/yellow]/);
+    strict_1.default.match(output, /counts: remote-new=1, baseline-missing=1/);
+    strict_1.default.match(output, /source remote-new: 1 file\(s\)/);
+    strict_1.default.match(output, /details:/);
+});
+(0, node_test_1.default)('health report JSON formatting preserves round-trip structure', () => {
+    const reports = Array.from({ length: 5 }, (_, index) => ({
+        timestamp: `2026-04-18T00:00:0${index}.000Z`,
+        workspaceRoot: `/tmp/workspace-${index}`,
+        environmentName: index % 2 === 0 ? 'dev' : undefined,
+        workspaceId: `ws-${index}`,
+        overallStatus: index % 3 === 0 ? 'error' : index % 3 === 1 ? 'warning' : 'healthy',
+        dimensions: [
+            {
+                dimensionName: 'manifest',
+                status: index % 2 === 0 ? 'healthy' : 'warning',
+                errors: index % 2 === 0 ? [] : ['manifest issue'],
+                warnings: index % 2 === 0 ? [] : ['manifest warning'],
+                metadata: {
+                    manifestPath: `/tmp/workspace-${index}/nexus-project.yaml`,
+                    format: 'yaml',
+                },
+            },
+        ],
+        errors: index % 2 === 0 ? [] : ['manifest issue'],
+        warnings: index % 2 === 0 ? [] : ['manifest warning'],
+        summary: {
+            totalErrors: index % 2 === 0 ? 0 : 1,
+            totalWarnings: index % 2 === 0 ? 0 : 1,
+            healthyDimensions: index % 2 === 0 ? 1 : 0,
+            warningDimensions: index % 2 === 0 ? 0 : 1,
+            errorDimensions: 0,
+            skippedDimensions: 0,
+        },
+    }));
+    for (const report of reports) {
+        strict_1.default.deepEqual(JSON.parse((0, workspace_health_1.formatHealthReportAsJson)(report)), JSON.parse(JSON.stringify(report)));
+    }
+});
+(0, node_test_1.default)('persistAuditTrail writes a complete audit snapshot to disk', async () => {
+    await withTempDir(async (tempDir) => {
+        const service = new workspace_health_1.WorkspaceHealthService({
+            now: () => new Date('2026-04-18T12:00:00.000Z'),
+        });
+        service.registerProvider(createProvider('manifest', {
+            dimensionName: 'manifest',
+            status: 'warning',
+            errors: [],
+            warnings: ['manifest warning'],
+        }));
+        const report = await service.checkHealth({
+            workspaceRoot: tempDir,
+            environmentName: 'dev',
+        });
+        const auditTrail = service.createAuditTrail(report);
+        const auditPath = (0, workspace_health_1.persistAuditTrail)(auditTrail, tempDir);
+        const persisted = JSON.parse(node_fs_1.default.readFileSync(auditPath, 'utf8'));
+        strict_1.default.equal(auditPath, node_path_1.default.join(tempDir, '.nexus-workspace-health.json'));
+        strict_1.default.equal(persisted.overallStatus, report.overallStatus);
+        strict_1.default.deepEqual(persisted.summary, report.summary);
+        strict_1.default.deepEqual(persisted.dimensions.map((dimension) => ({
+            dimensionName: dimension.dimensionName,
+            status: dimension.status,
+        })), report.dimensions.map((dimension) => ({
+            dimensionName: dimension.dimensionName,
+            status: dimension.status,
+        })));
+    });
+});
+(0, node_test_1.default)('WorkspaceHealthService remains idempotent for stable provider inputs', async () => {
+    const service = new workspace_health_1.WorkspaceHealthService({
+        now: () => new Date('2026-04-18T00:00:00.000Z'),
+    });
+    service.registerProvider(createProvider('manifest', {
+        dimensionName: 'manifest',
+        status: 'healthy',
+        errors: [],
+        warnings: [],
+    }));
+    service.registerProvider(createProvider('source-drift', {
+        dimensionName: 'source-drift',
+        status: 'warning',
+        errors: [],
+        warnings: ['remote drift detected'],
+    }));
+    const context = {
+        workspaceRoot: '/tmp/workspace',
+        workspaceId: 'ws-1',
+        environmentName: 'dev',
+    };
+    const first = await service.checkHealth(context);
+    const second = await service.checkHealth(context);
+    strict_1.default.equal(first.overallStatus, second.overallStatus);
+    strict_1.default.deepEqual(first.dimensions, second.dimensions);
+    strict_1.default.deepEqual(first.errors, second.errors);
+    strict_1.default.deepEqual(first.warnings, second.warnings);
+    strict_1.default.deepEqual(first.summary, second.summary);
+});
+(0, node_test_1.default)('createWorkspaceHealthService produces stable skip results when prerequisites are missing', async () => {
+    const service = (0, workspace_health_1.createWorkspaceHealthService)({
+        now: () => new Date('2026-04-18T00:00:00.000Z'),
+    });
+    const first = await service.checkHealth({
+        workspaceRoot: '/tmp/nonexistent-workspace',
+        environmentName: 'dev',
+    });
+    const second = await service.checkHealth({
+        workspaceRoot: '/tmp/nonexistent-workspace',
+        environmentName: 'dev',
+    });
+    const pickSkipStates = (report) => (report.dimensions
+        .filter((dimension) => ['package-drift', 'source-drift', 'environment-stack'].includes(dimension.dimensionName))
+        .map((dimension) => ({
+        dimensionName: dimension.dimensionName,
+        status: dimension.status,
+        skipped: dimension.skipped,
+        skipReason: dimension.skipReason,
+    })));
+    strict_1.default.deepEqual(pickSkipStates(first), pickSkipStates(second));
+    strict_1.default.deepEqual(pickSkipStates(first), [
+        {
+            dimensionName: 'package-drift',
+            status: 'skipped',
+            skipped: true,
+            skipReason: 'workspace-id not available',
+        },
+        {
+            dimensionName: 'source-drift',
+            status: 'skipped',
+            skipped: true,
+            skipReason: 'workspace-id not available',
+        },
+        {
+            dimensionName: 'environment-stack',
+            status: 'skipped',
+            skipped: true,
+            skipReason: 'Environment descriptor "dev" was not found.',
+        },
+    ]);
+});
+//# sourceMappingURL=workspace-health.test.js.map