@tiangong-lca/cli 0.0.1

package/dist/src/lib/review-lifecyclemodel.js

@@ -0,0 +1,727 @@
+import { existsSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { readJsonArtifact, writeJsonArtifact, writeJsonLinesArtifact, writeTextArtifact, } from './artifacts.js';
+import { CliError } from './errors.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value.trim();
+    return normalized || null;
+}
+function deepGet(value, pathParts) {
+    let current = value;
+    for (const part of pathParts) {
+        if (!isRecord(current)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function listify(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (value === undefined || value === null) {
+        return [];
+    }
+    return [value];
+}
+function toNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function toNonNegativeInteger(value) {
+    const parsed = toNumber(value);
+    if (parsed === null || !Number.isInteger(parsed) || parsed < 0) {
+        return null;
+    }
+    return parsed;
+}
+function uniqueStrings(values) {
+    return [
+        ...new Set(values.filter((value) => typeof value === 'string' && value.trim().length > 0)),
+    ];
+}
+function copyJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function emptySeverityCounts() {
+    return {
+        error: 0,
+        warning: 0,
+        info: 0,
+    };
+}
+function severityCounts(findings) {
+    return findings.reduce((counts, finding) => {
+        counts[finding.severity] += 1;
+        return counts;
+    }, emptySeverityCounts());
+}
+function readRequiredJsonObject(filePath, missingCode, invalidCode, label) {
+    if (!existsSync(filePath)) {
+        throw new CliError(`Required lifecyclemodel ${label} artifact not found: ${filePath}`, {
+            code: missingCode,
+            exitCode: 2,
+            details: { filePath, label },
+        });
+    }
+    const value = readJsonArtifact(filePath);
+    if (!isRecord(value)) {
+        throw new CliError(`Expected lifecyclemodel ${label} artifact JSON object: ${filePath}`, {
+            code: invalidCode,
+            exitCode: 2,
+            details: { filePath, label },
+        });
+    }
+    return value;
+}
+function readOptionalJsonObject(filePath, invalidCode, label) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    const value = readJsonArtifact(filePath);
+    if (!isRecord(value)) {
+        throw new CliError(`Expected lifecyclemodel ${label} artifact JSON object: ${filePath}`, {
+            code: invalidCode,
+            exitCode: 2,
+            details: { filePath, label },
+        });
+    }
+    return value;
+}
+function readOptionalJsonArray(filePath, invalidCode, label) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    const value = readJsonArtifact(filePath);
+    if (!Array.isArray(value)) {
+        throw new CliError(`Expected lifecyclemodel ${label} artifact JSON array: ${filePath}`, {
+            code: invalidCode,
+            exitCode: 2,
+            details: { filePath, label },
+        });
+    }
+    return value;
+}
+function buildLayout(runRoot, outDir) {
+    const runId = path.basename(runRoot);
+    return {
+        runId,
+        runRoot,
+        outDir,
+        modelsDir: path.join(runRoot, 'models'),
+        reportsDir: path.join(runRoot, 'reports'),
+        manifestsDir: path.join(runRoot, 'manifests'),
+        runManifestPath: path.join(runRoot, 'manifests', 'run-manifest.json'),
+        invocationIndexPath: path.join(runRoot, 'manifests', 'invocation-index.json'),
+        validationReportPath: path.join(runRoot, 'reports', 'lifecyclemodel-validate-build-report.json'),
+        modelSummariesPath: path.join(outDir, 'model_summaries.jsonl'),
+        findingsPath: path.join(outDir, 'findings.jsonl'),
+        summaryPath: path.join(outDir, 'lifecyclemodel_review_summary.json'),
+        reviewZhPath: path.join(outDir, 'lifecyclemodel_review_zh.md'),
+        reviewEnPath: path.join(outDir, 'lifecyclemodel_review_en.md'),
+        timingPath: path.join(outDir, 'lifecyclemodel_review_timing.md'),
+        reportPath: path.join(outDir, 'lifecyclemodel_review_report.json'),
+    };
+}
+function resolveLayout(options) {
+    const runDir = nonEmptyString(options.runDir);
+    if (!runDir) {
+        throw new CliError('Missing required --run-dir for review lifecyclemodel.', {
+            code: 'LIFECYCLEMODEL_REVIEW_RUN_DIR_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    const outDir = nonEmptyString(options.outDir);
+    if (!outDir) {
+        throw new CliError('Missing required --out-dir for review lifecyclemodel.', {
+            code: 'LIFECYCLEMODEL_REVIEW_OUT_DIR_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    return buildLayout(path.resolve(runDir), path.resolve(outDir));
+}
+function ensureRunRootExists(layout) {
+    if (!existsSync(layout.runRoot)) {
+        throw new CliError(`lifecyclemodel review run root not found: ${layout.runRoot}`, {
+            code: 'LIFECYCLEMODEL_REVIEW_RUN_NOT_FOUND',
+            exitCode: 2,
+        });
+    }
+}
+function readRequiredRunManifest(layout) {
+    const manifest = readRequiredJsonObject(layout.runManifestPath, 'LIFECYCLEMODEL_REVIEW_RUN_MANIFEST_MISSING', 'LIFECYCLEMODEL_REVIEW_RUN_MANIFEST_INVALID', 'run-manifest');
+    const manifestRunId = nonEmptyString(manifest.runId);
+    if (manifestRunId && manifestRunId !== layout.runId) {
+        throw new CliError(`lifecyclemodel review run manifest runId mismatch: ${layout.runManifestPath}`, {
+            code: 'LIFECYCLEMODEL_REVIEW_RUN_MANIFEST_MISMATCH',
+            exitCode: 2,
+            details: {
+                expected: layout.runId,
+                actual: manifestRunId,
+            },
+        });
+    }
+    return manifest;
+}
+function readInvocationIndex(layout) {
+    if (!existsSync(layout.invocationIndexPath)) {
+        return {
+            schema_version: 1,
+            invocations: [],
+        };
+    }
+    const value = readJsonArtifact(layout.invocationIndexPath);
+    if (!isRecord(value)) {
+        throw new CliError(`Expected lifecyclemodel review invocation index JSON object: ${layout.invocationIndexPath}`, {
+            code: 'LIFECYCLEMODEL_REVIEW_INVOCATION_INDEX_INVALID',
+            exitCode: 2,
+        });
+    }
+    if (value.invocations === undefined) {
+        return {
+            schema_version: 1,
+            invocations: [],
+        };
+    }
+    if (!Array.isArray(value.invocations)) {
+        throw new CliError(`Expected lifecyclemodel review invocation index to contain an invocations array: ${layout.invocationIndexPath}`, {
+            code: 'LIFECYCLEMODEL_REVIEW_INVOCATION_INDEX_INVALID',
+            exitCode: 2,
+        });
+    }
+    return value;
+}
+function discoverModelEntries(layout) {
+    const runNames = existsSync(layout.modelsDir) ? readdirSync(layout.modelsDir).sort() : [];
+    const entries = runNames.flatMap((runName) => {
+        const lifecyclemodelsDir = path.join(layout.modelsDir, runName, 'tidas_bundle', 'lifecyclemodels');
+        if (!existsSync(lifecyclemodelsDir)) {
+            return [];
+        }
+        const modelFiles = readdirSync(lifecyclemodelsDir)
+            .filter((entry) => entry.endsWith('.json'))
+            .sort()
+            .map((entry) => path.join(lifecyclemodelsDir, entry));
+        if (modelFiles.length === 0) {
+            throw new CliError(`lifecyclemodel review found a bundle without lifecyclemodel JSON files: ${lifecyclemodelsDir}`, {
+                code: 'LIFECYCLEMODEL_REVIEW_MODELS_EMPTY',
+                exitCode: 2,
+            });
+        }
+        return [
+            {
+                runName,
+                modelFiles,
+                summaryPath: path.join(layout.modelsDir, runName, 'summary.json'),
+                connectionsPath: path.join(layout.modelsDir, runName, 'connections.json'),
+                processCatalogPath: path.join(layout.modelsDir, runName, 'process-catalog.json'),
+            },
+        ];
+    });
+    if (entries.length === 0) {
+        throw new CliError(`lifecyclemodel review run does not contain any model bundles: ${layout.modelsDir}`, {
+            code: 'LIFECYCLEMODEL_REVIEW_MODELS_NOT_FOUND',
+            exitCode: 2,
+        });
+    }
+    return entries;
+}
+function normalizeValidationIssue(raw) {
+    if (!isRecord(raw)) {
+        return {
+            issue_code: 'validation_issue',
+            severity: 'error',
+            category: 'unknown',
+            file_path: '<unknown>',
+            message: String(raw),
+            location: '<root>',
+            context: {},
+        };
+    }
+    const severity = raw.severity === 'warning' || raw.severity === 'info' || raw.severity === 'error'
+        ? raw.severity
+        : 'error';
+    return {
+        issue_code: nonEmptyString(raw.issue_code) ?? 'validation_issue',
+        severity,
+        category: nonEmptyString(raw.category) ?? 'unknown',
+        file_path: nonEmptyString(raw.file_path) ?? '<unknown>',
+        message: nonEmptyString(raw.message) ?? JSON.stringify(raw),
+        location: nonEmptyString(raw.location) ?? '<root>',
+        context: isRecord(raw.context) ? raw.context : {},
+    };
+}
+function collectValidationIssues(validation) {
+    const executionReports = Array.isArray(validation.reports) ? validation.reports : [];
+    const seen = new Set();
+    const issues = [];
+    executionReports.forEach((report) => {
+        if (!isRecord(report) || !isRecord(report.report)) {
+            return;
+        }
+        const rawIssues = Array.isArray(report.report.issues) ? report.report.issues : [];
+        rawIssues.forEach((rawIssue) => {
+            const issue = normalizeValidationIssue(rawIssue);
+            const key = JSON.stringify([
+                issue.issue_code,
+                issue.severity,
+                issue.category,
+                issue.file_path,
+                issue.message,
+                issue.location,
+            ]);
+            if (seen.has(key)) {
+                return;
+            }
+            seen.add(key);
+            issues.push(issue);
+        });
+    });
+    return issues;
+}
+function readValidationAggregate(layout) {
+    const aggregate = readOptionalJsonObject(layout.validationReportPath, 'LIFECYCLEMODEL_REVIEW_VALIDATION_REPORT_INVALID', 'validate-build report');
+    if (!aggregate) {
+        return {
+            ok: null,
+            reportPath: null,
+            modelReports: new Map(),
+        };
+    }
+    if (aggregate.model_reports !== undefined && !Array.isArray(aggregate.model_reports)) {
+        throw new CliError(`Expected lifecyclemodel validate-build report to contain a model_reports array: ${layout.validationReportPath}`, {
+            code: 'LIFECYCLEMODEL_REVIEW_VALIDATION_REPORT_INVALID',
+            exitCode: 2,
+        });
+    }
+    const modelReports = new Map();
+    for (const rawEntry of Array.isArray(aggregate.model_reports) ? aggregate.model_reports : []) {
+        if (!isRecord(rawEntry)) {
+            throw new CliError(`Expected lifecyclemodel validate-build model report entry JSON object: ${layout.validationReportPath}`, {
+                code: 'LIFECYCLEMODEL_REVIEW_VALIDATION_REPORT_INVALID',
+                exitCode: 2,
+            });
+        }
+        const runName = nonEmptyString(rawEntry.run_name);
+        if (!runName || !isRecord(rawEntry.validation)) {
+            throw new CliError(`Expected lifecyclemodel validate-build model report entry to contain run_name and validation: ${layout.validationReportPath}`, {
+                code: 'LIFECYCLEMODEL_REVIEW_VALIDATION_REPORT_INVALID',
+                exitCode: 2,
+            });
+        }
+        const validation = rawEntry.validation;
+        const executionReports = Array.isArray(validation.reports) ? validation.reports : [];
+        modelReports.set(runName, {
+            ok: typeof validation.ok === 'boolean' ? validation.ok : null,
+            reportFile: nonEmptyString(rawEntry.report_file),
+            engineCount: executionReports.length,
+            issues: collectValidationIssues(validation),
+        });
+    }
+    return {
+        ok: typeof aggregate.ok === 'boolean' ? aggregate.ok : null,
+        reportPath: layout.validationReportPath,
+        modelReports,
+    };
+}
+function modelRoot(value) {
+    return isRecord(value.lifeCycleModelDataSet)
+        ? value.lifeCycleModelDataSet
+        : value;
+}
+function readModelFileReviewInfo(filePath) {
+    const payload = readJsonArtifact(filePath);
+    if (!isRecord(payload)) {
+        throw new CliError(`Expected lifecyclemodel review payload JSON object: ${filePath}`, {
+            code: 'LIFECYCLEMODEL_REVIEW_MODEL_INVALID',
+            exitCode: 2,
+        });
+    }
+    const root = modelRoot(payload);
+    const processInstances = listify(deepGet(root, ['lifeCycleModelInformation', 'technology', 'processes', 'processInstance'])).filter(isRecord);
+    const zeroMultiplicationFactorCount = processInstances.filter((instance) => toNumber(instance['@multiplicationFactor']) === 0).length;
+    return {
+        modelFile: filePath,
+        modelUuid: nonEmptyString(deepGet(root, ['lifeCycleModelInformation', 'dataSetInformation', 'common:UUID'])) ?? path.basename(filePath),
+        modelVersion: nonEmptyString(deepGet(root, [
+            'administrativeInformation',
+            'publicationAndOwnership',
+            'common:dataSetVersion',
+        ])) ?? 'unknown',
+        referenceProcessInternalId: nonEmptyString(deepGet(root, [
+            'lifeCycleModelInformation',
+            'quantitativeReference',
+            'referenceToReferenceProcess',
+        ])),
+        resultingProcessUuid: nonEmptyString(deepGet(root, [
+            'lifeCycleModelInformation',
+            'dataSetInformation',
+            'referenceToResultingProcess',
+            '@refObjectId',
+        ])),
+        processInstanceCount: processInstances.length,
+        zeroMultiplicationFactorCount,
+    };
+}
+function makeFinding(runName, modelFile, severity, ruleId, source, message, evidence) {
+    return {
+        run_name: runName,
+        model_file: modelFile,
+        severity,
+        rule_id: ruleId,
+        source,
+        message,
+        evidence,
+    };
+}
+function buildModelReview(entry, validationAggregate) {
+    const summaryArtifact = readOptionalJsonObject(entry.summaryPath, 'LIFECYCLEMODEL_REVIEW_SUMMARY_INVALID', 'summary');
+    const connections = readOptionalJsonArray(entry.connectionsPath, 'LIFECYCLEMODEL_REVIEW_CONNECTIONS_INVALID', 'connections');
+    const processCatalog = readOptionalJsonArray(entry.processCatalogPath, 'LIFECYCLEMODEL_REVIEW_PROCESS_CATALOG_INVALID', 'process-catalog');
+    const modelFileInfos = entry.modelFiles.map((modelFile) => readModelFileReviewInfo(modelFile));
+    const validation = validationAggregate.modelReports.get(entry.runName) ?? {
+        ok: null,
+        reportFile: null,
+        engineCount: 0,
+        issues: [],
+    };
+    const findings = [];
+    validation.issues.forEach((issue) => {
+        findings.push(makeFinding(entry.runName, issue.file_path, issue.severity, `validation:${issue.issue_code}`, 'validation', issue.message, {
+            category: issue.category,
+            location: issue.location,
+            context: issue.context,
+        }));
+    });
+    const modelUuids = uniqueStrings(modelFileInfos.map((info) => info.modelUuid));
+    const modelVersions = uniqueStrings(modelFileInfos.map((info) => info.modelVersion));
+    const resultingProcessUuids = uniqueStrings(modelFileInfos.map((info) => info.resultingProcessUuid));
+    const referenceProcessInternalIds = uniqueStrings(modelFileInfos.map((info) => info.referenceProcessInternalId));
+    const referenceProcessUuids = uniqueStrings([
+        nonEmptyString(summaryArtifact?.reference_process_uuid),
+    ]);
+    const processInstanceCount = modelFileInfos.reduce((sum, info) => sum + info.processInstanceCount, 0);
+    const zeroMultiplicationFactorCount = modelFileInfos.reduce((sum, info) => sum + info.zeroMultiplicationFactorCount, 0);
+    const summaryProcessCount = toNonNegativeInteger(summaryArtifact?.process_count);
+    const summaryEdgeCount = toNonNegativeInteger(summaryArtifact?.edge_count);
+    const multiplicationFactors = isRecord(summaryArtifact?.multiplication_factors)
+        ? summaryArtifact?.multiplication_factors
+        : null;
+    const multiplicationFactorCount = multiplicationFactors
+        ? Object.keys(multiplicationFactors).length
+        : 0;
+    if (!summaryArtifact) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'warning', 'missing_model_summary', 'review', 'Model bundle is missing summary.json generated by lifecyclemodel auto-build.', {
+            summary_path: entry.summaryPath,
+        }));
+    }
+    if (!connections) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'warning', 'missing_connections_artifact', 'review', 'Model bundle is missing connections.json generated by lifecyclemodel auto-build.', {
+            connections_path: entry.connectionsPath,
+        }));
+    }
+    if (!processCatalog) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'warning', 'missing_process_catalog', 'review', 'Model bundle is missing process-catalog.json generated by lifecyclemodel auto-build.', {
+            process_catalog_path: entry.processCatalogPath,
+        }));
+    }
+    if (referenceProcessUuids.length === 0) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'warning', 'missing_reference_process_uuid', 'review', 'Review could not resolve reference_process_uuid from summary.json.', {
+            summary_path: summaryArtifact ? entry.summaryPath : null,
+        }));
+    }
+    if (resultingProcessUuids.length === 0) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'warning', 'missing_resulting_process_ref', 'review', 'Review could not resolve referenceToResultingProcess from the lifecyclemodel payload.', {
+            model_files: entry.modelFiles,
+        }));
+    }
+    if (processInstanceCount === 0) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'error', 'empty_process_instances', 'review', 'Lifecyclemodel payload does not contain any processInstance entries.', {
+            model_files: entry.modelFiles,
+        }));
+    }
+    if (summaryProcessCount !== null && summaryProcessCount !== processInstanceCount) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'warning', 'process_count_mismatch', 'review', 'summary.json process_count does not match the number of processInstance entries in the payload.', {
+            summary_process_count: summaryProcessCount,
+            process_instance_count: processInstanceCount,
+        }));
+    }
+    if (connections && summaryEdgeCount !== null && connections.length !== summaryEdgeCount) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'warning', 'edge_count_mismatch', 'review', 'summary.json edge_count does not match the connections.json row count.', {
+            summary_edge_count: summaryEdgeCount,
+            connection_count: connections.length,
+        }));
+    }
+    if (processCatalog && processCatalog.length !== processInstanceCount) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'warning', 'process_catalog_count_mismatch', 'review', 'process-catalog.json row count does not match the number of processInstance entries in the payload.', {
+            process_catalog_count: processCatalog.length,
+            process_instance_count: processInstanceCount,
+        }));
+    }
+    if (summaryArtifact &&
+        multiplicationFactors &&
+        multiplicationFactorCount !== processInstanceCount) {
+        findings.push(makeFinding(entry.runName, entry.modelFiles[0] ?? null, 'warning', 'multiplication_factor_count_mismatch', 'review', 'summary.json multiplication_factors count does not match the number of processInstance entries in the payload.', {
+            multiplication_factor_count: multiplicationFactorCount,
+            process_instance_count: processInstanceCount,
+        }));
+    }
+    const counts = severityCounts(findings);
+    return {
+        summary: {
+            run_name: entry.runName,
+            model_files: entry.modelFiles,
+            model_uuids: modelUuids,
+            model_versions: modelVersions,
+            reference_process_uuids: referenceProcessUuids,
+            reference_process_internal_ids: referenceProcessInternalIds,
+            resulting_process_uuids: resultingProcessUuids,
+            summary_process_count: summaryProcessCount,
+            process_instance_count: processInstanceCount,
+            summary_edge_count: summaryEdgeCount,
+            connection_count: connections ? connections.length : null,
+            process_catalog_count: processCatalog ? processCatalog.length : null,
+            multiplication_factor_count: multiplicationFactorCount,
+            zero_multiplication_factor_count: zeroMultiplicationFactorCount,
+            validation: {
+                available: validationAggregate.reportPath !== null,
+                ok: validation.ok,
+                report_file: validation.reportFile,
+                engine_count: validation.engineCount,
+                issue_count: validation.issues.length,
+            },
+            artifacts: {
+                summary: summaryArtifact ? entry.summaryPath : null,
+                connections: connections ? entry.connectionsPath : null,
+                process_catalog: processCatalog ? entry.processCatalogPath : null,
+            },
+            finding_count: findings.length,
+            severity_counts: counts,
+        },
+        findings,
+    };
+}
+function buildInvocationIndex(layout, invocationIndex, options, now) {
+    const priorInvocations = Array.isArray(invocationIndex.invocations)
+        ? [...invocationIndex.invocations]
+        : [];
+    const command = [
+        'review',
+        'lifecyclemodel',
+        '--run-dir',
+        options.runDir,
+        '--out-dir',
+        options.outDir,
+    ];
+    if (nonEmptyString(options.logicVersion)) {
+        command.push('--logic-version', options.logicVersion);
+    }
+    if (nonEmptyString(options.startTs)) {
+        command.push('--start-ts', options.startTs);
+    }
+    if (nonEmptyString(options.endTs)) {
+        command.push('--end-ts', options.endTs);
+    }
+    return {
+        ...invocationIndex,
+        schema_version: typeof invocationIndex.schema_version === 'number' ? invocationIndex.schema_version : 1,
+        invocations: [
+            ...priorInvocations,
+            {
+                command,
+                cwd: options.cwd ?? process.cwd(),
+                created_at: now.toISOString(),
+                run_id: layout.runId,
+                run_root: layout.runRoot,
+                report_path: layout.reportPath,
+            },
+        ],
+    };
+}
+function buildNextActions(layout, validationAggregate) {
+    return [
+        `inspect: ${layout.findingsPath}`,
+        validationAggregate.reportPath
+            ? `inspect: ${validationAggregate.reportPath}`
+            : `run: tiangong lifecyclemodel validate-build --run-dir ${layout.runRoot}`,
+        `run: tiangong lifecyclemodel publish-build --run-dir ${layout.runRoot}`,
+    ];
+}
+function renderZhReview(options) {
+    const lines = [
+        '# lifecyclemodel_review_zh\n',
+        `- run_id: \`${options.runId}\`\n`,
+        `- logic_version: \`${options.logicVersion}\`\n`,
+        `- run_root: \`${options.runRoot}\`\n`,
+        '\n## 总览\n',
+        `- model bundle 数量: **${options.modelSummaries.length}**\n`,
+        `- findings 数量: **${options.findings.length}**\n`,
+        `- validation report: \`${options.validation.available ? 'available' : 'missing'}\`\n`,
+    ];
+    lines.push('\n## 模型摘要\n|run name|model uuid 数|processInstance|connections|validation issues|findings|\n|---|---:|---:|---:|---:|---:|\n');
+    options.modelSummaries.forEach((summary) => {
+        lines.push(`|${summary.run_name}|${summary.model_uuids.length}|${summary.process_instance_count}|${summary.connection_count ?? 0}|${summary.validation.issue_count}|${summary.finding_count}|\n`);
+    });
+    lines.push('\n## Findings\n');
+    if (options.findings.length === 0) {
+        lines.push('- 未发现新的 lifecyclemodel review findings。\n');
+    }
+    else {
+        lines.push('\n|run name|severity|source|rule id|message|\n|---|---|---|---|---|\n');
+        options.findings.slice(0, 200).forEach((finding) => {
+            lines.push(`|${finding.run_name}|${finding.severity}|${finding.source}|${finding.rule_id}|${finding.message.replace(/\|/gu, '/')}|\n`);
+        });
+    }
+    lines.push('\n## 说明\n', '- 当前 review lifecyclemodel 保持 local-first / artifact-first，只读取现有 build run 与 validate-build 产物。\n', '- 当前命令不引入 Python、LangGraph 或 skill 私有 review runtime。\n');
+    return lines.join('');
+}
+function renderEnReview(options) {
+    const lines = [
+        '# lifecyclemodel_review_en\n',
+        `- run_id: \`${options.runId}\`\n`,
+        `- logic_version: \`${options.logicVersion}\`\n`,
+        `- run_root: \`${options.runRoot}\`\n`,
+        '\n## Summary\n',
+        `- model bundles: **${options.modelSummaries.length}**\n`,
+        `- findings: **${options.findings.length}**\n`,
+        `- validation report: \`${options.validation.available ? 'available' : 'missing'}\`\n`,
+    ];
+    lines.push('\n## Model overview\n|run name|model uuids|process instances|connections|validation issues|findings|\n|---|---:|---:|---:|---:|---:|\n');
+    options.modelSummaries.forEach((summary) => {
+        lines.push(`|${summary.run_name}|${summary.model_uuids.length}|${summary.process_instance_count}|${summary.connection_count ?? 0}|${summary.validation.issue_count}|${summary.finding_count}|\n`);
+    });
+    if (options.findings.length > 0) {
+        lines.push('\n## Findings\n');
+        options.findings.slice(0, 100).forEach((finding) => {
+            lines.push(`- [${finding.severity}] ${finding.run_name}: ${finding.message}\n`);
+        });
+    }
+    return lines.join('');
+}
+function renderTiming(options) {
+    const lines = ['# lifecyclemodel_review_timing\n', `- run_id: \`${options.runId}\`\n`];
+    if (options.startTs && options.endTs) {
+        const started = Date.parse(options.startTs);
+        const ended = Date.parse(options.endTs);
+        if (!Number.isFinite(started) || !Number.isFinite(ended)) {
+            throw new CliError('Expected --start-ts and --end-ts to be valid ISO timestamps.', {
+                code: 'LIFECYCLEMODEL_REVIEW_INVALID_TIMESTAMP',
+                exitCode: 2,
+            });
+        }
+        lines.push(`- start: \`${options.startTs}\`\n`);
+        lines.push(`- end: \`${options.endTs}\`\n`);
+        lines.push(`- total elapsed: **${((ended - started) / 60_000).toFixed(2)} min**\n`);
+    }
+    lines.push(`- model bundles reviewed: \`${options.modelCount}\`\n`);
+    lines.push('- major time consumers: model JSON parsing, validation issue aggregation, artifact checks.\n');
+    return lines.join('');
+}
+export async function runLifecyclemodelReview(options) {
+    const layout = resolveLayout(options);
+    ensureRunRootExists(layout);
+    readRequiredRunManifest(layout);
+    const invocationIndex = readInvocationIndex(layout);
+    const validationAggregate = readValidationAggregate(layout);
+    const modelEntries = discoverModelEntries(layout);
+    const logicVersion = options.logicVersion?.trim() || 'lifecyclemodel-review-v1.0';
+    const now = options.now ?? (() => new Date());
+    const generatedAt = now();
+    const reviewedModels = modelEntries.map((entry) => buildModelReview(entry, validationAggregate));
+    const modelSummaries = reviewedModels.map((model) => model.summary);
+    const findings = reviewedModels.flatMap((model) => model.findings);
+    const report = {
+        schema_version: 1,
+        generated_at_utc: generatedAt.toISOString(),
+        status: 'completed_local_lifecyclemodel_review',
+        run_id: layout.runId,
+        run_root: layout.runRoot,
+        out_dir: layout.outDir,
+        logic_version: logicVersion,
+        model_count: modelSummaries.length,
+        finding_count: findings.length,
+        severity_counts: severityCounts(findings),
+        validation: {
+            available: validationAggregate.reportPath !== null,
+            ok: validationAggregate.ok,
+            report: validationAggregate.reportPath,
+        },
+        files: {
+            run_manifest: layout.runManifestPath,
+            invocation_index: layout.invocationIndexPath,
+            validation_report: validationAggregate.reportPath,
+            model_summaries: layout.modelSummariesPath,
+            findings: layout.findingsPath,
+            summary: layout.summaryPath,
+            review_zh: layout.reviewZhPath,
+            review_en: layout.reviewEnPath,
+            timing: layout.timingPath,
+            report: layout.reportPath,
+        },
+        model_summaries: modelSummaries,
+        next_actions: buildNextActions(layout, validationAggregate),
+    };
+    writeJsonArtifact(layout.invocationIndexPath, buildInvocationIndex(layout, invocationIndex, options, generatedAt));
+    writeJsonLinesArtifact(layout.modelSummariesPath, modelSummaries);
+    writeJsonLinesArtifact(layout.findingsPath, findings);
+    writeJsonArtifact(layout.summaryPath, {
+        run_id: report.run_id,
+        logic_version: report.logic_version,
+        model_count: report.model_count,
+        finding_count: report.finding_count,
+        severity_counts: copyJson(report.severity_counts),
+        validation: copyJson(report.validation),
+    });
+    writeTextArtifact(layout.reviewZhPath, renderZhReview({
+        runId: report.run_id,
+        logicVersion: report.logic_version,
+        runRoot: report.run_root,
+        modelSummaries,
+        findings,
+        validation: report.validation,
+    }));
+    writeTextArtifact(layout.reviewEnPath, renderEnReview({
+        runId: report.run_id,
+        logicVersion: report.logic_version,
+        runRoot: report.run_root,
+        modelSummaries,
+        findings,
+        validation: report.validation,
+    }));
+    writeTextArtifact(layout.timingPath, renderTiming({
+        runId: report.run_id,
+        startTs: options.startTs,
+        endTs: options.endTs,
+        modelCount: report.model_count,
+    }));
+    writeJsonArtifact(layout.reportPath, report);
+    return report;
+}
+export const __testInternals = {
+    buildLayout,
+    resolveLayout,
+    readInvocationIndex,
+    discoverModelEntries,
+    readValidationAggregate,
+    readModelFileReviewInfo,
+    buildModelReview,
+    buildInvocationIndex,
+    buildNextActions,
+    renderZhReview,
+    renderEnReview,
+    renderTiming,
+};
+//# sourceMappingURL=review-lifecyclemodel.js.map