kld-sdd 2.6.16 → 2.6.21

package/skywalk-sdd/reporting/change-report-model.cjs

@@ -3,12 +3,25 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const {
+  CORE_METRIC_DEFINITIONS,
+  localizeStageName,
+  validateCoreMetricResult,
+} = require('./core-metric-definitions.cjs');
 
 let formatArtifactSize;
+let computeTelemetryHealthScore;
+let resolveScoreStatus;
 try {
-  ({ formatArtifactSize } = require('../metrics-v3.cjs'));
+  ({
+    formatArtifactSize,
+    computeTelemetryHealthScore,
+    resolveScoreStatus,
+  } = require('../metrics-v3.cjs'));
 } catch {
   formatArtifactSize = null;
+  computeTelemetryHealthScore = null;
+  resolveScoreStatus = null;
 }
 
 function formatArtifactSizeDisplay(bytes) {
@@ -36,6 +49,26 @@ const EVIDENCE_LABELS = {
   task_update_reuse: '测试结果被重复引用',
 };
 
+const RESOLVED_ISSUE_DISPOSITIONS = new Set([
+  'fixed',
+  'accepted',
+  'waived',
+  'informational',
+  'ignored',
+  'not-applicable',
+]);
+const CANONICAL_ISSUE_DISPOSITIONS = new Set([
+  ...RESOLVED_ISSUE_DISPOSITIONS,
+  'needs_input',
+  'open',
+]);
+
+function statusForDisposition(disposition, fallbackStatus = null) {
+  if (RESOLVED_ISSUE_DISPOSITIONS.has(disposition)) return 'resolved';
+  if (disposition === 'needs_input' || disposition === 'open') return 'open';
+  return fallbackStatus || 'open';
+}
+
 function eventTimestamp(event) {
   const raw = event?.timestamp || event?.ended_at || event?.started_at;
   const value = Date.parse(raw || '');
@@ -162,7 +195,7 @@ function issueGuidance(code) {
       expected: 'task_update 应直接引用覆盖当前任务的 strict 成功测试。',
       root_cause: 'test_event_id 缺失、无效或没有覆盖当前任务。',
       impact: '测试存在，但任务到测试的直接审计链不完整。',
-      remediation: '将 task_update 精确关联到覆盖当前任务的 strict 测试事件。',
+      remediation: '在任务完成事件 task_update 中填写 test_event_id，精确关联到覆盖当前任务的严格测试事件。',
     },
     TASK_TEST_EVIDENCE_MISSING: {
       expected: '任务应有严格成功测试，或有可审计的不适用理由。',
@@ -195,10 +228,9 @@ function normalizeIssue(alert, index) {
     ...(Array.isArray(alert.evidence_event_ids) ? alert.evidence_event_ids : []),
   ].filter(Boolean))];
   const subject = alert.subject || alert.task_id || alert.pair_id || null;
-  const status = alert.status
-    || (['fixed', 'accepted', 'waived'].includes(alert.disposition) ? 'resolved' : 'open');
+  const status = statusForDisposition(alert.disposition, alert.status);
   return {
-    issue_id: alert.issue_id || alert.key || `${code}:${subject || 'change'}:${index + 1}`,
+    issue_id: alert.issue_id || alert.key || `${code}:${subject || 'change'}`,
     category: alert.category || 'evidence',
     code,
     label: EVIDENCE_LABELS[code] || code,
@@ -236,11 +268,57 @@ function normalizeEvidenceSummary(report) {
       ...item,
       code: item.warning,
       occurrences: 1,
-      status: ['fixed', 'accepted', 'waived'].includes(item.disposition) ? 'resolved' : 'open',
+      status: statusForDisposition(item.disposition),
       last_seen_event_id: item.evidence_event_id,
     })),
   ];
-  const issues = history.map(normalizeIssue);
+  const issueByKey = new Map();
+  history.map(normalizeIssue).forEach((issue) => {
+    const stableKey = issue.issue_id
+      || `${issue.code}:${issue.task_id || issue.pair_id || issue.subject || 'change'}`;
+    const previous = issueByKey.get(stableKey);
+    if (!previous) {
+      issueByKey.set(stableKey, issue);
+      return;
+    }
+    const previousAt = Date.parse(
+      previous.history?.resolved_at
+      || previous.history?.last_seen_at
+      || previous.history?.first_seen_at
+      || '',
+    );
+    const currentAt = Date.parse(
+      issue.history?.resolved_at
+      || issue.history?.last_seen_at
+      || issue.history?.first_seen_at
+      || '',
+    );
+    const latest = !Number.isFinite(previousAt)
+      || (Number.isFinite(currentAt) && currentAt >= previousAt)
+      ? issue
+      : previous;
+    issueByKey.set(stableKey, {
+      ...previous,
+      ...latest,
+      occurrence_count: Math.max(previous.occurrence_count, issue.occurrence_count),
+      evidence_event_ids: [...new Set([
+        ...previous.evidence_event_ids,
+        ...issue.evidence_event_ids,
+      ])],
+      related_event_ids: [...new Set([
+        ...previous.related_event_ids,
+        ...issue.related_event_ids,
+      ])],
+      history: {
+        first_seen_at: previous.history?.first_seen_at || issue.history?.first_seen_at || null,
+        last_seen_at: latest.history?.last_seen_at || previous.history?.last_seen_at || null,
+        resolved_at: latest.status === 'resolved'
+          ? (latest.history?.resolved_at || previous.history?.resolved_at || null)
+          : null,
+      },
+    });
+  });
+  const issues = [...issueByKey.values()];
   const groups = new Map();
   for (const issue of issues) {
     const code = issue.code;
@@ -284,33 +362,741 @@ function normalizeChangedFiles(changedFiles = {}) {
     ? [...new Set(changedFiles.final_output_files)]
     : (Array.isArray(changedFiles.files) ? [...new Set(changedFiles.files)] : null);
   const taskCount = changedFiles.task_event_files_changed
-    ?? changedFiles.files_changed
     ?? taskEventFiles?.length
     ?? null;
   const finalCount = changedFiles.final_output_files_changed
     ?? finalOutputFiles?.length
     ?? null;
+  const taskSet = new Set(taskEventFiles || []);
+  const finalSet = new Set(finalOutputFiles || []);
+  const onlyInTaskEvents = [...taskSet].filter(file => !finalSet.has(file)).sort();
+  const onlyInFinalOutput = [...finalSet].filter(file => !taskSet.has(file)).sort();
   const countsDiffer = taskCount != null && finalCount != null && taskCount !== finalCount;
+  const listsDiffer = taskEventFiles != null
+    && finalOutputFiles != null
+    && (onlyInTaskEvents.length > 0 || onlyInFinalOutput.length > 0);
+  let reconciliationStatus = changedFiles.reconciliation_status || 'consistent';
+  let reconciliationNote = changedFiles.reconciliation_note || null;
+  if (taskCount == null && finalCount == null) {
+    reconciliationStatus = 'unavailable';
+    reconciliationNote = reconciliationNote
+      || '任务过程和最终输出均没有可用的文件证据，暂时无法对账。';
+  } else if (taskCount == null && finalCount != null) {
+    reconciliationStatus = 'task-evidence-missing';
+    reconciliationNote = '任务事件未记录文件清单或无文件原因；仅展示最终输出快照。';
+  } else if (taskCount != null && finalCount == null) {
+    reconciliationStatus = 'final-snapshot-missing';
+    reconciliationNote = '最终输出文件快照不可用，无法与任务事件对账。';
+  } else if (countsDiffer) {
+    reconciliationStatus = 'count-mismatch';
+  } else if (listsDiffer) {
+    reconciliationStatus = 'list-mismatch';
+  }
   const normalized = {
     ...changedFiles,
     task_event_files: taskEventFiles,
     task_event_files_changed: taskCount,
     final_output_files: finalOutputFiles,
     final_output_files_changed: finalCount,
-    diff_source: changedFiles.diff_source || 'dual-source',
+    diff_source: changedFiles.diff_source
+      || (taskCount == null && finalCount == null ? null : 'dual-source'),
     line_count_estimate: changedFiles.line_count_estimate ?? null,
-    reconciliation_status: changedFiles.reconciliation_status
-      || (countsDiffer ? 'count-mismatch' : 'consistent'),
-    reconciliation_note: changedFiles.reconciliation_note
+    only_in_task_events: onlyInTaskEvents,
+    only_in_final_output: onlyInFinalOutput,
+    reconciliation_status: reconciliationStatus,
+    reconciliation_note: reconciliationNote
       || (countsDiffer
         ? `任务事件累计涉及 ${taskCount} 个文件；最终输出快照包含 ${finalCount} 个文件。两者用途不同，不应合并为一个口径。`
-        : '任务事件与最终输出文件口径一致。'),
+        : (listsDiffer
+          ? `文件数量均为 ${taskCount}，但清单不同：任务过程独有 ${onlyInTaskEvents.length} 个，最终交付独有 ${onlyInFinalOutput.length} 个。`
+          : '任务过程中涉及的文件与最终实际交付的文件清单一致。')),
   };
   // v4：不再对外输出 legacy_fields；若调用方传入则显式剔除
   delete normalized.legacy_fields;
   return normalized;
 }
 
+const STANDARD_STAGES = new Set(['propose', 'spec', 'design', 'task', 'check', 'apply', 'archive']);
+const REWORK_REASON_LABELS = {
+  incomplete: '上一次没有正常结束',
+  'prev-failed': '上一次执行失败',
+  'code-changed-after-pass': '通过后发生开发活动，再次执行',
+  'recheck-no-change': '期间没有开发活动，属于重复复检',
+  'pre-archive-recheck': '归档前复检',
+  unspecified: '现有证据无法判断原因',
+};
+const CHECK_FALLBACK_REASON_LABELS = {
+  SUBAGENT_CAPABILITY_UNAVAILABLE: '当前宿主不提供可用的子代理能力',
+  SUBAGENT_PERMISSION_DENIED: '当前权限不允许启动子代理',
+  SUBAGENT_START_FAILED: '子代理启动失败',
+  SUBAGENT_TIMEOUT: '子代理执行超时',
+  SUBAGENT_RESULT_INVALID: '子代理返回结果不完整或无法校验',
+};
+
+function hasFiniteMetricNumber(value) {
+  if (typeof value === 'number') return Number.isFinite(value);
+  if (typeof value === 'string' && value.trim()) return Number.isFinite(Number(value));
+  return false;
+}
+
+function humanDuration(ms) {
+  if (!hasFiniteMetricNumber(ms) || Number(ms) < 0) return '暂无数据';
+  const seconds = Math.round(Number(ms) / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const remainder = seconds % 60;
+  return `${minutes > 0 ? `${minutes}分` : ''}${remainder}秒`;
+}
+
+function evidenceFor(report, key) {
+  const metricEvidence = report.metrics?.metric_evidence?.[key]
+    || report.metric_provenance?.[key]
+    || report.metric_evidence?.[key]
+    || {};
+  const ids = metricEvidence.event_ids
+    || metricEvidence.evidence_event_ids
+    || [];
+  return {
+    status: metricEvidence.status || null,
+    reason: metricEvidence.reason || null,
+    source_event_count: metricEvidence.source_event_count ?? null,
+    event_ids: Array.isArray(ids) ? ids : [],
+  };
+}
+
+function trustFor(report, key, fallbackStatus, explanation) {
+  const evidence = evidenceFor(report, key);
+  const status = evidence.status || fallbackStatus || 'provisional';
+  const defaultExplanation = (() => {
+    if (status === 'trusted' || status === 'verified') {
+      return '原始输入和来源证据完整。';
+    }
+    if (['missing', 'unavailable', 'pending-upstream'].includes(status)) {
+      return '当前没有可用的计算结果或来源证据。';
+    }
+    return '已有计算结果，但证据或独立复核信息仍不完整。';
+  })();
+  return {
+    status,
+    explanation: explanation || defaultExplanation,
+  };
+}
+
+function roundMetric(value, digits = 4) {
+  if (!Number.isFinite(Number(value))) return null;
+  const factor = 10 ** digits;
+  return Math.round(Number(value) * factor) / factor;
+}
+
+function applyConsistencyCheck(detail, expectedValue, comparable) {
+  const actualValue = detail?.result?.value;
+  if (!comparable || !hasFiniteMetricNumber(expectedValue)) {
+    return detail;
+  }
+  if (!hasFiniteMetricNumber(actualValue)) {
+    return {
+      ...detail,
+      trust: {
+        status: 'missing',
+        explanation: `按本页原始数据可复算为 ${expectedValue}，但报告结果缺失，不能标记为可信。`,
+        detail_downgrade: true,
+      },
+    };
+  }
+  const actual = Number(actualValue);
+  const expected = Number(expectedValue);
+  if (Math.abs(actual - expected) <= 0.0001) return detail;
+  return {
+    ...detail,
+    trust: {
+      status: 'inconsistent',
+      explanation: `计算明细与结果不一致：按本页原始数据复算应为 ${expected}，报告结果为 ${actual}。请检查上游采集或指标生成过程。`,
+    },
+  };
+}
+
+function markDetailInconsistent(detail, explanation) {
+  return {
+    ...detail,
+    trust: {
+      status: 'inconsistent',
+      explanation: `计算明细与结果不一致：${explanation}。请检查上游采集或指标生成过程。`,
+    },
+  };
+}
+
+function markDetailProvisional(detail, explanation) {
+  if (['inconsistent', 'missing'].includes(detail?.trust?.status)) return detail;
+  return {
+    ...detail,
+    trust: {
+      status: 'provisional',
+      explanation,
+      detail_downgrade: true,
+    },
+  };
+}
+
+function validateMetricDetailResult(metricKey, detail) {
+  const validation = validateCoreMetricResult(metricKey, detail?.result?.value);
+  if (validation.status === 'missing') {
+    return {
+      ...detail,
+      trust: {
+        status: 'missing',
+        explanation: '报告结果缺失或不是有效数字，不能标记为可信。',
+        detail_downgrade: true,
+      },
+    };
+  }
+  if (validation.status === 'invalid') {
+    return {
+      ...detail,
+      result: {
+        ...(detail.result || {}),
+        display_value: `无效值（原始记录：${detail.result.value}）`,
+      },
+      trust: {
+        status: 'inconsistent',
+        explanation: `${validation.explanation}请检查上游采集或指标生成过程。`,
+      },
+    };
+  }
+  return detail;
+}
+
+function metricValuesDiffer(left, right) {
+  return left !== null
+    && left !== undefined
+    && right !== null
+    && right !== undefined
+    && Number.isFinite(Number(left))
+    && Number.isFinite(Number(right))
+    && Math.abs(Number(left) - Number(right)) > 0.0001;
+}
+
+function buildMetricDetails(report) {
+  const metrics = report.metrics || {};
+  const efficiency = metrics.efficiency || {};
+  const quality = metrics.quality || {};
+  const process = metrics.process || {};
+  const telemetry = metrics.telemetry_health || {};
+  const nodes = Array.isArray(report.stage_timeline?.nodes) ? report.stage_timeline.nodes : [];
+  const includedNodes = nodes.filter(node => STANDARD_STAGES.has(node.stage || node.command));
+  const excludedNodes = nodes.filter(node => !STANDARD_STAGES.has(node.stage || node.command));
+  const includedNodeDurations = includedNodes.map(node => (
+    hasFiniteMetricNumber(node.duration_ms) ? Number(node.duration_ms) : null
+  ));
+  const invalidDetailedStageDurationCount = includedNodeDurations
+    .filter(duration => duration == null || duration < 0)
+    .length;
+  const hasDetailedStageDuration = includedNodes.length > 0
+    && invalidDetailedStageDurationCount === 0;
+  const detailedStageDuration = hasDetailedStageDuration
+    ? includedNodeDurations.reduce((sum, duration) => sum + duration, 0)
+    : null;
+  const stageDuration = efficiency.total_stage_duration_ms
+    ?? efficiency.measurement_stage_duration_ms
+    ?? process.rework_summary?.total_stage_duration_ms
+    ?? null;
+  const scenarioCount = efficiency.scenario_count ?? null;
+  const e1Value = efficiency.e1_scenario_delivery_efficiency_ms ?? null;
+  const e1Numerator = hasDetailedStageDuration ? detailedStageDuration : stageDuration;
+  const expectedE1 = e1Numerator != null
+    && Number.isFinite(Number(e1Numerator))
+    && Number(scenarioCount) > 0
+    ? roundMetric(Number(e1Numerator) / Number(scenarioCount))
+    : null;
+  const endpointElapsed = efficiency.e1_lead_time_ms ?? null;
+  const e1Evidence = evidenceFor(report, 'e1');
+
+  let e1 = applyConsistencyCheck({
+    ...CORE_METRIC_DEFINITIONS.e1,
+    raw_values: {
+      total_stage_duration_ms: stageDuration,
+      detailed_stage_duration_ms: detailedStageDuration,
+      endpoint_elapsed_ms: endpointElapsed,
+      scenario_count: scenarioCount,
+      stage_execution_count: nodes.length,
+      included_stage_execution_count: includedNodes.length,
+      excluded_stage_execution_count: excludedNodes.length,
+      expected_result: expectedE1,
+    },
+    raw_inputs: [
+      {
+        label: '标准阶段总耗时（含返工）',
+        value: stageDuration,
+        display_value: humanDuration(stageDuration),
+        source: '标准阶段开始/结束事件配对后的耗时合计',
+        included: true,
+      },
+      {
+        label: '验收场景总数',
+        value: scenarioCount,
+        display_value: scenarioCount == null ? '暂无数据' : `${scenarioCount} 条`,
+        source: (efficiency.scenario_sources || []).map(item => item.path).filter(Boolean).join('、') || 'spec.md 场景标题',
+        included: true,
+      },
+      ...nodes.map(node => ({
+        label: `${node.stage || node.command || '未知阶段'} · 第 ${node.round || 1} 轮`,
+        value: node.duration_ms ?? null,
+        display_value: humanDuration(node.duration_ms),
+        source: node.event_id || node.start_event_id || '阶段时间线',
+        included: STANDARD_STAGES.has(node.stage || node.command),
+        exclusion_reason: STANDARD_STAGES.has(node.stage || node.command)
+          ? null
+          : '辅助阶段不进入 E1 分子',
+      })),
+    ],
+    calculation_steps: [
+      hasDetailedStageDuration
+        ? `逐条相加 ${includedNodes.length} 条计入的标准阶段执行记录，明细合计为 ${detailedStageDuration} ms；汇总字段记录为 ${stageDuration ?? '暂无数据'} ms。`
+        : (includedNodes.length > 0
+          ? `${invalidDetailedStageDurationCount} 条计入的阶段明细缺少耗时或耗时无效，不能独立求和；暂用汇总字段 ${stageDuration ?? '暂无数据'} ms。`
+          : `当前没有可用于逐条求和的阶段明细，使用汇总字段 ${stageDuration ?? '暂无数据'} ms。`),
+      `从规约文档统计 ${scenarioCount ?? '暂无数据'} 条“##### 场景”验收场景。`,
+      e1Numerator != null && scenarioCount > 0
+        ? `代入公式：${e1Numerator} ÷ ${scenarioCount} = ${expectedE1} ms/场景；再与报告结果 ${e1Value} 对照。`
+        : '当前缺少可用分子或分母，不能完成除法。',
+    ],
+    result: {
+      value: e1Value,
+      display_value: e1Value == null ? '暂无数据' : `${humanDuration(e1Value)}/场景`,
+      unit: 'ms/场景',
+    },
+    trust: trustFor(report, 'e1', e1Evidence.status),
+    evidence: [
+      ...(efficiency.scenario_sources || []).map(item => ({
+        type: 'scenario-source',
+        path: item.path || null,
+        count: item.count ?? null,
+        scenarios: Array.isArray(item.scenarios) ? item.scenarios : [],
+      })),
+      ...e1Evidence.event_ids.map(eventId => ({ type: 'event', event_id: eventId })),
+    ],
+    caveats: [
+      ...CORE_METRIC_DEFINITIONS.e1.scheme_notes,
+      endpointElapsed == null
+        ? '端到端经过时间未采集。'
+        : `${endpointElapsed} ms 是从起点到终点的端到端经过时间，包含阶段间空隙，不能当作 E1 分子。`,
+    ],
+  }, expectedE1, expectedE1 != null);
+  if (hasDetailedStageDuration && metricValuesDiffer(stageDuration, detailedStageDuration)) {
+    e1 = markDetailInconsistent(
+      e1,
+      `计入公式的阶段明细合计为 ${detailedStageDuration} ms，但汇总字段为 ${stageDuration} ms`,
+    );
+  }
+  if (includedNodes.length > 0 && !hasDetailedStageDuration) {
+    e1 = markDetailProvisional(
+      e1,
+      `${invalidDetailedStageDurationCount} 条计入的阶段明细缺少耗时或耗时无效，不能独立复算 E1；当前结果仅按汇总字段核对。`,
+    );
+  }
+
+  const q3Total = quality.q3_total ?? null;
+  const q3Errors = quality.q3_errors ?? null;
+  const q3Value = quality.q3_spec_quality_score ?? null;
+  const q3OperandsValid = hasFiniteMetricNumber(q3Total)
+    && Number(q3Total) > 0
+    && hasFiniteMetricNumber(q3Errors)
+    && Number(q3Errors) >= 0
+    && Number(q3Errors) <= Number(q3Total);
+  const expectedQ3 = q3OperandsValid
+    ? roundMetric(((Number(q3Total) - Number(q3Errors)) / Number(q3Total)) * 100)
+    : null;
+  const q3Review = quality.q3_review || {};
+  const q3ReviewMode = q3Review.review_execution_mode || null;
+  const q3ReviewIndependence = q3Review.reviewer_independence
+    || quality.q3_reviewer_independence
+    || 'unknown';
+  const q3MetadataStatus = typeof resolveScoreStatus === 'function'
+    ? resolveScoreStatus(q3ReviewIndependence, q3Review)
+    : 'provisional';
+  const q3Verified = quality.q3_score_status === 'verified'
+    && q3MetadataStatus === 'verified';
+  const q3ReviewExplanation = q3Verified
+    ? `由独立子代理 ${q3Review.reviewer_agent_id} 完成复核，作者会话与评审会话不同。`
+    : (q3ReviewMode === 'subagent'
+      ? '本次由独立子代理执行检查，但作者身份、评审身份或会话差异证据不完整，尚不能确认独立性。'
+      : (q3ReviewMode === 'main-agent-fallback'
+      ? `由主代理自查，未经过独立复核。回退原因：${q3Review.fallback_reason || CHECK_FALLBACK_REASON_LABELS[q3Review.fallback_reason_code] || q3Review.fallback_reason_code || '未记录具体原因'}。`
+      : '旧事件没有记录是否使用独立子代理，不能确认独立复核。'));
+  const q3Evidence = evidenceFor(report, 'q3');
+  const q3Trust = q3Verified
+    ? trustFor(report, 'q3', 'verified', q3ReviewExplanation)
+    : {
+      status: 'provisional',
+      explanation: q3ReviewExplanation,
+      detail_downgrade: true,
+    };
+  let q3 = applyConsistencyCheck({
+    ...CORE_METRIC_DEFINITIONS.q3,
+    raw_values: {
+      total: q3Total,
+      errors: q3Errors,
+      warnings: quality.q3_warnings ?? null,
+      suggestions: quality.q3_suggestions ?? null,
+      category_scores: quality.q3_category_scores || {},
+      expected_result: expectedQ3,
+      review: {
+        executor: q3ReviewMode === 'subagent'
+          ? '独立子代理'
+          : (q3ReviewMode === 'main-agent-fallback' ? '主代理' : '无法确认'),
+        independently_verified: q3Verified,
+        review_execution_mode: q3ReviewMode,
+        reviewer_agent_id: q3Review.reviewer_agent_id || null,
+        author_session_id: q3Review.author_session_id || null,
+        reviewer_session_id: q3Review.review_session_id || q3Review.reviewer_session_id || null,
+        fallback_reason_code: q3Review.fallback_reason_code || null,
+        fallback_reason: q3Review.fallback_reason || null,
+      },
+    },
+    raw_inputs: [
+      { label: '检查项总数', value: q3Total, source: '最新 check_result.check_results.total', included: true },
+      { label: '错误数', value: q3Errors, source: '最新 check_result.check_results.errors', included: true },
+      { label: '警告数', value: quality.q3_warnings ?? null, source: '最新 Check 结果', included: false, exclusion_reason: '警告不进入当前扣分公式' },
+      { label: '建议数', value: quality.q3_suggestions ?? null, source: '最新 Check 结果', included: false, exclusion_reason: '建议不进入当前扣分公式' },
+    ],
+    calculation_steps: [
+      q3OperandsValid
+        ? `代入公式：(${q3Total} - ${q3Errors}) ÷ ${q3Total} × 100 = ${expectedQ3}；再与报告结果 ${q3Value} 对照。`
+        : '旧事件没有保留检查项总数或错误数，分数可读，但当前报告无法完整复算。',
+      `复核可信度：${q3ReviewExplanation}`,
+    ],
+    result: { value: q3Value, display_value: q3Value == null ? '暂无数据' : `${q3Value}/100`, unit: '分' },
+    trust: q3Trust,
+    evidence: q3Evidence.event_ids.map(eventId => ({ type: 'event', event_id: eventId })),
+    caveats: CORE_METRIC_DEFINITIONS.q3.scheme_notes,
+  }, expectedQ3, expectedQ3 != null);
+  if (!q3OperandsValid) {
+    q3 = markDetailProvisional(
+      q3,
+      '检查项总数或错误数缺失、超出合理范围，不能独立复算 Q3；当前分数仅作参考。',
+    );
+  }
+
+  const firstApply = nodes.find(node => (node.stage || node.command) === 'apply') || null;
+  const p4Facts = process.p4_evidence || {};
+  const p4Value = process.p4_quality_gate_enforcement_rate ?? null;
+  const firstApplyStartedAt = p4Facts.first_apply_started_at || firstApply?.start_ts || null;
+  const firstApplyStartedMs = Date.parse(firstApplyStartedAt || '');
+  const hasQualifyingCheckDetails = Array.isArray(p4Facts.qualifying_checks);
+  const candidateChecks = hasQualifyingCheckDetails
+    ? p4Facts.qualifying_checks
+    : nodes.filter(node => (node.stage || node.command) === 'check');
+  const qualifyingChecks = candidateChecks.filter((check) => {
+    const startedAt = check.started_at || check.start_ts || null;
+    const endedAt = check.ended_at || check.end_ts || null;
+    const startedMs = Date.parse(startedAt || '');
+    const endedMs = Date.parse(endedAt || '');
+    const hasStartEvidence = Boolean(check.start_event_id || startedAt);
+    const hasEndEvidence = Boolean(check.end_event_id || endedAt);
+    return ['success', 'partial'].includes(check.result)
+      && Number.isFinite(firstApplyStartedMs)
+      && hasStartEvidence
+      && hasEndEvidence
+      && Number.isFinite(startedMs)
+      && Number.isFinite(endedMs)
+      && startedMs <= endedMs
+      && endedMs <= firstApplyStartedMs;
+  });
+  const derivedQualifyingCheckCount = qualifyingChecks.length;
+  const qualifyingCheckCount = p4Facts.qualifying_check_count ?? derivedQualifyingCheckCount;
+  const expectedP4 = Number.isFinite(firstApplyStartedMs)
+    ? (derivedQualifyingCheckCount > 0 ? 1 : 0)
+    : null;
+  const p4Evidence = evidenceFor(report, 'p4');
+  let p4 = applyConsistencyCheck({
+    ...CORE_METRIC_DEFINITIONS.p4,
+    raw_values: {
+      first_apply_started_at: firstApplyStartedAt,
+      first_apply_event_id: p4Facts.first_apply_event_id || firstApply?.start_event_id || null,
+      qualifying_check_count: qualifyingCheckCount,
+      derived_qualifying_check_count: derivedQualifyingCheckCount,
+      qualifying_checks: candidateChecks,
+      derived_qualifying_checks: qualifyingChecks,
+      expected_result: expectedP4,
+    },
+    raw_inputs: [
+      { label: '首次 Apply 开始时间', value: firstApplyStartedAt, source: p4Facts.first_apply_event_id || '阶段时间线', included: true },
+      { label: '首次 Apply 前按明细复算的有效 Check 数', value: derivedQualifyingCheckCount, source: '逐条核对 Check 结果、结束时间和首次 Apply 开始时间', included: true },
+      { label: '指标汇总字段中的有效 Check 数', value: qualifyingCheckCount, source: 'p4_evidence.qualifying_check_count', included: false, exclusion_reason: '只用于与明细复算结果对账' },
+    ],
+    calculation_steps: [
+      `找到首次 Apply：${firstApplyStartedAt || '暂无可定位记录'}。`,
+      `逐条筛选后，在首次 Apply 前找到 ${derivedQualifyingCheckCount} 次已配对且结果为成功或部分通过的 Check；汇总字段记录为 ${qualifyingCheckCount} 次。`,
+      `按明细复算 P4 = ${expectedP4 == null ? '暂无数据' : `${expectedP4}（${expectedP4 * 100}%）`}；报告结果为 ${p4Value ?? '暂无数据'}。`,
+    ],
+    result: { value: p4Value, display_value: p4Value == null ? '暂无数据' : `${p4Value * 100}%`, unit: '比例' },
+    trust: trustFor(report, 'p4', p4Evidence.status),
+    evidence: p4Evidence.event_ids.map(eventId => ({ type: 'event', event_id: eventId })),
+    caveats: CORE_METRIC_DEFINITIONS.p4.scheme_notes,
+  }, expectedP4, expectedP4 != null);
+  if (hasQualifyingCheckDetails
+      && metricValuesDiffer(qualifyingCheckCount, derivedQualifyingCheckCount)) {
+    p4 = markDetailInconsistent(
+      p4,
+      `Check 明细复算得到 ${derivedQualifyingCheckCount} 次有效检查，但汇总字段为 ${qualifyingCheckCount} 次`,
+    );
+  }
+
+  const rework = process.rework_summary || {};
+  const pRValue = rework.total_rework_attempts ?? null;
+  const hasReworkByStage = Array.isArray(rework.by_stage);
+  const reworkByStage = hasReworkByStage ? rework.by_stage : [];
+  const reworkStageDetails = reworkByStage.map((item) => {
+    const rawTotalAttempts = item.total_attempts;
+    const rawReworkAttempts = item.rework_attempts;
+    const totalAttemptsProvided = rawTotalAttempts !== null
+      && rawTotalAttempts !== undefined
+      && rawTotalAttempts !== '';
+    const reworkAttemptsProvided = rawReworkAttempts !== null
+      && rawReworkAttempts !== undefined
+      && rawReworkAttempts !== '';
+    const totalAttemptsValid = totalAttemptsProvided
+      && hasFiniteMetricNumber(rawTotalAttempts)
+      && Number.isInteger(Number(rawTotalAttempts))
+      && Number(rawTotalAttempts) >= 1;
+    const reworkAttemptsValid = reworkAttemptsProvided
+      && hasFiniteMetricNumber(rawReworkAttempts)
+      && Number.isInteger(Number(rawReworkAttempts))
+      && Number(rawReworkAttempts) >= 0;
+    const totalAttempts = totalAttemptsValid
+      ? Number(rawTotalAttempts)
+      : null;
+    const recordedReworkAttempts = reworkAttemptsValid
+      ? Number(rawReworkAttempts)
+      : null;
+    const derivedReworkAttempts = totalAttemptsProvided
+      ? (totalAttemptsValid ? totalAttempts - 1 : null)
+      : recordedReworkAttempts;
+    const invalidFields = [
+      ...(totalAttemptsProvided && !totalAttemptsValid
+        ? ['执行次数必须是大于等于 1 的整数']
+        : []),
+      ...(reworkAttemptsProvided && !reworkAttemptsValid
+        ? ['重复次数必须是大于等于 0 的整数']
+        : []),
+    ];
+    return {
+      ...item,
+      raw_total_attempts: rawTotalAttempts ?? null,
+      raw_rework_attempts: rawReworkAttempts ?? null,
+      total_attempts: totalAttempts,
+      rework_attempts: recordedReworkAttempts,
+      derived_rework_attempts: derivedReworkAttempts,
+      derivation_source: totalAttemptsValid
+        ? 'total_attempts'
+        : (!totalAttemptsProvided && reworkAttemptsValid ? 'rework_attempts' : 'unavailable'),
+      invalid_fields: invalidFields,
+    };
+  });
+  const hasObservedReworkEvidence = reworkByStage.length > 0
+    || rework.total_attempts == null
+    || (hasFiniteMetricNumber(rework.total_attempts) && Number(rework.total_attempts) > 0);
+  const canRecomputePR = hasReworkByStage
+    && hasObservedReworkEvidence
+    && reworkStageDetails.every(item => item.derived_rework_attempts != null);
+  const expectedPR = canRecomputePR
+    ? reworkStageDetails.reduce((sum, item) => sum + item.derived_rework_attempts, 0)
+    : null;
+  const conflictingReworkDetails = reworkStageDetails.filter(item => (
+    item.total_attempts != null
+    && item.rework_attempts != null
+    && metricValuesDiffer(item.derived_rework_attempts, item.rework_attempts)
+  ));
+  const invalidReworkDetails = reworkStageDetails
+    .filter(item => item.invalid_fields.length > 0);
+  const reasonCounts = rework.reasons?.by_category || {};
+  const reasonDetails = rework.reasons?.details || [];
+  const pREvidence = evidenceFor(report, 'p_r');
+  let pR = applyConsistencyCheck({
+    ...CORE_METRIC_DEFINITIONS.p_r,
+    raw_values: {
+      total_attempts: rework.total_attempts ?? null,
+      canonical_attempts: rework.canonical_attempts ?? null,
+      total_rework_attempts: pRValue,
+      by_stage: reworkStageDetails,
+      expected_result: expectedPR,
+      reasons: Object.fromEntries(Object.entries(reasonCounts).map(([key, value]) => [
+        key,
+        { count: value, label: REWORK_REASON_LABELS[key] || key },
+      ])),
+      reason_details: reasonDetails.map(item => ({
+        ...item,
+        reason_label: REWORK_REASON_LABELS[item.reason] || item.reason,
+      })),
+    },
+    raw_inputs: reworkStageDetails.flatMap(item => ([
+      {
+        label: `${localizeStageName(item.command)} · 执行次数`,
+        value: item.raw_total_attempts,
+        display_value: item.raw_total_attempts == null ? '暂无数据' : `${item.raw_total_attempts} 次`,
+        source: item.canonical_event_id || '阶段配对结果',
+        included: item.total_attempts != null,
+        exclusion_reason: item.invalid_fields.some(reason => reason.startsWith('执行次数'))
+          ? '执行次数格式无效'
+          : (item.total_attempts == null
+            ? '旧数据没有记录执行次数，改用已记录的重复次数'
+            : null),
+      },
+      {
+        label: `${localizeStageName(item.command)} · 用于计算的重复次数`,
+        value: item.derived_rework_attempts,
+        display_value: item.derived_rework_attempts == null
+          ? '暂无数据'
+          : `${item.derived_rework_attempts} 次`,
+        source: item.derivation_source === 'total_attempts'
+          ? '由执行次数按 max(执行次数 - 1, 0) 推导'
+          : (item.derivation_source === 'rework_attempts'
+            ? '旧数据中已记录的重复次数字段'
+            : '当前没有可用的次数数据'),
+        included: item.derived_rework_attempts != null,
+        exclusion_reason: item.derived_rework_attempts == null ? '没有可用的执行或重复次数' : null,
+      },
+      {
+        label: `${localizeStageName(item.command)} · 已记录的重复次数`,
+        value: item.raw_rework_attempts,
+        display_value: item.raw_rework_attempts == null ? '暂无数据' : `${item.raw_rework_attempts} 次`,
+        source: '旧数据中已记录的重复次数字段',
+        included: item.derivation_source === 'rework_attempts',
+        exclusion_reason: item.invalid_fields.some(reason => reason.startsWith('重复次数'))
+          ? '重复次数格式无效'
+          : (item.derivation_source === 'total_attempts'
+            ? '执行次数完整时，此字段只用于交叉核对'
+            : null),
+      },
+    ])),
+    calculation_steps: [
+      canRecomputePR
+        ? `逐阶段优先计算 max(执行次数 - 1, 0)；旧数据缺少执行次数时使用已记录的重复次数。按 ${reworkStageDetails.length} 条阶段明细合计 ${expectedPR} 次；报告结果为 ${pRValue ?? '暂无数据'} 次。`
+        : (hasReworkByStage
+          ? `逐阶段明细中仍有执行次数和重复次数均缺失的记录，无法独立复算；报告结果为 ${pRValue ?? '暂无数据'} 次。`
+          : `旧数据没有逐阶段明细，无法独立复算；报告结果为 ${pRValue ?? '暂无数据'} 次。`),
+      ...reworkStageDetails.map(item => (
+        item.invalid_fields.length > 0
+          ? `${localizeStageName(item.command)}：${item.invalid_fields.join('；')}。`
+          : item.total_attempts == null
+          ? `${localizeStageName(item.command)}：执行次数暂无数据，使用已记录的重复次数 ${item.rework_attempts ?? '暂无数据'} 次。`
+          : `${localizeStageName(item.command)}：执行次数 ${item.total_attempts} 次，按公式得到重复次数 ${item.derived_rework_attempts} 次；记录的重复次数为 ${item.rework_attempts ?? '暂无数据'} 次。`
+      )),
+      ...reasonDetails.map(item => `${localizeStageName(item.command)}：${REWORK_REASON_LABELS[item.reason] || item.reason}。`),
+    ],
+    result: { value: pRValue, display_value: pRValue == null ? '暂无数据' : `${pRValue} 次`, unit: '次' },
+    trust: trustFor(report, 'p_r', pREvidence.status),
+    evidence: pREvidence.event_ids.map(eventId => ({ type: 'event', event_id: eventId })),
+    caveats: CORE_METRIC_DEFINITIONS.p_r.scheme_notes,
+  }, expectedPR, expectedPR != null);
+  if (invalidReworkDetails.length > 0) {
+    const invalid = invalidReworkDetails[0];
+    pR = markDetailInconsistent(
+      pR,
+      `${localizeStageName(invalid.command)}的${invalid.invalid_fields.join('；')}`,
+    );
+  } else if (conflictingReworkDetails.length > 0) {
+    const conflict = conflictingReworkDetails[0];
+    pR = markDetailInconsistent(
+      pR,
+      `${localizeStageName(conflict.command)}的执行次数 ${conflict.total_attempts} 次按公式推导为重复次数 ${conflict.derived_rework_attempts} 次，但记录的重复次数为 ${conflict.rework_attempts} 次`,
+    );
+  } else if (hasReworkByStage && !canRecomputePR) {
+    pR = markDetailProvisional(
+      pR,
+      '逐阶段明细存在执行次数和重复次数均缺失的记录，不能独立复算 P-R；当前结果仅作参考。',
+    );
+  }
+
+  const healthInputs = [
+    ['未闭环阶段', telemetry.open_stages, 0.18],
+    ['孤儿事件', telemetry.orphan_events, 0.18],
+    ['未知命令', telemetry.unknown_command_events, 0.12],
+    ['无效阶段名', telemetry.invalid_stage_events, 0.12],
+    ['缺少耗时', telemetry.null_duration_stages, 0.08],
+    ['过期数据格式', telemetry.outdated_schema_events, 0.06],
+    ['缺少变更名', telemetry.missing_change_events, 0.04],
+    ['缺少能力域名', telemetry.missing_capability_events, 0.01],
+  ].map(([label, count, weight]) => {
+    const normalizedCount = hasFiniteMetricNumber(count)
+      && Number.isInteger(Number(count))
+      && Number(count) >= 0
+      ? Number(count)
+      : null;
+    return {
+      label,
+      count: normalizedCount,
+      weight,
+      weighted_value: normalizedCount == null ? null : normalizedCount * weight,
+    };
+  });
+  const invalidHealthInputs = healthInputs.filter(item => item.count == null);
+  const weightedIssueValue = invalidHealthInputs.length === 0
+    ? healthInputs.reduce((sum, item) => sum + item.weighted_value, 0)
+    : null;
+  const stageEvents = telemetry.stage_events ?? null;
+  const pHValue = telemetry.p_h_telemetry_health_score ?? null;
+  const canRecomputePH = hasFiniteMetricNumber(stageEvents)
+    && Number(stageEvents) > 0
+    && invalidHealthInputs.length === 0;
+  const healthCalculation = canRecomputePH && typeof computeTelemetryHealthScore === 'function'
+    ? computeTelemetryHealthScore({
+      weighted_issue_value: weightedIssueValue,
+      stage_event_count: stageEvents,
+    })
+    : (canRecomputePH
+      ? {
+        ratio: Math.max(0, roundMetric(1 - weightedIssueValue / Number(stageEvents), 2)),
+        score: Math.max(0, roundMetric(1 - weightedIssueValue / Number(stageEvents), 2)) * 100,
+      }
+      : { ratio: null, score: null });
+  const expectedPH = canRecomputePH ? healthCalculation.score : null;
+  const pHEvidence = evidenceFor(report, 'p_h');
+  let pH = applyConsistencyCheck({
+    ...CORE_METRIC_DEFINITIONS.p_h,
+    raw_values: {
+      stage_events: stageEvents,
+      weighted_issue_value: weightedIssueValue,
+      normalized_ratio: canRecomputePH ? healthCalculation.ratio : null,
+      deductions: healthInputs,
+      expected_result: expectedPH,
+    },
+    raw_inputs: healthInputs.map(item => ({
+      label: item.label,
+      value: item.count,
+      display_value: item.count == null ? '暂无数据' : `${item.count} 个 × ${item.weight}`,
+      source: 'skywalk-sdd 诊断结果',
+      included: true,
+      weight: item.weight,
+      weighted_value: item.weighted_value,
+    })),
+    calculation_steps: [
+      invalidHealthInputs.length === 0
+        ? `八类问题的加权问题值合计为 ${weightedIssueValue}。`
+        : `八类问题中有 ${invalidHealthInputs.length} 类缺少有效计数，当前不能得到加权问题值。`,
+      canRecomputePH
+        ? `按发布口径先计算并将比例保留两位：1 - ${weightedIssueValue} ÷ ${stageEvents} = ${healthCalculation.ratio}；再乘以 100 得 ${expectedPH} 分；报告结果为 ${pHValue} 分。`
+        : '标准阶段事件分母或八类问题计数缺失，当前无法完成归一化。',
+    ],
+    result: { value: pHValue, display_value: pHValue == null ? '暂无数据' : `${pHValue}/100`, unit: '分' },
+    trust: trustFor(report, 'p_h', pHEvidence.status),
+    evidence: pHEvidence.event_ids.map(eventId => ({ type: 'event', event_id: eventId })),
+    caveats: CORE_METRIC_DEFINITIONS.p_h.scheme_notes,
+  }, expectedPH, expectedPH != null);
+  if (!canRecomputePH) {
+    pH = markDetailProvisional(
+      pH,
+      '标准阶段事件总数或八类问题计数缺失、无效，不能独立复算 P-H；当前分数仅作参考。',
+    );
+  }
+
+  e1 = validateMetricDetailResult('e1', e1);
+  q3 = validateMetricDetailResult('q3', q3);
+  p4 = validateMetricDetailResult('p4', p4);
+  pR = validateMetricDetailResult('p_r', pR);
+  pH = validateMetricDetailResult('p_h', pH);
+
+  return { e1, q3, p4, p_r: pR, p_h: pH };
+}
+
 function resolveArtifact(projectRoot, artifactPath, options = {}) {
   if (!artifactPath) return { path: null, exists: false, size_bytes: null, size_display: null, sha256: null };
   const absolute = path.isAbsolute(artifactPath)
@@ -389,7 +1175,7 @@ function buildWarningDispositions(report) {
     ...(report.evidence_alerts?.resolved || []),
     ...(report.check_warning_dispositions || []),
   ];
-  const allowed = new Set(['fixed', 'accepted', 'waived', 'needs_input', 'open']);
+  const allowed = CANONICAL_ISSUE_DISPOSITIONS;
   const checkWarnings = new Set((report.check_warning_dispositions || []).map(item => item.warning));
   const byWarning = new Map();
   for (const alert of alerts) {
@@ -409,6 +1195,188 @@ function buildWarningDispositions(report) {
   return [...byWarning.values()];
 }
 
+function propagateMetricConsistency(report, metricDetails) {
+  const inconsistentMetrics = Object.entries(metricDetails || {})
+    .filter(([, detail]) => detail?.trust?.status === 'inconsistent')
+    .map(([key]) => key);
+  const detailDowngrades = Object.entries(metricDetails || {})
+    .filter(([, detail]) => ['missing', 'provisional'].includes(detail?.trust?.status))
+    .map(([key, detail]) => ({ key, status: detail.trust.status }));
+  const affectedMetrics = new Set([
+    ...inconsistentMetrics,
+    ...detailDowngrades.map(item => item.key),
+  ]);
+
+  const minimum = report.minimum_metric_set || {};
+  const minimumMetrics = Array.isArray(minimum.minimum_metrics)
+    ? minimum.minimum_metrics.slice()
+    : ['e1', 'q3', 'p4', 'p_r', 'p_h'];
+  const inconsistentSet = new Set(inconsistentMetrics);
+  const evidenceStatus = { ...(minimum.evidence_status || {}) };
+  const evidence = { ...(minimum.evidence || {}) };
+  for (const key of inconsistentMetrics) {
+    evidenceStatus[key] = 'inconsistent';
+    evidence[key] = {
+      ...(evidence[key] || {}),
+      status: 'inconsistent',
+      reason: 'metric-detail-calculation-mismatch',
+    };
+  }
+  for (const item of detailDowngrades) {
+    evidenceStatus[item.key] = item.status;
+    evidence[item.key] = {
+      ...(evidence[item.key] || {}),
+      status: item.status,
+      reason: item.status === 'missing'
+        ? 'metric-result-missing'
+        : 'metric-detail-evidence-incomplete',
+    };
+  }
+
+  const provisionalMetrics = (minimum.provisional_metrics || [])
+    .filter(key => !inconsistentSet.has(key)
+      && !detailDowngrades.some(item => item.key === key && item.status === 'missing'));
+  for (const item of detailDowngrades) {
+    if (item.status === 'provisional' && !provisionalMetrics.includes(item.key)) {
+      provisionalMetrics.push(item.key);
+    }
+  }
+  const numericTotal = hasFiniteMetricNumber(minimum.numeric_total)
+    && Number(minimum.numeric_total) > 0
+    ? Number(minimum.numeric_total)
+    : minimumMetrics.length;
+  const availableMetrics = minimumMetrics.filter(key => (
+    validateCoreMetricResult(key, metricDetails[key]?.result?.value).valid
+  ));
+  const declaredTrusted = Array.isArray(minimum.trusted_metrics)
+    ? minimum.trusted_metrics
+    : (Array.isArray(minimum.trusted) ? minimum.trusted : []);
+  const trustedMetrics = declaredTrusted.filter(key => (
+    availableMetrics.includes(key)
+    && !affectedMetrics.has(key)
+    && ['trusted', 'verified'].includes(metricDetails[key]?.trust?.status)
+  ));
+  const missingMetrics = minimumMetrics.filter(key => !availableMetrics.includes(key));
+  const minimumMetricSet = {
+    ...minimum,
+    minimum_metrics: minimumMetrics,
+    available: availableMetrics,
+    missing: missingMetrics,
+    coverage_rate: numericTotal > 0
+      ? roundMetric(availableMetrics.length / numericTotal)
+      : 0,
+    numeric_available: availableMetrics.length,
+    numeric_total: numericTotal,
+    numeric_coverage_rate: numericTotal > 0
+      ? roundMetric(availableMetrics.length / numericTotal)
+      : 0,
+    trusted_available: trustedMetrics.length,
+    trusted_metrics: trustedMetrics,
+    provisional: provisionalMetrics.length,
+    provisional_metrics: provisionalMetrics,
+    missing_count: missingMetrics.length,
+    inconsistent: inconsistentMetrics.length,
+    inconsistent_metrics: inconsistentMetrics,
+    trusted_coverage_rate: numericTotal > 0
+      ? roundMetric(trustedMetrics.length / numericTotal)
+      : 0,
+    evidence_status: evidenceStatus,
+    evidence,
+  };
+  if (Object.hasOwn(minimum, 'trusted')) {
+    minimumMetricSet.trusted = trustedMetrics;
+  }
+
+  if (affectedMetrics.size === 0) {
+    return {
+      minimumMetricSet,
+      conclusion: report.conclusion || null,
+    };
+  }
+
+  const inconsistentCodes = inconsistentMetrics.map(key => (
+    metricDetails[key]?.code || key.toUpperCase()
+  ));
+  const missingCodes = detailDowngrades
+    .filter(item => item.status === 'missing')
+    .map(item => metricDetails[item.key]?.code || item.key.toUpperCase());
+  const provisionalCodes = detailDowngrades
+    .filter(item => item.status === 'provisional')
+    .map(item => metricDetails[item.key]?.code || item.key.toUpperCase());
+  const trustStatements = [];
+  if (inconsistentCodes.length > 0) {
+    trustStatements.push(`核心指标 ${inconsistentCodes.join('、')} 的计算明细与结果不一致，已从可信范围移除`);
+  }
+  if (missingCodes.length > 0) {
+    trustStatements.push(`核心指标 ${missingCodes.join('、')} 的报告结果缺失，已从可信范围移除`);
+  }
+  if (provisionalCodes.length > 0) {
+    trustStatements.push(`核心指标 ${provisionalCodes.join('、')} 的计算明细不完整，已降为临时结果`);
+  }
+  const trustStatement = trustStatements.join('；');
+  const existingConclusion = report.conclusion || {};
+  const conclusionParts = [
+    existingConclusion.task_statement,
+    trustStatement,
+    existingConclusion.alert_statement,
+  ].filter(Boolean);
+  const conclusion = {
+    ...existingConclusion,
+    status: 'attention',
+    text: `${conclusionParts.join('；')}。`,
+    trust_statement: trustStatement,
+    inconsistent_metrics: inconsistentMetrics,
+    detail_downgraded_metrics: detailDowngrades.map(item => item.key),
+  };
+
+  return { minimumMetricSet, conclusion };
+}
+
+function reconcileSchemeCompliance(schemeCompliance, minimumMetricSet, metricDetails) {
+  if (!schemeCompliance
+      || typeof schemeCompliance !== 'object'
+      || !Array.isArray(schemeCompliance.items)) {
+    return schemeCompliance || null;
+  }
+  const total = hasFiniteMetricNumber(minimumMetricSet?.numeric_total)
+    && Number(minimumMetricSet.numeric_total) > 0
+    ? Number(minimumMetricSet.numeric_total)
+    : (minimumMetricSet?.minimum_metrics?.length || 5);
+  const numericAvailable = Number(minimumMetricSet?.numeric_available) || 0;
+  const trustedAvailable = Number(minimumMetricSet?.trusted_available) || 0;
+  const minimumImplemented = numericAvailable === total
+    && trustedAvailable === total
+    && Number(minimumMetricSet?.inconsistent || 0) === 0;
+  const q3TrustStatus = metricDetails?.q3?.trust?.status || null;
+  const independentReviewImplemented = ['trusted', 'verified'].includes(q3TrustStatus);
+  const items = schemeCompliance.items.map((item) => {
+    if (item.requirement === 'minimum-verifiable-metrics') {
+      return {
+        ...item,
+        status: minimumImplemented ? 'implemented' : 'provisional',
+        evidence: `数值覆盖 ${numericAvailable}/${total}；可信覆盖 ${trustedAvailable}/${total}`,
+      };
+    }
+    if (item.requirement === 'independent-reviewer') {
+      return {
+        ...item,
+        status: independentReviewImplemented ? 'implemented' : 'provisional',
+        evidence: independentReviewImplemented
+          ? 'Q3 已有完整的独立子代理身份与会话证据'
+          : 'Q3 尚未形成完整的独立子代理身份与会话证据',
+      };
+    }
+    return item;
+  });
+  const counts = {};
+  for (const item of items) counts[item.status] = (counts[item.status] || 0) + 1;
+  return {
+    ...schemeCompliance,
+    items,
+    counts,
+  };
+}
+
 function buildChangeReportModel(report, events = []) {
   if (!report || report.level !== 'change' || !report.change) return report;
   const scopedEvents = scopedEventsForChange(events, report.change);
@@ -422,6 +1390,13 @@ function buildChangeReportModel(report, events = []) {
     tasks: existingSummary.tasks || normalizeTaskSummary(report),
     evidence: existingSummary.evidence || normalizeEvidenceSummary(report),
   };
+  const metricDetails = report.metric_details || buildMetricDetails(report);
+  const consistency = propagateMetricConsistency(report, metricDetails);
+  const schemeCompliance = reconcileSchemeCompliance(
+    report.scheme_compliance,
+    consistency.minimumMetricSet,
+    metricDetails,
+  );
   return {
     ...report,
     report_scope: {
@@ -435,6 +1410,10 @@ function buildChangeReportModel(report, events = []) {
       cross_change_data_included: false,
     },
     metric_provenance: report.metric_provenance || report.metric_evidence || null,
+    metric_details: metricDetails,
+    minimum_metric_set: consistency.minimumMetricSet,
+    scheme_compliance: schemeCompliance,
+    conclusion: consistency.conclusion,
     change_summary: changeSummary,
     changed_files: changedFiles,
     warning_dispositions: buildWarningDispositions(report),