@feng0531/dsh-code-review 0.87.3 → 0.87.4

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 本文件介绍对使用者有意义的变化。安装与参数见 [README](README.md)，本次发布正文见 [发布说明](RELEASE-NOTES.md)。历史提交和安装包保留在 [GitHub Releases](https://github.com/f-e-n-g-0531/dsh-code-review/releases)；本文不把开发日志当作功能介绍。
 
+## 0.87.4 — 默认交付人能读懂的审核报告
+
+- 默认主文先给是否查完、问题卡、未完成原因和下一步；完整证据与执行台账移到同一报告折叠附录，不要求使用者手动拼接批次。
+- 按原文聚合限制并保留归属和记录；区分轮数、读取分配／共享额度、输入预算及依赖，空发现不暗示通过。
+- 严格区分复核支持、待核实、原有和已反驳；保留项目冲突候选及分页／过期／复用限制，修正 SVN 历史标签。仅本地呈现，不改变 JSON、取证或证据门槛。
+
 ## 0.87.3 — 明确审核指令不再重复确认
 
 - 明确要求审核且内部预览与当前授权范围、模型及发送目的地一致时，工具指导直接继续执行，不再要求第二次人工确认；仅预览或超出授权时仍暂停。

package/DEVELOPMENT.md

@@ -86,6 +86,12 @@ JSON合同新增280字节传输提示防止原始换行／反斜线转义错误
 
 Git 路径和索引、SVN XML、规则文件与 SVN 链接记录仍按各自 UTF-8 协议校验，不因源码兼容而放宽；固定宽度关键字映射仍须独立核验，不支持的混杂编码或映射会明确阻断。
 
+## 默认报告呈现
+
+变更与当前源码模式统一输出一份人可读 Markdown：业务首屏结论、按“本次新增（复核支持）／当前源码问题（复核支持）／待核实／原有问题（复核支持）／已反驳”分区的问题卡、聚合未完成原因和下一步。完整证据与判定、逐项覆盖、风险计划、执行诊断和按原文聚合的限制放在同一报告的 `<details>` 技术附录；不改成需要用户拼接的批报告，JSON 仍完整保留原始记录。
+
+这是本地呈现层调整，不改变取证算法、来源权限、独立复核或新旧对照门槛，不额外调用 LLM，也不由通俗主文代做源码复审。复核支持和引用校验不等于事实或因果证明；变更模式中缺少有效新旧对照的 supported 候选仍待核实；当前源码模式不要求历史对照，也不冒充本次新增。未完成原因区分检索轮数、共享读取调用数、读取字节、阶段输入预算和前置阶段未完成；未知原因不推测成输入超限，限制记录数不当作缺陷数或待审文件数。主文有界聚合不隐藏限制，全部范围与原始记录仍可在附录追溯。历史审查标签按实际模式显示 Git／SVN，不能把 SVN 历史误标为 Git。
+
 ## 性能与等待诊断
 
 风险计划只产生待证问题和后续来源需求，不再自行展开检索对话；计划不合法则明确回退，主审、跨文件分析和独立证据复核保持各自严格校验，不把回退当作完成。规划原始调用与 JSON 纠正仍使用同一共享调用预算。批准目录附各来源物理 `lineCount`（空源为 0，不计尾换行的虚拟空行），旧／新侧分别取界，不将越界读取钳位成成功或伪造证据。

package/README.md

@@ -63,7 +63,9 @@ dsh plugin add https://github.com/f-e-n-g-0531/dsh-code-review.git
 
 ### 5. 查看结果
 
-执行工具会在对话中返回 **中文 Markdown 报告**，同时返回结构化 JSON。“执行诊断”列出实际加载的插件版本、阶段调用和墙钟统计；累计调用耗时可能并发重叠，不代表纯提供方耗时或可相加的总耗时。先看前置的“结论摘要”和问题列表，再核对覆盖与限制；摘要区分已确认新增、未决、已反驳和既有问题，不把仅 supported 或缺少旧新对照的候选当作确认新增。
+执行工具默认在对话中返回 **一份人可读的中文 Markdown 报告**，同时保留完整结构化 JSON。首屏先回答所选范围是否查完、记录了哪些候选和哪些结论尚不能下；问题卡按“本次新增（复核支持）”“当前源码问题（复核支持）”“待核实”“原有问题（复核支持）”“已反驳”分区，说明位置、触发条件、影响、依据及已有建议。分区仍遵循严格证据判定：仅 supported 或缺少有效旧新对照不能算本次新增，当前源码模式不作历史新增归因；**复核支持和引用校验不等于事实、运行复现或因果证明。**
+
+主文聚合未完成原因并给出下一步；完整证据与判定、逐项覆盖、风险计划、执行诊断及聚合限制保留在**同一报告的 `<details>` 技术附录**，展开即可核对，不需要拼接批报告。通俗主文只是已有结果的呈现，不代做源码复审、不隐藏限制、不放宽证据门槛，也不会为改写报告额外调用模型或改变取证算法。执行诊断列出实际加载的插件版本、阶段调用和墙钟统计；累计调用耗时可能并发重叠，不代表纯提供方耗时或可相加的总耗时。
 
 如需保存报告，可以另行告诉 Agent：“将本次报告保存到我指定的位置”。插件本身不会自动在业务仓库创建报告文件。
 

package/RELEASE-NOTES.md

@@ -1,17 +1,17 @@
-# v0.87.3 发布说明
+# v0.87.4 发布说明
 
-## 审核授权与内部预览
+## 默认报告先给人能读懂的结论
 
-明确要求审核（例如“用 dsh-code-review 审核 r7364”）且内部预览与当前授权范围、模型及发送目的地一致时，工具描述和后台预览完成提示指导 Agent 直接继续执行，不再机械要求第二次确认。只要求预览、要求等待，或范围／模型／目的地超出授权时仍须取得授权。
+默认输出不再把执行台账平铺为报告。仍只交付一份统一 Markdown：先说明是否查完、形成了什么问题记录，再按复核支持本次新增／当前源码问题、待核实、原有问题、已反驳分区，先讲触发条件、影响和建议。没有问题记录不等于没有缺陷，主审完成不等于可以放行。
 
-此次修复的是 Agent 工具指引与预览完成提示，不新增一键自动执行 API，也不在后台自行推断自然语言授权。Agent 仍须捕获并核对预览，再传 confirmed=true。
+未完成范围按原因和受影响条目聚合，区分单阶段检索轮数、读取分配或共享额度、输入预算和前置依赖。完整证据、逐项覆盖、计划、执行诊断和保留归属的限制放在同一报告的折叠技术附录；重复限制只集中显示一次原文，保留次数、差异字段及可重建的原记录。
 
-## 保留的安全边界
+## 保留真实性与证据边界
 
-服务层确认参数、一次性预览、快照新鲜度、有效期、会话／目录／模型身份、宿主工具权限及独立远端许可不变。重启、保存任务或旧批准本身不授权再次外发。私有模型工件仍需展示隐私警告并取得独立明确同意，不能借审核请求读取。
+此修复仅改变本地呈现，不额外调用模型、不重新审核业务源码、不改变读取和执行预算、不放宽证据或新增归因校验。原始报告 JSON 保持完整。分页不足、取消、失败、过期、复用、窗口／复核／跨文件未完成仍明确披露；项目报告保留结论冲突的候选，SVN 历史不再误标为 Git。
 
 ## 验证
 
-补充同步／后台工具描述与终态预览提示回归测试，覆盖明确授权直接继续、仅预览不执行、超授权需询问及私有工件独立同意。发布以全量测试和四矩阵标签 CI 为门禁。
+新增报告端到端、问题卡、限制聚合与安全转义测试，并使用保留归档中74条目、290限制、34跨文件未完成这一计数模式的合成呈现夹具回归。公开夹具不含原始路径、源码或限制正文；另在本地验证真实归档呈现，不是新的源码审核结论。发布以全量测试及四矩阵标签 CI 为门禁。
 
-安装与使用见 [README](README.md)，历史变化见 [变更记录](CHANGELOG.md)，发布门禁见 [开发说明](DEVELOPMENT.md)。发布不等于自动升级或重启当前桌面宿主。
+安装与使用见 [README](README.md)，历史变化见 [变更记录](CHANGELOG.md)，发布门禁见 [开发说明](DEVELOPMENT.md)。发布不自动安装或重启当前宿主。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feng0531/dsh-code-review",
-  "version": "0.87.3",
+  "version": "0.87.4",
   "private": false,
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },

package/src/project-report.mjs

@@ -1,23 +1,12 @@
 import { markdownReport } from './review.mjs';
 
-function dedupeFindings(findings) {
-  const seen = new Set();
-  const result = [];
-  for (const f of findings ?? []) {
-    const key = JSON.stringify([f.path, f.anchor, f.title, f.evidence]);
-    if (!seen.has(key)) { seen.add(key); result.push(f); }
-  }
-  return result;
-}
-
 export function renderProjectReport(report) {
   const merged = {
     ...report,
-    findings: dedupeFindings(report.findings),
+    reviewMode: 'project',
+    findings: report.findings ?? [],
     interactions: (report.batches ?? []).flatMap(b => b.interactions ?? []),
-    limitations: (report.batches ?? []).flatMap(b => b.limitations ?? []),
+    limitations: [...(report.limitations ?? []), ...(report.batches ?? []).flatMap(b => b.limitations ?? [])],
   };
-  const scope = '总体范围：' + report.coverage.completed + '/' + report.coverage.total + ' 个文件完成主审；排除 ' + report.coverage.excluded + '，阻断 ' + report.coverage.blocked + '，未完成 ' + report.coverage.pending + '。综合未完成项单独列出；主审完成不等于审核通过。';
-  const outdated = report.outdated ? '\n注意：来源已变化或无法复核，仅对应原批准快照。' : '';
-  return markdownReport(merged).replace('# Code Review 报告', '# 全项目代码审查报告') + '\n\n' + scope + outdated;
+  return markdownReport(merged).replace('# Code Review 报告', '# 全项目代码审查报告');
 }

package/src/report-findings.mjs

@@ -0,0 +1,57 @@
+import { groupDuplicateFindings } from './finding-groups.mjs';
+import { comparisonValidated } from './report-summary.mjs';
+
+const safe = value => Array.from(String(value ?? '')).map(c => {
+  if (c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127) return ' ';
+  if (c === '&') return '&amp;';
+  if (c === '<') return '&lt;';
+  if (c === '>') return '&gt;';
+  return '*_[]#|!()\\`'.includes(c) ? '\\' + c : c;
+}).join('');
+
+export function findingDisposition(finding, report = {}) {
+  const v = finding.verification;
+  const evidence = Array.isArray(v?.evidence) && v.evidence.length > 0 && v.evidence.every(e => e?.status === 'references-validated');
+  if (v?.status !== 'completed' || !evidence) return '待核实';
+  if (v.verdict === 'refuted') return '已反驳';
+  if (v.verdict !== 'supported') return '待核实';
+  if (report.mode === 'project' || report.reviewMode === 'project' || report.projectScope || finding.attribution?.causality === 'current-source-only') return '当前源码问题（复核支持）';
+  const r = v.regression;
+  if (!comparisonValidated(finding)) return '待核实';
+  return r.classification === 'introduced' ? '本次新增（复核支持）' : r.classification === 'preexisting' ? '原有问题（复核支持）' : '待核实';
+}
+
+function location(finding) {
+  const a = finding.anchor ?? {};
+  return safe(finding.path ?? '未标明文件') + (a.kind === 'line' ? ' · ' + (a.side === 'old' ? '修改前' : a.side === 'new' ? '修改后' : safe(a.side)) + '第 ' + safe(a.start) + '–' + safe(a.end) + ' 行' : a.kind === 'property' ? ' · 属性 ' + safe(a.name) : ' · 文件级');
+}
+
+export function findingsMarkdown(report) {
+  const findings = Array.isArray(report.findings) ? report.findings : [];
+  const duplicate = new Map();
+  for (const group of groupDuplicateFindings(findings)) for (const i of group.findingIndices.slice(1)) duplicate.set(i, group.findingIndices[0]);
+  const sections = new Map([['本次新增（复核支持）',[]],['当前源码问题（复核支持）',[]],['待核实',[]],['原有问题（复核支持）',[]],['已反驳',[]]]);
+  findings.forEach((f,i)=>{ if (!duplicate.has(i)) sections.get(findingDisposition(f,report)).push({f,i}); });
+  const output = ['', '## 审查发现'];
+  if (!findings.length) return [...output, '本轮没有形成问题记录；这不等于已经排除未完成范围内的问题。'];
+  output.push('以下区分复核支持、待核实和已反驳的记录；证据引用通过校验不等于运行复现或因果证明。');
+  for (const [label, items] of sections) {
+    if (!items.length) continue;
+    output.push('', '### ' + label);
+    for (const {f,i} of items) {
+      const severity = ({critical:'严重',high:'高',medium:'中',low:'低'})[f.severity] ?? safe(f.severity ?? '未分级');
+      output.push('', '#### ' + (i+1) + '. ' + safe(f.title) + '（严重程度：' + severity + '）', '- 位置：' + location(f));
+      for (const [key,title] of [['trigger','什么情况下发生'],['impact','可能造成的影响'],['evidence','已看到的依据']]) if (f[key]) output.push('- ' + title + '：' + safe(f[key]));
+      if (label === '待核实') output.push('- 尚未确定：' + safe(f.verification?.reason ?? '候选尚未完成有效的独立复核或修改前后对照，不能作为已确认缺陷。'));
+      if (label === '已反驳') output.push('- 反证结论：' + safe(f.verification?.reason ?? '复核反驳该候选；不计为待修缺陷。'));
+      if (f.attribution?.beforeBehavior) output.push('- 修改前：' + safe(f.attribution.beforeBehavior));
+      if (f.attribution?.afterBehavior) output.push('- 修改后：' + safe(f.attribution.afterBehavior));
+      if (f.suggestion) output.push('- 建议：' + safe(f.suggestion));
+      const related = [...duplicate].filter(([,first])=>first===i).map(([index])=>location(findings[index]));
+      if (related.length) output.push('- 相同证据与解释的其他位置：' + related.join('；') + '。正文合并展示，原始候选仍保留。');
+      if (f.reused || f.priorRun) output.push('- 来源：包含既往审核结果，不表示本轮重新取证。');
+      output.push('- 完整证据与判定过程：见技术附录中的候选 ' + (i+1) + '。');
+    }
+  }
+  return output;
+}

package/src/report-readability.mjs

@@ -0,0 +1,147 @@
+// Pure presentation: original report records remain authoritative and unchanged.
+const rows = value => Array.isArray(value) ? value : [];
+const escape = value => String(value ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/[\x00-\x1f\x7f]/g, ' ').replace(/[\\\x60*_{}\[\]()#+.!|~=-]/g, '\\$&');
+const brief = value => { const text = String(value ?? ''); return escape(text.length > 180 ? text.slice(0, 180) + '…（完整值见附录）' : text); };
+const html = value => String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+const stages = { primary: '主审', verification: '独立复核', synthesis: '综合', 'window-synthesis': '跨窗口综合', interaction: '跨文件综合' };
+const stage = value => Object.hasOwn(stages, value) ? stages[value] : String(value ?? '未标明阶段');
+
+function reason(record = {}) {
+  const value = typeof record === 'string' ? record : record?.failureCode ?? record?.blockCode ?? record?.code ?? record?.reason;
+  const text = String(value ?? '');
+  // Dependency state must not be relabelled as an input-budget failure.
+  if (/dependenc|primary.*incomplete|member.*incomplete|prerequisite|依赖.*未完成|主审.*未完成/i.test(text)) return '依赖的主审或前置阶段未完成';
+  if (/RETRIEVAL_ROUND_BUDGET_EXCEEDED|检索轮数|retrieval.*round.*(budget|limit)/i.test(text)) return '单阶段检索轮数达到上限（读取额度可能仍有余量）';
+  if (/READER_CALL_BUDGET_EXCEEDED|reader.*call.*(budget|limit)|读取调用.*(不足|耗尽|上限)/i.test(text)) return '阶段分配或共享读取调用次数不足';
+  if (/READER_OUTPUT_BUDGET_EXCEEDED|reader.*output.*(budget|limit)|读取.*字节|输出字节/i.test(text)) return '阶段分配或共享读取输出字节预算不足';
+  if (/input[-_ ]budget|input.*(budget|limit).*exceed|输入.*(预算|上限|超限)/i.test(text)) return '阶段输入预算不足';
+  if (/PROJECT_MODEL_CALL_LIMIT|model call budget|模型调用.*(额度不足|上限)/i.test(text)) return '模型调用额度不足';
+  if (/unsupported|not[-_ ]supported|不支持/i.test(text)) return '当前不支持此来源或操作';
+  if (text === 'exact-edit-analysis-unavailable') return '精确编辑分析不可用';
+  if (/CANCELLED|cancelled|canceled/i.test(text)) return '执行已取消';
+  if (/MODEL_TIMEOUT|timed? ?out/i.test(text)) return '阶段执行超时';
+  return text ? '未知／其他原因（完整原文见附录）' : '原因未记录（未知；不推测为预算不足）';
+}
+
+function fileReasons(file, findings) {
+  const result = [];
+  const limits = [...rows(file?.retrievalLimits), ...rows(file?.groupRetrievalLimits)];
+  const failures = rows(file?.stageFailures);
+  const hasReason = record => record != null && ['failureCode', 'blockCode', 'code', 'reason'].some(key => record[key] != null && record[key] !== '');
+  if (['pending', 'blocked', 'failed', 'cancelled', 'running'].includes(file?.status)) {
+    // A missing top-level code does not erase concrete phase/group evidence.
+    const evidence = hasReason(file) ? [file] : [...failures, ...limits].filter(hasReason);
+    result.push(...(evidence.length ? evidence : [file]).map(reason));
+  }
+  for (const failure of failures) result.push(stage(failure?.phase ?? failure?.stage) + '未完成；' + reason(failure));
+  if (file?.retrievalLimited || limits.length) {
+    result.push(...(limits.length ? limits.map(reason) : [reason(file)]));
+  }
+  if (rows(file?.windowCoverage?.pending).length) result.push('变更窗口尚未完成');
+  if (file?.continuationPending) result.push('阶段续审尚未完成');
+  for (const [key, label] of [['synthesisStatus', '跨窗口综合'], ['verificationStatus', '独立复核']]) if (file?.[key] && file[key] !== 'completed') result.push(label + '未完成');
+  if (rows(file?.reviewPasses).some(pass => pass?.status !== 'completed')) result.push('独立审查轮次尚未完成');
+  if (file?.fileId != null && findings.some(finding => finding?.fileId === file.fileId && finding?.verification?.status !== 'completed')) result.push('候选的独立复核尚未完成');
+  return [...new Set(result)];
+}
+
+function collect(report) {
+  const files = rows(report?.files), findings = rows(report?.findings);
+  const names = new Map(files.filter(file => file?.fileId != null).map(file => [file.fileId, file.path]));
+  const identity = id => names.has(id) && names.get(id) != null ? String(names.get(id)) : '未知文件身份：' + (typeof id === 'object' ? JSON.stringify(id) : String(id));
+  const paths = record => {
+    if (record == null || typeof record !== 'object') return [];
+    return [...new Set([...(record.path != null ? [String(record.path)] : []), ...(record.fileId != null ? [identity(record.fileId)] : []), ...rows(record.fileIds).map(identity)])];
+  };
+  const unfinished = files.map(record => ({ record, reasons: fileReasons(record, findings), paths: record?.path != null ? [String(record.path)] : paths(record) })).filter(item => item.reasons.length);
+  const interactions = rows(report?.interactions).filter(record => record?.status !== 'completed').map(record => ({ record, reasons: [reason(record)], paths: paths(record) }));
+  return { unfinished, interactions, limitations: rows(report?.limitations), paths };
+}
+
+function grouped(items) {
+  const groups = new Map();
+  for (const item of items) for (const label of item.reasons) {
+    if (!groups.has(label)) groups.set(label, []);
+    groups.get(label).push(item);
+  }
+  return [...groups];
+}
+
+function summary(output, label, items) {
+  if (!items.length) return;
+  output.push('- ' + label + '：' + items.length + ' 条记录。');
+  const groups = grouped(items);
+  for (const [why, members] of groups.slice(0, 6)) {
+    const paths = [...new Set(members.flatMap(member => member.paths))];
+    output.push('  - ' + brief(why) + '：' + members.length + ' 条；' + (paths.length ? paths.slice(0, 4).map(brief).join('、') + (paths.length > 4 ? '；另有 ' + (paths.length - 4) + ' 个路径／身份' : '') : '未记录文件路径／身份') + '。');
+  }
+  if (groups.length > 6) output.push('  - 另有 ' + (groups.length - 6) + ' 类原因；完整范围与原始记录见本报告限制附录。');
+}
+
+export function readabilityMarkdown(report = {}) {
+  const data = collect(report);
+  const output = ['', '## 未完成范围与原因', '以下为处理状态与限制记录数，非缺陷数；同一文件可能涉及多个阶段，限制不自动表示待审或缺陷。'];
+  summary(output, '未完成条目', data.unfinished);
+  summary(output, '跨文件综合未完成', data.interactions);
+  if (!data.unfinished.length && !data.interactions.length) output.push(report?.partial || data.limitations.length ? '- 报告仍有部分完成标记或限制；未逐项记录待续审范围，不表示全部查完。' : '- 未记录未完成条目或跨文件综合；这不是正确性证明。');
+  if (data.limitations.length) output.push('- 另有 ' + data.limitations.length + ' 条限制记录，按原文聚合保留在本报告限制附录；不将这些限制全部计入未完成范围。');
+  if (data.unfinished.length || data.interactions.length) output.push('- 以上仅列有界摘要；全部路径、身份、阶段及原始记录见本报告限制附录。');
+  output.push('', '## 下一步');
+  if (data.unfinished.length || data.interactions.length) output.push('- 先处理对应阻断／失败原因，再选择未完成条目、窗口、综合或复核阶段继续；已完成主审不能替代后续综合和独立复核。', '- 检索轮数、读取调用数、字节与输入预算是不同限制，应按实际原因调整；依赖未完成时先完成前置阶段，不据此推断输入超限。', '- 本报告不会自动续审或调用模型；再次执行需新预览并核对当前人类授权，范围或发送目的地变化时重新确认。');
+  else output.push('- 如需扩大或继续审核，请显式选择范围并核对新预览与当前人类授权；不要仅凭没有未完成记录判定通过。');
+  return output;
+}
+
+function originalDetails(output, record) {
+  output.push('<details><summary>原始记录 JSON（完整保留）</summary>', '', '<pre>' + html(JSON.stringify(record, null, 2) ?? 'null') + '</pre>', '', '</details>');
+}
+
+// Deduplicate identical records without losing their original positions or multiplicity.
+function packed(records) {
+  const entries = new Map();
+  records.forEach((record, index) => {
+    const key = JSON.stringify(record);
+    if (!entries.has(key)) entries.set(key, { record, positions: [] });
+    entries.get(key).positions.push(index);
+  });
+  return [...entries.values()];
+}
+
+export function limitationDetailsMarkdown(report = {}) {
+  const data = collect(report);
+  const output = ['', '## 限制附录', '以下按原文聚合；计数为记录数，非缺陷数，也不等于待审条目数。相同原文只展示一次，归属与重复次数聚合；折叠 JSON 保留差异字段及原始顺序。完整源报告 JSON 仍为权威记录。'];
+  const groups = new Map();
+  for (const record of data.limitations) {
+    const text = typeof record === 'string' ? record : record?.text;
+    // Prefixes distinguish a text-bearing record from an opaque legacy record.
+    const key = text == null ? 'record:' + JSON.stringify(record) : 'text:' + JSON.stringify(text);
+    if (!groups.has(key)) groups.set(key, { text, records: [] });
+    groups.get(key).records.push(record);
+  }
+  if (!groups.size) output.push('- 未记录限制原文。');
+  for (const { text, records } of groups.values()) {
+    output.push('', '### 限制（' + records.length + ' 条记录）', text == null ? '未提供限制原文' : '<pre>' + html(JSON.stringify(text)) + '</pre>');
+    const scopes = new Map();
+    for (const record of records) {
+      const paths = data.paths(record);
+      const scope = '- 范围：' + (paths.length ? paths.map(escape).join('、') : '未标明文件身份') + (record?.stage != null || record?.phase != null ? '；阶段：' + escape(stage(record.stage ?? record.phase)) : '');
+      scopes.set(scope, (scopes.get(scope) ?? 0) + 1);
+    }
+    for (const [scope, count] of scopes) output.push(scope + '；重复次数：' + count);
+    // Shared text is represented by the visible original above, not repeated in every JSON row.
+    const compact = records.map(record => typeof record === 'string' ? { type: 'string' } : record && typeof record === 'object' && record.text != null && Object.hasOwn(record, 'text') ? { type: 'object-with-shared-text', fields: Object.fromEntries(Object.entries(record).filter(([key]) => key !== 'text')) } : { type: 'original', value: record });
+    output.push('折叠记录中 object-with-shared-text 的 text、string 的原值均为本组上方完整原文；positions 为组内原始索引。');
+    originalDetails(output, packed(compact));
+  }
+  for (const [label, items] of [['未完成条目明细', data.unfinished], ['未完成跨文件综合明细', data.interactions]]) {
+    if (!items.length) continue;
+    output.push('', '### ' + label + '（' + items.length + ' 条记录）');
+    for (const item of items) output.push('- ' + (item.paths.length ? item.paths.map(escape).join('、') : '未标明文件身份') + '：' + item.reasons.map(escape).join('；'));
+    // State/reason metadata includes window IDs and pass statuses; full source and candidates already
+    // exist in the complete report JSON and must not be duplicated into this appendix.
+    const keys = ['fileId', 'path', 'groupId', 'fileIds', 'status', 'failureCode', 'blockCode', 'code', 'reason', 'stage', 'phase', 'stageFailures', 'retrievalLimited', 'retrievalLimits', 'groupRetrievalLimits', 'continuationPending', 'synthesisStatus', 'verificationStatus', 'windowCoverage', 'reviewPasses'];
+    output.push('以下仅为状态与原因元数据；源码、候选及其他完整字段见完整源报告 JSON。');
+    originalDetails(output, packed(items.map(item => Object.fromEntries(keys.filter(key => Object.hasOwn(item.record ?? {}, key)).map(key => [key, item.record[key]])))));
+  }
+  return output;
+}

package/src/report-summary.mjs

@@ -1,20 +1,12 @@
-const FILE_STATES = ['completed', 'excluded', 'blocked', 'failed', 'cancelled', 'pending'];
+const FILE_STATES = ['completed', 'excluded', 'blocked', 'failed', 'cancelled', 'pending', 'running', 'interrupted'];
 const STATUS_LABELS = { completed: '已完成', partial: '部分完成', failed: '执行失败', cancelled: '已取消', interrupted: '已中断', pending: '待执行', running: '执行中' };
-const safe = value => Array.from(String(value ?? '').slice(0, 240)).map(c => {
-  if (c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127) return ' ';
-  if (c === '&') return '&amp;';
-  if (c === '<') return '&lt;';
-  if (c === '>') return '&gt;';
-  if ('*_[]#|!()\\'.includes(c) || c.charCodeAt(0) === 96) return '\\' + c;
-  return c;
-}).join('');
 const rows = value => Array.isArray(value) ? value : [];
 const validCount = n => Number.isSafeInteger(n) && n >= 0;
 const supported = finding => finding?.verification?.status === 'completed' && finding.verification.verdict === 'supported' && rows(finding.verification.evidence).length > 0 && finding.verification.evidence.every(ref => ref?.status === 'references-validated');
 
 // Presentation consumes host-validated results; it neither re-reads sources nor
 // upgrades model verdicts, reference validation, or reuse into causal proof.
-function comparisonValidated(finding) {
+export function comparisonValidated(finding) {
   const { evidence, regression } = finding.verification ?? {};
   if (regression?.status !== 'comparison-references-validated' || !Array.isArray(evidence)) return false;
   const old = regression.oldEvidence, fresh = regression.newEvidence;
@@ -25,35 +17,89 @@ function comparisonValidated(finding) {
   return old.every(i => typeof evidence[i].sourceId === 'string' && evidence[i].sourceId) && fresh.every(i => typeof evidence[i].sourceId === 'string' && evidence[i].sourceId && old.every(j => evidence[j].sourceId !== evidence[i].sourceId));
 }
 
-export function reportSummaryMarkdown(report = {}) {
+/**
+ * Pure presentation data for Markdown/Lead renderers. Counts are candidate records,
+ * not proven defects. coverage counts main-review entries (directories included in
+ * change mode); unfinished preserves every loaded entry with incomplete stages, while
+ * crossFile is separate. complete means processing finished, never release approval.
+ * Returned objects/arrays are newly allocated and contain no raw model/source text.
+ */
+export function reportSummaryData(report = {}) {
   const findings = rows(report.findings), files = rows(report.files);
+  const project = report.mode === 'project' || report.reviewMode === 'project' || Boolean(report.projectScope);
   const counts = { introduced: 0, unresolved: 0, refuted: 0, preexisting: 0, current: 0 };
   for (const finding of findings) {
     const verification = finding?.verification;
     if (verification?.status === 'completed' && verification.verdict === 'refuted' && rows(verification.evidence).length && verification.evidence.every(ref => ref?.status === 'references-validated')) counts.refuted++;
     else if (!supported(finding)) counts.unresolved++;
-    else if (report.reviewMode === 'project' || report.projectScope || finding.attribution?.causality === 'current-source-only') counts.current++;
+    else if (project || finding.attribution?.causality === 'current-source-only') counts.current++;
     else if (comparisonValidated(finding) && verification.regression.classification === 'introduced') counts.introduced++;
     else if (comparisonValidated(finding) && verification.regression.classification === 'preexisting') counts.preexisting++;
     else counts.unresolved++;
   }
   const coverage = Object.fromEntries(FILE_STATES.map(status => [status, validCount(report.coverage?.[status]) ? report.coverage[status] : files.filter(f => f?.status === status).length]));
-  const total = validCount(report.coverage?.total) ? report.coverage.total : files.length;
-  const unfinished = files.filter(file => !['completed', 'excluded'].includes(file?.status) || rows(file.stageFailures).length || file.retrievalLimited || rows(file.windowCoverage?.pending).length || file.synthesisStatus && file.synthesisStatus !== 'completed' || file.verificationStatus && file.verificationStatus !== 'completed' || rows(file.reviewPasses).some(pass => pass?.status !== 'completed') || findings.some(finding => finding?.fileId === file.fileId && finding?.verification?.status !== 'completed'));
-  const incompleteInteractions = rows(report.interactions).filter(item => item?.status !== 'completed');
-  const output = ['', '## 结论摘要', '- 整体状态：' + (STATUS_LABELS[report.status] ?? '未知') + '；完成状态只表示处理进度，不表示代码正确。',
-    '- 已确认新增（独立复核支持、旧新对照引用已校验）：' + counts.introduced + '；未决／证据不足：' + counts.unresolved + '；已反驳候选：' + counts.refuted + '；既有问题（复核支持且旧新对照已校验）：' + counts.preexisting + '。'];
-  if (counts.current) output.push('- 当前源码复核支持：' + counts.current + '；当前源码模式不评估历史新增归因，不计为已确认新增。');
-  output.push('- 以上按候选记录计数，不是去重根因数；“已确认新增”仅指模型复核支持及引用校验成立，因果解释仍未经验证，不是事实或因果证明。');
-  if (findings.some(finding => finding?.reused || finding?.priorRun)) output.push('- 含既往轮次复用发现；保留原复核来源，不表示本轮重新取证。');
-  if (report.outdated) output.push('- 注意：来源已变化或无法复核；这些结论仅对应原批准快照，不能当作当前源码结论。');
-  output.push('- 范围：' + total + ' 个文件；完成 ' + coverage.completed + '，排除 ' + coverage.excluded + '，阻断 ' + coverage.blocked + '，失败 ' + coverage.failed + '，取消 ' + coverage.cancelled + '，待审 ' + coverage.pending + '。排除／阻断不是通过。');
-  if (unfinished.length) {
-    output.push('- 关键未完成范围：' + unfinished.slice(0, 5).map(file => safe(file.path ?? '未命名文件')).join('、') + (unfinished.length > 5 ? '；另有 ' + (unfinished.length - 5) + ' 个文件，见覆盖明细。' : '；阶段和限制见覆盖明细。'));
+  const accounted = FILE_STATES.reduce((sum, status) => sum + coverage[status], 0);
+  const total = validCount(report.coverage?.total) ? report.coverage.total :
+    validCount(report.totalFiles) ? report.totalFiles : Math.max(files.length, accounted);
+  const detailsComplete = files.length >= total;
+  const unfinished = files.flatMap(file => {
+    if (file?.status === 'excluded') return [];
+    const reasons = [];
+    if (file?.status !== 'completed') reasons.push(STATUS_LABELS[file?.status] ?? '主审未完成');
+    if (rows(file?.stageFailures).length) reasons.push('阶段失败');
+    if (file?.retrievalLimited) reasons.push('取证受限');
+    if (file?.continuationPending) reasons.push('后续阶段待执行');
+    if (rows(file?.windowCoverage?.pending).length) reasons.push('窗口待审 ' + file.windowCoverage.pending.length);
+    if (file?.synthesisStatus && file.synthesisStatus !== 'completed') reasons.push('综合未完成');
+    if (file?.verificationStatus && file.verificationStatus !== 'completed' || findings.some(finding => file?.fileId != null && finding?.fileId === file.fileId && finding?.verification?.status !== 'completed')) reasons.push('复核未完成');
+    if (rows(file?.reviewPasses).some(pass => pass?.status !== 'completed')) reasons.push('审查轮次未完成');
+    return reasons.length ? [{ path: String(file?.path ?? '未命名条目'), reasons }] : [];
+  });
+  const interactions = rows(report.interactions);
+  const crossFile = { total: interactions.length, completed: interactions.filter(item => item?.status === 'completed').length, pending: interactions.filter(item => item?.status !== 'completed').length };
+  const stages = Object.fromEntries(['pending', 'running', 'stopped'].map(status => [status, validCount(report.stageContinuation?.[status]) ? report.stageContinuation[status] : 0]));
+  const unverifiedCandidates = findings.filter(finding => finding?.verification?.status !== 'completed').length;
+  coverage.unaccounted = Math.max(0, total - accounted);
+  const complete = report.status === 'completed' && detailsComplete && total > 0 && coverage.completed > 0 &&
+    !unfinished.length && !crossFile.pending && !Object.values(stages).some(Boolean) && !unverifiedCandidates && !coverage.unaccounted &&
+    !FILE_STATES.some(status => !['completed', 'excluded'].includes(status) && coverage[status] > 0);
+  return {
+    status: typeof report.status === 'string' ? report.status : 'unknown',
+    complete, outdated: Boolean(report.outdated), emptySelection: total === 0,
+    counts: { total: findings.length, ...counts },
+    coverage: { total, loaded: files.length, detailsComplete, unit: project ? 'files' : 'change-entries', ...coverage },
+    unfinished, crossFile, stages, unverifiedCandidates,
+    limitations: rows(report.limitations).length,
+    reused: findings.some(finding => finding?.reused || finding?.priorRun),
+    currentSourceOnly: Boolean(project || findings.some(finding => finding?.attribution?.causality === 'current-source-only')),
+  };
+}
+
+export function reportSummaryMarkdown(report = {}) {
+  const data = reportSummaryData(report), { counts, coverage } = data;
+  const state = data.emptySelection ? '未选择条目，没有执行代码审核（' + (STATUS_LABELS[data.status] ?? '状态未知') + '）' :
+    data.complete ? '所选范围已查完' : '尚未查完（' + (STATUS_LABELS[data.status] ?? '状态未知') + '）';
+  const headline = state + (data.outdated ? '；报告已过期' : '') + '；' +
+    (counts.total ? '记录 ' + counts.total + ' 个候选问题' : '未记录候选问题') + '；不得据此放行。';
+  const output = ['', '## 结论摘要', '- ' + headline];
+  if (counts.total) {
+    const labels = { introduced: '复核支持本次新增', unresolved: '待核实', preexisting: '复核支持原有', refuted: '复核反驳', current: '当前源码复核支持' };
+    output.push('- 候选复核：' + Object.entries(labels).filter(([key]) => counts[key] > 0).map(([key, label]) => label + ' ' + counts[key]).join('；') + '。');
   }
-  if (incompleteInteractions.length) output.push('- 跨文件综合未完成：' + incompleteInteractions.length + ' 项；主文件完成不能替代交互覆盖。');
-  if (rows(report.limitations).length) output.push('- 已记录限制：' + report.limitations.length + ' 项；完整内容保留在限制明细，不能据空发现判定通过。');
-  if (total === 0) output.push('- 未选择文件，没有执行代码审核；不能解释为零缺陷结论。');
-  if (!findings.length) output.push(total > 0 && coverage.completed > 0 && report.status === 'completed' && !unfinished.length && !incompleteInteractions.length && !rows(report.limitations).length && !report.outdated ? '- 已审范围内没有候选问题记录；不证明不存在缺陷。' : '- 当前没有候选问题记录；执行状态、未完成范围或限制不支持“审核通过”。');
+  const unit = coverage.unit === 'files' ? '个文件' : '个变更条目（含目录）';
+  const labels = { completed: '主审完成', excluded: '排除', blocked: '阻断', failed: '失败', cancelled: '取消', pending: '待审', running: '执行中', interrupted: '中断', unaccounted: '状态未记账' };
+  output.push('- 覆盖：' + coverage.total + ' ' + unit + '；' + Object.entries(labels).filter(([key]) => coverage[key] > 0).map(([key, label]) => label + ' ' + coverage[key]).join('，') + (coverage.total ? '。' : '未执行。'));
+  if (!coverage.detailsComplete) output.push('- 明细仅 ' + coverage.loaded + '/' + coverage.total + ' 项；未加载条目的路径与阶段状态未在本摘要核实。');
+  if (data.unfinished.length) output.push('- 未完成条目 ' + data.unfinished.length + '（完整范围见后文及附录）' + (coverage.detailsComplete ? '。' : '；仅计已加载明细。'));
+  if (Object.values(data.stages).some(Boolean)) output.push('- 后续阶段：待执行 ' + data.stages.pending + '，执行中 ' + data.stages.running + '，已停止 ' + data.stages.stopped + '。');
+  if (data.unverifiedCandidates) output.push('- 候选复核未完成：' + data.unverifiedCandidates + ' 项。');
+  if (data.crossFile.total) output.push('- 跨文件综合：完成 ' + data.crossFile.completed + '/' + data.crossFile.total + ' 项；未完成 ' + data.crossFile.pending + ' 项。');
+  if (data.limitations) output.push('- 已记录限制：' + data.limitations + ' 项，见限制明细。');
+  const qualifications = ['完成仅指处理进度，空发现不证明无缺陷'];
+  if (counts.total) qualifications.push('按候选记录而非去重根因计数，复核支持及引用校验不是事实或因果证明');
+  if (data.currentSourceOnly) qualifications.push('当前源码模式不评估历史新增归因');
+  if (data.reused) qualifications.push('含既往轮次复用发现，不表示本轮重新取证');
+  if (data.outdated) qualifications.push('仅对应原批准快照，不能作为当前源码结论');
+  output.push('- 技术限定：' + qualifications.join('；') + '。');
   return output;
 }

package/src/review.mjs

@@ -35,6 +35,8 @@ import { configureWireBudget, modelWireBudget } from './model-wire-budget.mjs';
 import { createEvidenceContext } from './evidence-context.mjs';
 import { prepareInteractionRisk, consumeInteractionRisks } from './interaction-risk.mjs';
 import { reportSummaryMarkdown } from './report-summary.mjs';
+import { findingsMarkdown } from './report-findings.mjs';
+import { readabilityMarkdown, limitationDetailsMarkdown } from './report-readability.mjs';
 import { validateGroupInteraction } from './group-interaction.mjs';
 import { stageKey } from './review-stage-state.mjs';
 import { createStageGenerationCache } from './stage-generation-cache.mjs';
@@ -852,7 +854,7 @@ function renderFinding(output, finding, index, duplicates) {
   }
 
 export function markdownReport(report) {
-  const output = ['# Code Review 报告', '', '状态：' + report.status, '快照：' + report.snapshotId, ...reportSummaryMarkdown(report), '', '## 审查发现'];
+  const output = ['# Code Review 报告', ...reportSummaryMarkdown(report), ...findingsMarkdown(report), ...readabilityMarkdown(report), '', '## 技术附录', '', '<details>', '<summary>展开完整证据、逐项覆盖与执行诊断（不影响上面的结论）</summary>', '', '状态：' + safe(report.status), '快照：' + safe(report.snapshotId), '', '## 候选原始证据与判定'];
   if (!report.findings.length) output.push(report.status === 'completed' ? '在已审查范围内未发现具体问题；不代表代码已被证明正确。' : '当前没有有效问题记录，但审查存在未完成项或限制，不能视为通过。');
   const duplicates = new Map();
   for (const group of groupDuplicateFindings(report.findings)) for (const index of group.findingIndices.slice(1)) duplicates.set(index, group.findingIndices[0]);
@@ -861,7 +863,7 @@ export function markdownReport(report) {
   if (report.callerDiscovery) output.push('- 引用方发现：扫描 '+report.callerDiscovery.scanned.length+' 个文件，捕获 '+report.callerDiscovery.capturedPaths.length+' 个上下文；仅批准目录字面引用导航，不证明函数调用或完整覆盖。');
   if(report.businessRequirement)output.push('- 业务需求：SHA256 '+safe(report.businessRequirement.hash)+' · '+report.businessRequirement.bytes+' bytes；不可信约束，不是证据或权限，全文不在报告重复。');
   for (const file of report.files) for (const correction of file.anchorCorrections ?? []) output.push('- 定位纠正：' + safe(correction.originalCandidate.fileId) + ' · ' + safe(correction.status) + ' · ' + safe(correction.reason) + '；原完整候选保留JSON，仅定位不证明因果');
-  if (report.history) output.push('- Git历史审查：' + safe(report.history.mode) + ' · ' + safe(report.history.base ?? 'empty') + ' → ' + safe(report.history.target) + '；精确端点树差异，重命名按增删，不含工作树');
+  if (report.history) output.push('- ' + (String(report.history.mode).startsWith('svn') ? 'SVN' : 'Git') + '历史审查：' + safe(report.history.mode) + ' · ' + safe(report.history.base ?? 'empty') + ' → ' + safe(report.history.target) + '；精确端点树差异，重命名按增删，不含工作树');
   if (report.changeScope) output.push('- Git审查范围：' + safe(changeScopeLabel(report.changeScope)) + '；其他范围未审查，未跟踪文件仍默认排除。');
   if (report.businessGrouping) output.push('- 业务分组：' + safe(report.businessGrouping.status) + (report.businessGrouping.reason ? ' — ' + safe(report.businessGrouping.reason) : '') + '；仅调度假设，不证明依赖或覆盖');
   for (const file of report.files) for (const plan of file.riskPlans ?? []) output.push('- 风险计划：' + safe(file.path) + ' · ' + safe(plan.status) + (plan.method === 'inline' ? '（合并主审，非独立规划）' : '') + ' · ' + plan.risks.length + '项待证假设；不表示缺陷成立或覆盖完成');
@@ -880,6 +882,6 @@ export function markdownReport(report) {
   if (report.rules?.length) output.push('', '## 项目规则', '规则仅为已批准约束数据，不扩大权限或证明缺陷。', ...report.rules.map(rule => '- ' + safe(rule.path) + ' · SHA256 ' + safe(rule.hash)));
   if (report.followup?.suggestedPaths.length) output.push('', '## 后续选择建议', '仅为原快照未完成项；不会自动续审。再次执行需新预览、新审批，并显式选择规则和上下文。阻断项需先处理原因；关联上下文不等于主文件已审查。', ...report.followup.items.filter(item => item.followup).map(item => '- ' + safe(item.path) + '：' + item.status + (item.incompleteVerification ? '（候选复核未完成）' : '')));
   output.push(...diagnosticsMarkdown(report.diagnostics));
-  if (report.limitations.length) output.push('', '## 限制', ...report.limitations.map(l => '- ' + safe(l.text)));
+  output.push(...limitationDetailsMarkdown(report), '', '</details>');
   return output.join('\n') + '\n';
 }