kld-sdd 2.6.13 → 2.6.15

package/skywalk-sdd/index.cjs

@@ -2622,8 +2622,14 @@ function computeConformanceMetrics(events) {
 }
 
 function getAiAdoptionReview(event) {
-  // Q4: 兼容三 key（ai_adoption / ai_code_adoption / ai_adoption_review）
-  const review = event?.details?.ai_adoption || event?.details?.ai_code_adoption || event?.details?.ai_adoption_review;
+  // Q4: 兼容四 key + 历史顶层 details.ai_diff（无嵌套 review 外壳）
+  const nested = event?.details?.ai_adoption
+    || event?.details?.ai_code_adoption
+    || event?.details?.ai_adoption_review;
+  const topLevelAiDiff = event?.details?.ai_diff && typeof event.details.ai_diff === 'object'
+    ? event.details.ai_diff
+    : null;
+  const review = nested || (topLevelAiDiff ? { ai_diff: topLevelAiDiff } : null);
   if (!review) return null;
 
   const retainedLines = Number.isFinite(review.retained_lines) ? review.retained_lines : null;
@@ -2645,6 +2651,11 @@ function getAiAdoptionReview(event) {
     else adoptionLevel = 'rewritten';
   }
 
+  const aiDiff = review.ai_diff && typeof review.ai_diff === 'object'
+    ? review.ai_diff
+    : (topLevelAiDiff || {});
+  const legacyTopLevelShape = Boolean(topLevelAiDiff) && !nested;
+
   return {
     base_git_sha: review.base_git_sha || null,
     ai_git_sha: review.ai_git_sha || null,
@@ -2655,9 +2666,10 @@ function getAiAdoptionReview(event) {
     retained_lines: retainedLines,
     rewritten_lines: rewrittenLines,
     deleted_lines: deletedLines,
-    ai_diff: review.ai_diff || {},
+    ai_diff: aiDiff,
     final_diff: review.final_diff || {},
     notes: review.notes || '',
+    legacy_shape: legacyTopLevelShape || undefined,
   };
 }
 
@@ -2666,7 +2678,8 @@ function getAiAdoptionEvents(events) {
     return e.type === 'ai_adoption_review'
       || Boolean(e.details?.ai_adoption)
       || Boolean(e.details?.ai_code_adoption)
-      || Boolean(e.details?.ai_adoption_review);
+      || Boolean(e.details?.ai_adoption_review)
+      || Boolean(e.details?.ai_diff);
   });
 }
 
@@ -3218,16 +3231,6 @@ function computeSinglePdfMvpMetrics(events, options = {}) {
     change_type: changeType,
     change_name: options.change || null,
     v3,
-    legacy_metrics: {
-      e1_lead_time_ms: leadTime,
-      e4_ai_code_first_pass_rate: aiFirstPassMetrics.e4_ai_code_first_pass_rate,
-      p1_spec_iteration_count: specIterationCount,
-      p2_ai_code_adoption_rate: aiAdoptionMetrics.p2_ai_code_adoption_rate,
-      q3_build_first_pass_rate: firstBuildSuccess == null ? null : (firstBuildSuccess ? 1 : 0),
-      q5_cross_doc_consistency_score: consistencyScore,
-      deprecated: true,
-      notes: '旧版指标，保留用于兼容。新版主指标见 v3 字段（E1=场景交付效率 ms/场景，Q3=规约质量评分 0-100）。',
-    },
   };
 }
 
@@ -3499,7 +3502,13 @@ function reportStatusLabel(status) {
 
 function renderExecutiveReportMarkdown(report) {
   if (report?.level === 'change' && report.change) {
-    report = require('./reporting/change-report-model.cjs').buildChangeReportModel(report);
+    if (!report.change_summary || !report.artifacts?.files) {
+      report = require('./reporting/change-report-model.cjs').buildChangeReportModel(report);
+    }
+    const changeMarkdown = require('./reporting/change-report-markdown.cjs');
+    if (typeof changeMarkdown.renderChangeReportMarkdown === 'function') {
+      return changeMarkdown.renderChangeReportMarkdown(report);
+    }
   }
   const metrics = report.metrics;
   const health = report.doctor || {};
@@ -3672,9 +3681,12 @@ function renderExecutiveReportMarkdown(report) {
     `- 归档目录：${archive?.archive_path || 'null'}`,
     `- 归档清单：${archive?.manifest_path || 'null'}`,
     `- 最终报告：${archive?.report_path || 'null'}`,
-    `- 已完成任务项（含子项 checkbox）：${taskCompletion?.completed ?? 'null'}`,
-    `- 未勾选任务项（含子项 checkbox）：${taskCompletion?.incomplete ?? 'null'}`,
-    `- 任务项总数（含子项 checkbox）：${taskCompletion?.total ?? 'null'}`,
+    `- 主任务完成：${taskCompletion?.primary_tasks
+      ? `${taskCompletion.primary_tasks.completed}/${taskCompletion.primary_tasks.total}`
+      : 'null'}`,
+    `- 全部 checkbox 完成：${taskCompletion?.completed ?? 'null'}/${taskCompletion?.total ?? 'null'}（含验收子项；分母≠主任务数）`,
+    `- 未勾选 checkbox：${taskCompletion?.incomplete ?? 'null'}`,
+    `- 验收证据待确认：${taskCompletion?.acceptance_evidence?.unconfirmed ?? 'null'}/${taskCompletion?.acceptance_evidence?.total ?? 'null'}`,
     '',
     '## 说明',
     '- `null` 表示当前还没有采集到对应事件或该指标暂不适用。',
@@ -4219,10 +4231,32 @@ tr:last-child td,tr:last-child th{border-bottom:none}
 </body></html>`;
 }
 
+function sortedUniqueFileList(files) {
+  return [...new Set((files || []).filter(file => typeof file === 'string' && file.trim()).map(file => file.trim()))]
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function fileListSymmetricDiff(left, right) {
+  const leftSet = new Set(left || []);
+  const rightSet = new Set(right || []);
+  return {
+    only_in_task_events: [...leftSet].filter(file => !rightSet.has(file)).sort((a, b) => a.localeCompare(b)),
+    only_in_final_output: [...rightSet].filter(file => !leftSet.has(file)).sort((a, b) => a.localeCompare(b)),
+  };
+}
+
 // ── U1 报告维度提取辅助：从 events/metrics/doctor/archive 提炼 5 维度，数据缺失诚实标注 _available: false ──
 function extractChangedFiles(events, projectRoot) {
-  const adoptionEvents = events.filter(e => e.type === 'ai_adoption_review' || Boolean(e.details?.ai_adoption) || Boolean(e.details?.ai_code_adoption));
-  const latest = latestByTimestamp(adoptionEvents);
+  const adoptionEvents = getAiAdoptionEvents(events);
+  const finalAdoptionEvents = adoptionEvents.filter((event) => {
+    const review = getAiAdoptionReview(event);
+    return review?.review_status === 'final'
+      || event.status === 'final'
+      || review?.ai_diff?.snapshot_kind === 'final';
+  });
+  const latest = latestByTimestamp(
+    finalAdoptionEvents.length > 0 ? finalAdoptionEvents : adoptionEvents,
+  );
   const review = latest ? getAiAdoptionReview(latest) : null;
   const aiDiff = review?.ai_diff || null;
   const taskUpdateFiles = new Set();
@@ -4243,7 +4277,10 @@ function extractChangedFiles(events, projectRoot) {
       : [],
   );
   if (finalOutputFiles.size === 0 && latest?.details) {
-    const rawReview = latest.details.ai_adoption || latest.details.ai_adoption_review || latest.details.ai_code_adoption || {};
+    const rawReview = latest.details.ai_adoption
+      || latest.details.ai_adoption_review
+      || latest.details.ai_code_adoption
+      || {};
     for (const assertion of rawReview.assertions || []) {
       for (const file of assertion.files || []) {
         if (typeof file === 'string' && file.trim()) finalOutputFiles.add(file.trim());
@@ -4251,12 +4288,17 @@ function extractChangedFiles(events, projectRoot) {
     }
   }
 
-  const taskUpdateFileCount = taskUpdateFiles.size;
+  const taskEventFileList = sortedUniqueFileList([...taskUpdateFiles]);
+  const finalOutputFileList = sortedUniqueFileList([...finalOutputFiles]);
+  const taskUpdateFileCount = taskEventFileList.length;
   const finalOutputFileCount = Number.isFinite(aiDiff?.files_changed)
     ? aiDiff.files_changed
-    : (finalOutputFiles.size > 0 ? finalOutputFiles.size : null);
-  const snapshotKind = aiDiff?.snapshot_kind || null;
-  const finalOutputStatus = snapshotKind === 'final' ? 'final' : (finalOutputFileCount == null ? 'unavailable' : 'provisional');
+    : (finalOutputFileList.length > 0 ? finalOutputFileList.length : null);
+  const snapshotKind = aiDiff?.snapshot_kind
+    || ((review?.review_status === 'final' || latest?.status === 'final') ? 'final' : null);
+  const finalOutputStatus = snapshotKind === 'final'
+    ? 'final'
+    : (finalOutputFileCount == null ? 'unavailable' : 'provisional');
   const addedLines = Number.isFinite(aiDiff?.added_lines)
     ? aiDiff.added_lines
     : (Number.isFinite(review?.final_diff?.added_lines) ? review.final_diff.added_lines : null);
@@ -4264,11 +4306,11 @@ function extractChangedFiles(events, projectRoot) {
     ? aiDiff.deleted_lines
     : (Number.isFinite(review?.final_diff?.deleted_lines) ? review.final_diff.deleted_lines : null);
   let lineCountEstimate = null;
-  if (addedLines == null && review?.ai_git_sha == null && finalOutputFiles.size > 0 && projectRoot) {
+  if (addedLines == null && review?.ai_git_sha == null && finalOutputFileList.length > 0 && projectRoot) {
     let lines = 0;
     let countedFiles = 0;
     const root = path.resolve(projectRoot);
-    for (const relativePath of finalOutputFiles) {
+    for (const relativePath of finalOutputFileList) {
       try {
         const absolutePath = path.isAbsolute(relativePath)
           ? path.resolve(relativePath)
@@ -4289,29 +4331,56 @@ function extractChangedFiles(events, projectRoot) {
       };
     }
   }
-  const filesChanged = taskUpdateFileCount > 0 ? taskUpdateFileCount : finalOutputFileCount;
+  // Prefer final AI snapshot for public files_changed when available.
+  const filesChanged = finalOutputStatus === 'final' && finalOutputFileCount != null
+    ? finalOutputFileCount
+    : (taskUpdateFileCount > 0 ? taskUpdateFileCount : finalOutputFileCount);
   const countsDiffer = taskUpdateFileCount > 0
     && finalOutputFileCount != null
     && taskUpdateFileCount !== finalOutputFileCount;
-  const reconciliationNote = countsDiffer
-    ? `任务事件累计涉及 ${taskUpdateFileCount} 个文件；最终输出快照包含 ${finalOutputFileCount} 个文件。两者用途不同，不应合并为一个口径。`
-    : (filesChanged == null ? '没有可用的文件变更证据。' : '任务事件与最终输出文件口径一致。');
+  const listDiff = fileListSymmetricDiff(taskEventFileList, finalOutputFileList);
+  const listsDiffer = taskUpdateFileCount > 0
+    && finalOutputFileList.length > 0
+    && (listDiff.only_in_task_events.length > 0 || listDiff.only_in_final_output.length > 0);
+  let reconciliationStatus = 'unavailable';
+  let reconciliationNote = '没有可用的文件变更证据。';
+  if (taskUpdateFileCount === 0 && finalOutputFileCount == null) {
+    reconciliationStatus = 'unavailable';
+    reconciliationNote = '没有可用的文件变更证据。';
+  } else if (taskUpdateFileCount === 0 || finalOutputFileCount == null) {
+    reconciliationStatus = 'unavailable';
+    reconciliationNote = finalOutputFileCount == null
+      ? '最终输出文件快照不可用，无法与任务事件对账。'
+      : '任务事件未记录文件清单；仅展示最终输出快照。';
+  } else if (countsDiffer) {
+    reconciliationStatus = 'count-mismatch';
+    reconciliationNote = `任务事件累计涉及 ${taskUpdateFileCount} 个文件；最终输出快照包含 ${finalOutputFileCount} 个文件。两者用途不同，不应合并为一个口径。`;
+  } else if (listsDiffer) {
+    reconciliationStatus = 'list-mismatch';
+    reconciliationNote = `文件数量均为 ${taskUpdateFileCount}，但清单不一致（任务独有 ${listDiff.only_in_task_events.length}，最终独有 ${listDiff.only_in_final_output.length}）。`;
+  } else {
+    reconciliationStatus = 'consistent';
+    reconciliationNote = '任务事件与最终输出文件口径一致。';
+  }
   return {
     _available: filesChanged != null,
     files_changed: filesChanged,
     added_lines: addedLines,
     deleted_lines: deletedLines,
-    files: finalOutputFiles.size > 0 ? [...finalOutputFiles] : null,
-    task_event_files: taskUpdateFileCount > 0 ? [...taskUpdateFiles] : null,
+    files: finalOutputFileList.length > 0 ? finalOutputFileList : null,
+    task_event_files: taskUpdateFileCount > 0 ? taskEventFileList : null,
     task_event_files_changed: taskUpdateFileCount > 0 ? taskUpdateFileCount : null,
-    final_output_files: finalOutputFiles.size > 0 ? [...finalOutputFiles] : null,
+    final_output_files: finalOutputFileList.length > 0 ? finalOutputFileList : null,
     final_output_files_changed: finalOutputFileCount,
     final_output_status: finalOutputStatus,
     diff_source: snapshotKind === 'final' ? 'ai-diff-final' : (aiDiff ? 'ai-diff-provisional' : 'task-events'),
     line_count_estimate: lineCountEstimate,
+    reconciliation_status: reconciliationStatus,
     reconciliation_note: reconciliationNote,
-    ai_diff_files_changed: countsDiffer ? finalOutputFileCount : null,
-    files_diff_note: countsDiffer ? reconciliationNote : null,
+    only_in_task_events: listDiff.only_in_task_events,
+    only_in_final_output: listDiff.only_in_final_output,
+    ai_diff_files_changed: (countsDiffer || listsDiffer) ? finalOutputFileCount : null,
+    files_diff_note: (countsDiffer || listsDiffer) ? reconciliationNote : null,
   };
 }
 
@@ -4564,9 +4633,101 @@ function validateMaturityEvidenceDetails(details) {
   };
 }
 
+function scopeEventsForChangeReport(events, change) {
+  const input = Array.isArray(events) ? events : [];
+  if (!change) {
+    return {
+      events: input,
+      audit: {
+        kind: 'project',
+        change: null,
+        input_event_count: input.length,
+        included_event_count: input.length,
+        excluded_event_count: 0,
+        cross_change_data_included: false,
+      },
+    };
+  }
+  const scoped = input
+    .filter((event) => (
+      event?.change === change
+      || event?.attribution?.target_change === change
+    ))
+    .map((event) => {
+      if (event?.change === change) return event;
+      return {
+        ...event,
+        change,
+        attribution: {
+          ...event.attribution,
+          source_change: event.attribution?.source_change || event.change || null,
+          target_change: change,
+        },
+      };
+    });
+  return {
+    events: scoped,
+    audit: {
+      kind: 'single-change',
+      change,
+      input_event_count: input.length,
+      included_event_count: scoped.length,
+      excluded_event_count: input.length - scoped.length,
+      cross_change_data_included: false,
+    },
+  };
+}
+
+function tddPairFinding(pair) {
+  const definitions = {
+    'red-did-not-fail': {
+      code: 'TDD_PAIR_RED_DID_NOT_FAIL',
+      expected: 'RED 测试必须以非零退出码失败，并至少包含 1 个失败用例。',
+      actual: '已记录 RED 事件，但测试没有形成有效失败。',
+      root_cause: 'RED 事件的 valid_red、exit_code 或 failed 计数不满足失败测试约束。',
+      impact: '该 TDD 对不能证明实现前测试曾有效拦截缺失行为。',
+      remediation: '修正 RED 用例并重新记录失败结果，再执行对应 GREEN 或回归测试。',
+    },
+    'red-missing': {
+      code: 'TDD_PAIR_RED_MISSING',
+      expected: '每个 TDD 对都应先存在可定位的有效 RED 事件。',
+      actual: '未找到该 TDD 对对应的 RED 事件。',
+      root_cause: '任务与事件中没有可关联到该 pair 的 RED 证据。',
+      impact: '无法证明测试先于实现并曾经失败。',
+      remediation: '补充并记录该 pair 的 RED 失败测试；不能事后伪造历史证据。',
+    },
+    'green-missing': {
+      code: 'TDD_PAIR_GREEN_MISSING',
+      expected: '有效 RED 之后应存在覆盖对应任务的 GREEN 或回归成功事件。',
+      actual: '存在有效 RED，但没有找到其后的成功 GREEN/回归事件。',
+      root_cause: '后续成功测试缺失、时间顺序错误，或未覆盖对应 GREEN 任务。',
+      impact: '无法证明该 TDD 对已经由失败转为通过。',
+      remediation: '执行对应 GREEN/回归测试并记录覆盖任务与成功结果。',
+    },
+  };
+  const detail = definitions[pair.status] || {
+    code: 'TDD_PAIR_UNCLASSIFIED',
+    expected: 'TDD 对应具备可判定的 RED→GREEN 证据。',
+    actual: `该 TDD 对状态为 ${pair.status || 'unclassified'}。`,
+    root_cause: '现有任务或测试事件不足以完成配对。',
+    impact: '该 TDD 对的完整性不可判定。',
+    remediation: '补充 pair、任务和测试事件之间的明确关联。',
+  };
+  return {
+    ...detail,
+    severity: 'warning',
+    verdict: pair.status,
+    pair_id: pair.pair_id,
+    task_id: pair.red_task_id || pair.green_task_id || null,
+    message: `${pair.pair_id}：${detail.actual}`,
+  };
+}
+
 function buildReport(projectRoot, events, options = {}) {
+  const scopedReport = scopeEventsForChangeReport(events, options.change);
+  events = scopedReport.events;
   const archiveEvent = latestByTimestamp(events.filter(e => {
-    return e.command === 'archive' && e.type === 'stage_end' && !e.orphan;
+    return e.command === 'archive' && e.type === 'stage_end';
   }));
   const gitCommitTimeline = resolveGitCommitTimeline(
     events,
@@ -4618,18 +4779,46 @@ function buildReport(projectRoot, events, options = {}) {
     });
   } catch { maturity = null; }
 
-  const archiveTaskCompletion = archiveEvent?.details?.archive_result?.task_completion || null;
+  const archiveTaskCompletion = options.taskModel
+    || archiveEvent?.details?.archive_result?.task_completion
+    || null;
   const applyEvidenceAudit = options.change && archiveTaskCompletion
     ? buildApplyEvidenceAudit(options.change, archiveTaskCompletion, events, { mode: 'report-only' })
     : null;
+  const taskEvidenceAudit = options.change && archiveTaskCompletion
+    ? buildTaskEvidenceAudit(options.change, archiveTaskCompletion, events, { mode: 'report-only' })
+    : null;
+  const tddPairAudit = options.change && archiveTaskCompletion
+    ? buildTddPairAudit(options.change, archiveTaskCompletion, events, { mode: 'report-only' })
+    : null;
+  if (applyEvidenceAudit && tddPairAudit) {
+    applyEvidenceAudit.tdd = {
+      required: tddPairAudit.required,
+      red_green_complete: tddPairAudit.complete,
+    };
+  }
   const baseEvidenceAlerts = metricsV3.buildEvidenceAlerts(events);
-  const auditAlerts = (applyEvidenceAudit?.findings || []).map((finding) => ({
-    key: `${finding.code}:${finding.task_id || options.change || 'change'}`,
+  const evidenceFindings = [
+    ...(applyEvidenceAudit?.findings || []),
+    ...((tddPairAudit?.pairs || [])
+      .filter((pair) => pair.status !== 'complete')
+      .map(tddPairFinding)),
+  ];
+  const auditAlerts = evidenceFindings.map((finding) => ({
+    key: `${finding.code}:${finding.pair_id || finding.task_id || options.change || 'change'}`,
     category: 'evidence',
     warning: finding.code,
-    subject: finding.task_id || options.change || null,
+    subject: finding.pair_id || finding.task_id || options.change || null,
+    task_id: finding.task_id || null,
+    pair_id: finding.pair_id || null,
     message: finding.message,
     severity: finding.severity || 'warning',
+    verdict: finding.verdict || 'evidence-gap',
+    expected: finding.expected || null,
+    actual: finding.actual || finding.message || null,
+    root_cause: finding.root_cause || null,
+    impact: finding.impact || null,
+    remediation: finding.remediation || null,
     status: 'open',
     occurrences: 1,
     opened_by_event_id: null,
@@ -4738,6 +4927,7 @@ function buildReport(projectRoot, events, options = {}) {
       active_links: [],
       unassigned_candidate_event_ids: [],
     },
+    report_scope: scopedReport.audit,
     conclusion: {
       status: evidenceAlerts.open.length > 0 || trustRate < 1 || primaryTasks?.has_incomplete ? 'attention' : 'trusted',
       text: `${taskStatement}；${trustStatement}；${alertStatement}。`,
@@ -4746,9 +4936,9 @@ function buildReport(projectRoot, events, options = {}) {
       alert_statement: alertStatement,
     },
     metrics,
-    legacy_metrics: metrics.legacy_metrics || null,
     doctor,
-    archive_result: archiveEvent?.details?.archive_result || null,
+    archive_result: archiveEvent?.details?.archive_result
+      || (options.taskModel ? { task_completion: options.taskModel } : null),
     changed_files: extractChangedFiles(events, projectRoot),
     timeline: extractTimeline(events),
     stage_timeline: extractStageTimeline(events),
@@ -4765,12 +4955,115 @@ function buildReport(projectRoot, events, options = {}) {
     evidence_alerts: evidenceAlerts,
     check_warning_dispositions: checkWarningDispositions,
     apply_evidence_audit: applyEvidenceAudit,
+    task_evidence_audit: taskEvidenceAudit,
+    tdd_pair_audit: tddPairAudit,
     scheme_compliance: schemeCompliance,
     maturity,
   };
   return require('./reporting/change-report-model.cjs').buildChangeReportModel(baseReport, events);
 }
 
+function reportArtifactPaths(projectRoot, archiveResult = {}, explicitPaths = []) {
+  const declared = [
+    archiveResult.report_path,
+    archiveResult.report_html_path,
+    archiveResult.report_json_path,
+    ...explicitPaths,
+  ].filter(Boolean).map((filePath) => (
+    path.isAbsolute(filePath) ? filePath : path.resolve(projectRoot, filePath)
+  ));
+  return [...new Set(declared)].filter((filePath) => ['.md', '.html', '.json'].includes(
+    path.extname(filePath).toLowerCase(),
+  ));
+}
+
+function renderReportArtifact(report, filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  if (extension === '.json') return JSON.stringify(report, null, 2);
+  if (extension === '.html') return renderExecutiveReportHtml(report);
+  return renderExecutiveReportMarkdown(report);
+}
+
+function artifactSizeVector(projectRoot, report) {
+  const required = [
+    'markdown_report',
+    'html_report',
+    'json_report',
+    'execution_log',
+    'manifest',
+    'archive_zip',
+  ];
+  const embedded = {};
+  const actual = {};
+  for (const name of required) {
+    const artifact = report.artifacts?.files?.[name];
+    if (!artifact?.path) {
+      throw new Error(`E_ARTIFACT_INVENTORY_INCOMPLETE: ${name} 缺少最终路径`);
+    }
+    const absolutePath = path.isAbsolute(artifact.path)
+      ? artifact.path
+      : path.resolve(projectRoot, artifact.path);
+    if (!fs.existsSync(absolutePath) || !fs.statSync(absolutePath).isFile()) {
+      throw new Error(`E_ARTIFACT_INVENTORY_INCOMPLETE: ${name} 未落盘 (${artifact.path})`);
+    }
+    embedded[name] = artifact.size_bytes;
+    actual[name] = fs.statSync(absolutePath).size;
+  }
+  return { embedded, actual };
+}
+
+function sameArtifactSizeVector(left, right) {
+  return Object.keys(left).every(name => left[name] === right[name]);
+}
+
+function finalizeArtifactInventory(options = {}) {
+  const projectRoot = options.projectRoot;
+  const change = options.change;
+  const archiveResult = options.archiveResult || {};
+  const dataDir = options.dataDir || getDataDir(projectRoot);
+  const paths = reportArtifactPaths(projectRoot, archiveResult, options.reportPaths || []);
+  if (paths.length !== 3) {
+    throw new Error(`E_ARTIFACT_INVENTORY_INCOMPLETE: 需要 md/html/json 三份报告，实际 ${paths.length} 份`);
+  }
+  const archiveDirAbs = path.isAbsolute(archiveResult.archive_path)
+    ? archiveResult.archive_path
+    : path.resolve(projectRoot, archiveResult.archive_path);
+  let previousActual = null;
+  for (let round = 1; round <= 5; round += 1) {
+    const report = buildReport(projectRoot, readEvents(dataDir, change), {
+      level: options.level || 'change',
+      change,
+      capability: options.capability,
+      formats: ['md', 'html', 'json'],
+    });
+    for (const filePath of paths) {
+      atomicWriteText(filePath, `${renderReportArtifact(report, filePath)}\n`);
+    }
+    ensureArchiveManifest(projectRoot, change, archiveDirAbs, {
+      reason: archiveResult.reason || '',
+      method: archiveResult.method || 'skywalk-full-spec-archive',
+      archivePath: archiveDirAbs,
+      archivedAt: archiveResult.created_at || archiveResult.archived_at,
+      copiedSpecs: archiveResult.copied_specs,
+      finalizeAfterReports: true,
+      runIdentity: options.runIdentity,
+    });
+    const vector = artifactSizeVector(projectRoot, report);
+    const embeddedMatchesDisk = sameArtifactSizeVector(vector.embedded, vector.actual);
+    const actualMatchesPrevious = previousActual
+      && sameArtifactSizeVector(previousActual, vector.actual);
+    if (embeddedMatchesDisk && actualMatchesPrevious) {
+      return {
+        stable: true,
+        rounds: round,
+        sizes: vector.actual,
+      };
+    }
+    previousActual = vector.actual;
+  }
+  throw new Error('E_ARTIFACT_INVENTORY_NOT_STABLE: 六类产物大小在 5 轮内未收敛');
+}
+
 function filterEventsByDate(events, dateFrom, dateTo) {
   if (!dateFrom && !dateTo) return events;
   return events.filter(e => {
@@ -5078,15 +5371,29 @@ function cmdEnd(args, options = {}) {
         const archiveDirAbs = path.isAbsolute(archiveResult.archive_path)
           ? archiveResult.archive_path
           : path.resolve(projectRoot, archiveResult.archive_path);
-        ensureArchiveManifest(projectRoot, change, archiveDirAbs, {
-          reason: archiveResult.reason || '',
-          method: archiveResult.method || 'skywalk-full-spec-archive',
-          archivePath: archiveDirAbs,
-          archivedAt: archiveResult.created_at || archiveResult.archived_at,
-          copiedSpecs: archiveResult.copied_specs,
-          finalizeAfterReports: true,
-          runIdentity: latestExisting.event_id,
-        });
+        const existingReportPaths = reportArtifactPaths(projectRoot, archiveResult);
+        if (existingReportPaths.length === 3) {
+          finalizeArtifactInventory({
+            projectRoot,
+            dataDir,
+            change,
+            archiveResult,
+            reportPaths: existingReportPaths,
+            level: args['report-level'] || 'change',
+            capability: args.capability || args['capability-name'] || startEvent?.capability,
+            runIdentity: latestExisting.event_id,
+          });
+        } else {
+          ensureArchiveManifest(projectRoot, change, archiveDirAbs, {
+            reason: archiveResult.reason || '',
+            method: archiveResult.method || 'skywalk-full-spec-archive',
+            archivePath: archiveDirAbs,
+            archivedAt: archiveResult.created_at || archiveResult.archived_at,
+            copiedSpecs: archiveResult.copied_specs,
+            finalizeAfterReports: true,
+            runIdentity: latestExisting.event_id,
+          });
+        }
       }
       const output = {
         event_id: eventId,
@@ -5339,13 +5646,14 @@ function cmdEnd(args, options = {}) {
     const archiveDirAbs = path.isAbsolute(finalArchiveResult.archive_path)
       ? finalArchiveResult.archive_path
       : path.resolve(projectRoot, finalArchiveResult.archive_path);
-    ensureArchiveManifest(projectRoot, change, archiveDirAbs, {
-      reason: finalArchiveResult.reason || '',
-      method: finalArchiveResult.method || 'skywalk-full-spec-archive',
-      archivePath: archiveDirAbs,
-      archivedAt: finalArchiveResult.created_at || finalArchiveResult.archived_at,
-      copiedSpecs: finalArchiveResult.copied_specs,
-      finalizeAfterReports: true,
+    finalizeArtifactInventory({
+      projectRoot,
+      dataDir,
+      change,
+      archiveResult: finalArchiveResult,
+      reportPaths: writtenReportPaths,
+      level: args['report-level'] || 'change',
+      capability: args.capability || args['capability-name'] || startEvent?.capability,
       runIdentity: event.event_id,
     });
   }
@@ -5468,6 +5776,153 @@ function isValidCompletionTestResults(testResults) {
   return true;
 }
 
+/**
+ * Pure task↔test reference resolver.
+ * Accepts mutually exclusive test_event_id or test_run_id.
+ * Does not throw; callers decide whether to fail strict writes.
+ */
+function resolveTaskVerificationReference(events, input = {}) {
+  const taskId = input.task_id || input.taskId || null;
+  const change = input.change || null;
+  const inputEventId = input.test_event_id || null;
+  const inputRunId = input.test_run_id || null;
+  const verificationNotApplicable = input.verification_not_applicable === true;
+  const verificationReason = String(
+    input.verification_not_applicable_reason
+      || input.verification_reason
+      || '',
+  ).trim();
+
+  const base = {
+    status: 'missing',
+    resolved_event_id: null,
+    input_event_id: inputEventId,
+    input_run_id: inputRunId,
+    covered_task_ids: [],
+    reason_code: null,
+  };
+
+  if (verificationNotApplicable) {
+    if (!verificationReason) {
+      return {
+        ...base,
+        status: 'invalid',
+        reason_code: 'TASK_VERIFICATION_REASON_REQUIRED',
+      };
+    }
+    return {
+      ...base,
+      status: 'waived',
+      reason_code: 'VERIFICATION_NOT_APPLICABLE',
+    };
+  }
+
+  if (inputEventId && inputRunId) {
+    return {
+      ...base,
+      status: 'invalid',
+      reason_code: 'TASK_TEST_REFERENCE_MUTEX',
+    };
+  }
+
+  if (!inputEventId && !inputRunId) {
+    return {
+      ...base,
+      status: 'missing',
+      reason_code: 'TASK_TEST_REFERENCE_MISSING',
+    };
+  }
+
+  const scoped = (events || []).filter((event) => {
+    if (!change) return true;
+    return event.change === change || event.attribution?.target_change === change;
+  });
+
+  function evaluateCandidate(event) {
+    if (!event) {
+      return { ...base, status: 'invalid', reason_code: 'TASK_TEST_REFERENCE_MISSING' };
+    }
+    if (change
+        && event.change
+        && event.change !== change
+        && event.attribution?.target_change !== change) {
+      return { ...base, status: 'invalid', reason_code: 'TASK_TEST_REFERENCE_CROSS_CHANGE' };
+    }
+    if (event.type !== 'test_result') {
+      return { ...base, status: 'invalid', reason_code: 'TASK_TEST_REFERENCE_NOT_TEST' };
+    }
+    const testResults = event.details?.test_results || {};
+    const covered = collectVerifiedTaskIds(event);
+    if (testResults.evidence_tier !== 'strict') {
+      return {
+        ...base,
+        status: 'invalid',
+        resolved_event_id: event.event_id || null,
+        covered_task_ids: covered,
+        reason_code: 'TASK_TEST_REFERENCE_NON_STRICT',
+      };
+    }
+    if (!isValidCompletionTestResults(testResults)) {
+      return {
+        ...base,
+        status: 'invalid',
+        resolved_event_id: event.event_id || null,
+        covered_task_ids: covered,
+        reason_code: 'TASK_TEST_REFERENCE_INVALID',
+      };
+    }
+    if (taskId && !covered.includes(taskId)) {
+      return {
+        ...base,
+        status: 'invalid',
+        resolved_event_id: event.event_id || null,
+        covered_task_ids: covered,
+        reason_code: 'E_TEST_IDENTITY_MISMATCH',
+      };
+    }
+    return {
+      ...base,
+      status: 'verified',
+      resolved_event_id: event.event_id || null,
+      covered_task_ids: covered,
+      reason_code: null,
+    };
+  }
+
+  if (inputEventId) {
+    const referenced = scoped.find(event => event.event_id === inputEventId);
+    return evaluateCandidate(referenced);
+  }
+
+  const candidates = scoped.filter((event) => {
+    if (event.type !== 'test_result') return false;
+    if (event.run_id !== inputRunId) return false;
+    const testResults = event.details?.test_results || {};
+    if (testResults.evidence_tier !== 'strict') return false;
+    if (!isValidCompletionTestResults(testResults)) return false;
+    if (taskId && !collectVerifiedTaskIds(event).includes(taskId)) return false;
+    return true;
+  });
+
+  if (candidates.length === 0) {
+    const anySameRun = scoped.filter(event => event.type === 'test_result' && event.run_id === inputRunId);
+    if (anySameRun.length === 0) {
+      return { ...base, status: 'invalid', reason_code: 'TASK_TEST_REFERENCE_MISSING' };
+    }
+    return evaluateCandidate(anySameRun[0]);
+  }
+  if (candidates.length > 1) {
+    return {
+      ...base,
+      status: 'ambiguous',
+      candidate_event_ids: candidates.map(event => event.event_id).filter(Boolean),
+      covered_task_ids: [...new Set(candidates.flatMap(collectVerifiedTaskIds))],
+      reason_code: 'TASK_TEST_REFERENCE_AMBIGUOUS',
+    };
+  }
+  return evaluateCandidate(candidates[0]);
+}
+
 function normalizeStrictProcessNote(args, details) {
   const input = details?.process_note && typeof details.process_note === 'object'
     ? details.process_note
@@ -5514,6 +5969,7 @@ function normalizeStrictTaskUpdate(args, details, dataDir, change) {
     'run_id',
   );
   const testEventId = input?.test_event_id || details?.test_event_id || null;
+  const testRunId = input?.test_run_id || details?.test_run_id || null;
   const verificationNotApplicable = input?.verification_not_applicable === true
     || details?.verification_not_applicable === true;
   const verificationReason = String(
@@ -5524,33 +5980,35 @@ function normalizeStrictTaskUpdate(args, details, dataDir, change) {
       || '',
   ).trim();
 
+  let resolvedTestEventId = testEventId;
+  let resolvedTestRunId = testRunId || undefined;
+
   if (status === 'completed') {
-    if (!testEventId && !verificationNotApplicable) {
-      fail('TASK_TEST_REFERENCE_MISSING: completed 任务必须引用 test_event_id，或声明 verification_not_applicable=true 并说明原因');
-    }
-    if (verificationNotApplicable && !verificationReason) {
-      fail('TASK_VERIFICATION_REASON_REQUIRED: verification_not_applicable 必须说明原因');
-    }
-    if (testEventId) {
-      const referenced = readEvents(dataDir, change).find(event => event.event_id === testEventId);
-      if (!referenced || referenced.type !== 'test_result') {
-        fail(`TASK_TEST_REFERENCE_MISSING: 同一 change 中不存在 test_result "${testEventId}"`);
-      }
-      const testResults = referenced.details?.test_results || {};
-      if (!isValidCompletionTestResults(testResults)) {
-        fail(`TASK_TEST_REFERENCE_INVALID: test_result "${testEventId}" 不能证明任务完成`);
-      }
-      const verifiedTaskIds = new Set([
-        referenced.task_id,
-        testResults.task_id,
-        ...(Array.isArray(testResults.verified_task_ids) ? testResults.verified_task_ids : []),
-      ].filter(Boolean));
-      if (testResults.evidence_tier !== 'strict' || !verifiedTaskIds.has(taskId)) {
-        fail(`E_TEST_IDENTITY_MISMATCH: test_result "${testEventId}" 未严格验证任务 "${taskId}"`);
-      }
+    const events = readEvents(dataDir, change);
+    const resolution = resolveTaskVerificationReference(events, {
+      task_id: taskId,
+      change,
+      test_event_id: testEventId,
+      test_run_id: testRunId,
+      verification_not_applicable: verificationNotApplicable,
+      verification_not_applicable_reason: verificationReason,
+    });
+
+    if (resolution.status === 'waived') {
+      // ok
+    } else if (resolution.status === 'verified') {
+      resolvedTestEventId = resolution.resolved_event_id;
+      if (testRunId) resolvedTestRunId = testRunId;
       if (typeof input?.tdd_required !== 'boolean') {
         fail('TASK_TDD_REQUIRED_MISSING: completed 任务引用测试时必须明确 tdd_required=true/false');
       }
+    } else if (resolution.status === 'ambiguous') {
+      fail(`TASK_TEST_REFERENCE_AMBIGUOUS: test_run_id "${testRunId}" 对应多个严格测试候选，拒绝猜测`);
+    } else if (resolution.status === 'missing') {
+      fail('TASK_TEST_REFERENCE_MISSING: completed 任务必须引用 test_event_id 或唯一 test_run_id，或声明 verification_not_applicable=true 并说明原因');
+    } else {
+      const code = resolution.reason_code || 'TASK_TEST_REFERENCE_INVALID';
+      fail(`${code}: 测试引用无法验证任务 "${taskId}"`);
     }
   }
 
@@ -5564,7 +6022,8 @@ function normalizeStrictTaskUpdate(args, details, dataDir, change) {
         ...(details.task_update || {}),
         task_id: taskId,
         status,
-        test_event_id: testEventId,
+        test_event_id: resolvedTestEventId,
+        test_run_id: resolvedTestRunId,
         tdd_required: typeof input?.tdd_required === 'boolean' ? input.tdd_required : undefined,
         test_requirement: input?.test_requirement
           || (verificationNotApplicable ? 'not_applicable' : 'required'),
@@ -5594,6 +6053,325 @@ function eventIdempotencyFingerprint(event) {
   });
 }
 
+function collectVerifiedTaskIds(event) {
+  const testResults = event?.details?.test_results || {};
+  return [...new Set([
+    event?.task_id,
+    testResults.task_id,
+    ...(Array.isArray(testResults.verified_task_ids) ? testResults.verified_task_ids : []),
+  ].filter(Boolean))];
+}
+
+function isStrictCoveringTest(event, taskId) {
+  const testResults = event?.details?.test_results || {};
+  if (testResults.evidence_tier !== 'strict') return false;
+  if (!isValidCompletionTestResults(testResults)) return false;
+  return new Set(collectVerifiedTaskIds(event)).has(taskId);
+}
+
+/**
+ * Four-way task evidence audit (document / completion event / direct backlink / strict coverage).
+ * Does not treat invalid direct backlinks as "no tests".
+ */
+function buildTaskEvidenceAudit(change, taskModel, events = [], options = {}) {
+  const completedTasks = (taskModel?.primary_tasks?.tasks || []).filter(task => task.completed);
+  const latestTaskUpdates = new Map();
+  const testEvents = new Map();
+  const strictByTask = new Map();
+
+  for (const event of events) {
+    if (event.change && change && event.change !== change) continue;
+    if (event.type === 'task_update'
+        && (event.status === 'completed' || event.details?.task_update?.status === 'completed')) {
+      const existing = latestTaskUpdates.get(event.task_id);
+      if (!existing || timestampMs(event) > timestampMs(existing)) {
+        latestTaskUpdates.set(event.task_id, event);
+      }
+      continue;
+    }
+    if (event.type === 'test_result') {
+      testEvents.set(event.event_id, event);
+      for (const verifiedTaskId of collectVerifiedTaskIds(event)) {
+        if (!isStrictCoveringTest(event, verifiedTaskId)) continue;
+        const related = strictByTask.get(verifiedTaskId) || [];
+        related.push(event);
+        strictByTask.set(verifiedTaskId, related);
+      }
+    }
+  }
+
+  let withUpdate = 0;
+  let directVerified = 0;
+  let strictVerified = 0;
+  let waived = 0;
+  const tasks = [];
+
+  for (const task of completedTasks) {
+    const update = latestTaskUpdates.get(task.task_id);
+    const updateDetails = update?.details?.task_update || update?.details || {};
+    const notApplicable = updateDetails.verification_not_applicable === true
+      && Boolean(String(updateDetails.verification_not_applicable_reason || '').trim());
+    const testEventId = updateDetails.test_event_id || null;
+    const testEvent = testEventId ? testEvents.get(testEventId) : null;
+    const directOk = Boolean(testEvent) && isStrictCoveringTest(testEvent, task.task_id);
+    const strictOk = (strictByTask.get(task.task_id) || []).length > 0;
+
+    if (update) withUpdate += 1;
+    if (directOk) directVerified += 1;
+    if (strictOk) strictVerified += 1;
+    if (notApplicable) waived += 1;
+
+    let backlinkStatus = 'missing';
+    if (notApplicable) backlinkStatus = 'waived';
+    else if (!testEventId) backlinkStatus = 'missing';
+    else if (!testEvent) backlinkStatus = 'invalid';
+    else if (!directOk) backlinkStatus = 'invalid';
+    else backlinkStatus = 'verified';
+
+    tasks.push({
+      task_id: task.task_id,
+      has_completion_event: Boolean(update),
+      direct_backlink_status: backlinkStatus,
+      test_event_id: testEventId,
+      strict_covered: strictOk,
+      verification_not_applicable: notApplicable,
+    });
+  }
+
+  return {
+    mode: options.mode === 'report-only' ? 'report-only' : 'strict',
+    document_completion: {
+      completed: completedTasks.length,
+      total: taskModel?.primary_tasks?.total ?? completedTasks.length,
+      source: 'tasks-document',
+    },
+    completion_event_coverage: {
+      verified: withUpdate,
+      total: completedTasks.length,
+    },
+    direct_test_backlink: {
+      verified: directVerified,
+      total: completedTasks.length,
+    },
+    strict_test_coverage: {
+      verified: strictVerified,
+      total: completedTasks.length,
+    },
+    verification_waivers: {
+      count: waived,
+      total: completedTasks.length,
+    },
+    tasks,
+  };
+}
+
+function extractTddPairNumber(text) {
+  if (!text) return null;
+  const red = String(text).match(/\bRED-(\d+)\b/i) || String(text).match(/red(\d+)/i);
+  if (red) return { role: 'red', pair: Number(red[1]) };
+  const green = String(text).match(/\bGREEN-(\d+)\b/i) || String(text).match(/green(\d+)/i);
+  if (green) return { role: 'green', pair: Number(green[1]) };
+  return null;
+}
+
+function buildTddPairDefinitions(taskModel, events = [], options = {}) {
+  if (Array.isArray(options.pair_definitions) && options.pair_definitions.length > 0) {
+    return options.pair_definitions.map((item) => ({
+      pair_id: item.pair_id || `pair-${item.pair_number}`,
+      pair_number: Number(item.pair_number),
+      red_task_id: item.red_task_id || null,
+      green_task_id: item.green_task_id || null,
+    }));
+  }
+
+  const byNumber = new Map();
+  const ensure = (num) => {
+    if (!byNumber.has(num)) {
+      byNumber.set(num, {
+        pair_id: `pair-${num}`,
+        pair_number: num,
+        red_task_id: null,
+        green_task_id: null,
+      });
+    }
+    return byNumber.get(num);
+  };
+
+  for (const task of (taskModel?.primary_tasks?.tasks || [])) {
+    const hint = extractTddPairNumber(task.title || task.summary || task.task_id);
+    if (!hint || !Number.isFinite(hint.pair)) continue;
+    const entry = ensure(hint.pair);
+    if (hint.role === 'red') entry.red_task_id = task.task_id;
+    if (hint.role === 'green') entry.green_task_id = task.task_id;
+  }
+
+  for (const event of events) {
+    if (event.type !== 'test_result') continue;
+    const explicit = event.details?.test_results?.tdd_pair_id
+      || event.details?.tdd_pair_id;
+    if (explicit) {
+      const numMatch = String(explicit).match(/(\d+)/);
+      const num = numMatch ? Number(numMatch[1]) : null;
+      if (!num) continue;
+      const entry = ensure(num);
+      const role = event.details?.test_results?.tdd_role
+        || event.details?.test_results?.tdd_phase;
+      if (role === 'red') entry.red_task_id = entry.red_task_id || event.task_id;
+      if (role === 'green' || role === 'regression') {
+        entry.green_task_id = entry.green_task_id || event.task_id;
+      }
+      continue;
+    }
+    const fromRun = extractTddPairNumber(event.run_id);
+    const fromSummary = extractTddPairNumber(event.summary);
+    const hint = fromRun || fromSummary || extractTddPairNumber(event.details?.test_results?.tdd_phase);
+    if (!hint) continue;
+    const entry = ensure(hint.pair);
+    const phase = event.details?.test_results?.tdd_phase;
+    if (hint.role === 'red' || phase === 'red') {
+      entry.red_task_id = entry.red_task_id || event.task_id;
+    }
+    if (hint.role === 'green' || phase === 'green' || phase === 'regression') {
+      // Prefer dedicated green task over regression umbrella task when already set.
+      if (!entry.green_task_id || phase === 'green') {
+        if (phase === 'green' || hint.role === 'green') {
+          entry.green_task_id = entry.green_task_id || event.task_id;
+        }
+      }
+    }
+  }
+
+  // 兼容没有 RED-n/GREEN-n 编号、但 task_update 明确声明 tdd_required 的
+  // 同任务链。仅在完全没有显式/可推导 pair 时启用，避免与编号 pair 重复计数。
+  if (byNumber.size === 0) {
+    const implicitTaskIds = [...new Set(events
+      .filter(event => (
+        event.type === 'task_update'
+        && event.task_id
+        && event.details?.task_update?.tdd_required === true
+      ))
+      .map(event => event.task_id))];
+    return implicitTaskIds.map((taskId, index) => ({
+      pair_id: `task-pair:${taskId}`,
+      pair_number: index + 1,
+      red_task_id: taskId,
+      green_task_id: taskId,
+    }));
+  }
+
+  return [...byNumber.values()].sort((a, b) => a.pair_number - b.pair_number);
+}
+
+/**
+ * Pair-level TDD audit. Historical fallback uses RED-n/GREEN-n labels and run_ids.
+ */
+function buildTddPairAudit(change, taskModel, events = [], options = {}) {
+  const scopedEvents = events.filter(event => (
+    !change
+    || event.change === change
+    || event.attribution?.target_change === change
+  ));
+  const definitions = buildTddPairDefinitions(taskModel, scopedEvents, options);
+  const testsByTask = new Map();
+
+  for (const event of scopedEvents) {
+    if (event.type !== 'test_result') continue;
+    for (const taskId of collectVerifiedTaskIds(event)) {
+      const related = testsByTask.get(taskId) || [];
+      related.push(event);
+      testsByTask.set(taskId, related);
+    }
+    if (event.task_id) {
+      const related = testsByTask.get(event.task_id) || [];
+      if (!related.includes(event)) related.push(event);
+      testsByTask.set(event.task_id, related);
+    }
+  }
+  for (const related of testsByTask.values()) {
+    related.sort((a, b) => {
+      const delta = timestampMs(a) - timestampMs(b);
+      if (delta !== 0) return delta;
+      return String(a.event_id || '').localeCompare(String(b.event_id || ''));
+    });
+  }
+
+  const pairs = [];
+  let complete = 0;
+
+  for (const def of definitions) {
+    const redEvents = (testsByTask.get(def.red_task_id) || [])
+      .filter(event => event.details?.test_results?.tdd_phase === 'red');
+    const greenOrRegression = [
+      ...(testsByTask.get(def.green_task_id) || []),
+      ...(testsByTask.get(def.red_task_id) || []),
+    ].filter((event, index, arr) => arr.indexOf(event) === index)
+      .filter(event => ['green', 'regression'].includes(event.details?.test_results?.tdd_phase)
+        && event.details?.test_results?.exit_code === 0);
+
+    let status = 'unclassified';
+    if (redEvents.length === 0 && def.green_task_id) {
+      const hasGreenSide = greenOrRegression.some(event => collectVerifiedTaskIds(event).includes(def.green_task_id)
+        || event.task_id === def.green_task_id);
+      status = hasGreenSide || def.red_task_id ? 'red-missing' : 'unclassified';
+      if (redEvents.length === 0) status = 'red-missing';
+    }
+
+    if (redEvents.length > 0) {
+      const firstRed = redEvents.find((event) => {
+        const results = event.details?.test_results || {};
+        return results.valid_red === true
+          && results.exit_code !== 0
+          && Number(results.failed || 0) > 0;
+      });
+      if (!firstRed) {
+        status = 'red-did-not-fail';
+      } else {
+        const redTs = timestampMs(firstRed);
+        const greenAfter = greenOrRegression.find(event => (
+          timestampMs(event) > redTs
+          && (
+            !def.green_task_id
+            || collectVerifiedTaskIds(event).includes(def.green_task_id)
+            || event.task_id === def.green_task_id
+            || event.details?.test_results?.tdd_phase === 'green'
+          )
+        ));
+        // Accept later regression that covers the green task id.
+        const regressionCover = greenOrRegression.find(event => (
+          timestampMs(event) > redTs
+          && def.green_task_id
+          && collectVerifiedTaskIds(event).includes(def.green_task_id)
+        ));
+        if (greenAfter || regressionCover) {
+          status = 'complete';
+          complete += 1;
+        } else {
+          status = 'green-missing';
+        }
+      }
+    } else if (!def.red_task_id && def.green_task_id) {
+      status = 'red-missing';
+    } else if (def.red_task_id && redEvents.length === 0) {
+      status = 'red-missing';
+    }
+
+    pairs.push({
+      pair_id: def.pair_id,
+      pair_number: def.pair_number,
+      red_task_id: def.red_task_id,
+      green_task_id: def.green_task_id,
+      status,
+    });
+  }
+
+  return {
+    mode: options.mode === 'report-only' ? 'report-only' : 'strict',
+    required: pairs.length,
+    complete,
+    pairs,
+  };
+}
+
 function buildApplyEvidenceAudit(change, taskModel, events = [], options = {}) {
   const strict = options.mode !== 'report-only';
   const completedTasks = (taskModel?.primary_tasks?.tasks || []).filter(task => task.completed);
@@ -5644,6 +6422,12 @@ function buildApplyEvidenceAudit(change, taskModel, events = [], options = {}) {
         severity: strict ? 'error' : 'warning',
         task_id: task.task_id,
         message: '主任务已标完成，但缺少 completed task_update 事件',
+        verdict: 'missing-task-update',
+        expected: '已完成主任务应存在同一变更下的 completed task_update 事件。',
+        actual: '任务文档标记已完成，但事件流中没有对应 completed task_update。',
+        root_cause: '任务完成状态只写入了 tasks 文档，没有同步记录结构化 task_update 事件。',
+        impact: '任务完成状态无法与测试事件建立直接追溯链。',
+        remediation: '为该任务补录真实 completed task_update；若历史证据不存在，应明确标记为无法追溯。',
       });
       continue;
     }
@@ -5662,39 +6446,52 @@ function buildApplyEvidenceAudit(change, taskModel, events = [], options = {}) {
       && testResults.evidence_tier === 'strict'
       && verifiedTaskIds.has(task.task_id)
       && isValidCompletionTestResults(testResults);
+    const strictCovered = (testsByTask.get(task.task_id) || [])
+      .some(event => isStrictCoveringTest(event, task.task_id));
     if (validTest || notApplicable) {
       withTestEvidence += 1;
+    } else if (strictCovered) {
+      findings.push({
+        code: 'TASK_TEST_LINKAGE_DEFECT',
+        severity: 'warning',
+        task_id: task.task_id,
+        message: '任务存在严格测试覆盖，但 completed task_update 的直接引用无效或缺失（链路缺陷，不是缺测试）',
+        verdict: 'linkage-defect',
+        expected: 'completed task_update 应通过 test_event_id 精确引用覆盖该任务的严格成功测试。',
+        actual: '存在严格测试覆盖，但 task_update 没有有效的直接测试引用。',
+        root_cause: 'task_update 的 test_event_id 缺失、无效，或引用事件没有明确覆盖当前任务。',
+        impact: '测试本身存在，但任务到测试的直接审计链不完整。',
+        remediation: '修正 task_update 的 test_event_id，使其指向覆盖当前任务的 strict 成功测试事件。',
+      });
     } else {
       findings.push({
         code: 'TASK_TEST_EVIDENCE_MISSING',
         severity: strict ? 'error' : 'warning',
         task_id: task.task_id,
         message: 'completed task_update 没有有效测试引用或不适用理由',
+        verdict: 'missing-test-evidence',
+        expected: 'completed task_update 应引用严格成功测试，或提供明确且非空的不适用理由。',
+        actual: '没有有效直接引用，也没有发现可间接覆盖该任务的严格成功测试。',
+        root_cause: '任务完成事件缺少测试证据，且未声明可审计的不适用理由。',
+        impact: '无法验证该任务完成状态是否经过测试。',
+        remediation: '执行覆盖该任务的严格测试并记录引用；确实不适用时填写具体原因。',
       });
     }
 
     if (updateDetails.tdd_required === true) {
       tddRequired += 1;
-      const related = testsByTask.get(task.task_id) || [];
-      const redIndex = related.findIndex(event => event.details?.test_results?.valid_red === true);
-      const greenIndex = related.findIndex((event, index) => (
-        index > redIndex
-          && event.details?.test_results?.exit_code === 0
-          && ['green', 'regression'].includes(event.details?.test_results?.tdd_phase)
-      ));
-      if (redIndex >= 0 && greenIndex > redIndex) {
-        redGreenComplete += 1;
-      } else {
-        findings.push({
-          code: 'TDD_RED_GREEN_INCOMPLETE',
-          severity: strict ? 'error' : 'warning',
-          task_id: task.task_id,
-          message: 'TDD 任务缺少有效 RED→GREEN 顺序证据',
-        });
-      }
     }
   }
 
+  const pairAudit = buildTddPairAudit(change, taskModel, events, options);
+  tddRequired = pairAudit.required;
+  redGreenComplete = pairAudit.complete;
+  if (strict) {
+    findings.push(...pairAudit.pairs
+      .filter(pair => pair.status !== 'complete')
+      .map(pair => ({ ...tddPairFinding(pair), severity: 'error' })));
+  }
+
   return {
     mode: strict ? 'strict' : 'report-only',
     status: findings.some(finding => finding.severity === 'error') ? 'blocked' : 'pass',
@@ -6788,15 +7585,40 @@ function cmdArchiveDocs(args) {
     }
 
     const archiveDir = path.resolve(result.archive_path);
-    const finalPackage = ensureArchiveManifest(projectRoot, changeName, archiveDir, {
-      reason: result.reason || args.reason || '',
-      method: result.method || 'skywalk-full-spec-archive',
-      archivePath: archiveDir,
-      archivedAt: result.created_at || result.archived_at,
-      copiedSpecs: result.copied_specs,
-      finalizeAfterReports: true,
-      runIdentity: stageEnd?.event_id || `archive-docs:${changeName}`,
-    });
+    let finalPackage;
+    if (stageEnd) {
+      // cmdEnd 已完成报告/Manifest/ZIP 的收敛封装；此处只读取终态，禁止再次
+      // 物化导致报告中记录的 Manifest/ZIP 大小失真。
+      const finalEvent = readAllEventEndsById(
+        getDataDir(projectRoot),
+        stageEnd.event_id,
+        changeName,
+      ).sort((a, b) => timestampMs(b) - timestampMs(a))[0];
+      const finalArchiveResult = finalEvent?.details?.archive_result || {};
+      const manifestPath = path.isAbsolute(finalArchiveResult.manifest_path || '')
+        ? finalArchiveResult.manifest_path
+        : path.resolve(projectRoot, finalArchiveResult.manifest_path || path.join(archiveDir, 'archive-manifest.json'));
+      const packagePath = path.isAbsolute(finalArchiveResult.package_path || '')
+        ? finalArchiveResult.package_path
+        : path.resolve(projectRoot, finalArchiveResult.package_path || `${archiveDir}.zip`);
+      finalPackage = {
+        manifest: JSON.parse(fs.readFileSync(manifestPath, 'utf8')),
+        manifest_path: manifestPath,
+        canonical_facts_path: path.resolve(archiveDir, 'canonical-facts.json'),
+        conversion_report_path: path.resolve(archiveDir, 'conversion-report.json'),
+        package_path: packagePath,
+      };
+    } else {
+      finalPackage = ensureArchiveManifest(projectRoot, changeName, archiveDir, {
+        reason: result.reason || args.reason || '',
+        method: result.method || 'skywalk-full-spec-archive',
+        archivePath: archiveDir,
+        archivedAt: result.created_at || result.archived_at,
+        copiedSpecs: result.copied_specs,
+        finalizeAfterReports: true,
+        runIdentity: `archive-docs:${changeName}`,
+      });
+    }
     result = {
       ...result,
       schema_version: finalPackage.manifest.schema_version,
@@ -6994,7 +7816,12 @@ module.exports = {
   formatDuration,
   formatReworkReasons,
   buildReport,
+  finalizeArtifactInventory,
   buildApplyEvidenceAudit,
+  buildTaskEvidenceAudit,
+  buildTddPairAudit,
+  resolveTaskVerificationReference,
+  extractChangedFiles,
   computeGitDocumentMetrics,
   getCheckResults,
   getBuildResults,