@feng0531/dsh-code-review 0.87.3 → 0.87.5

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 本文件介绍对使用者有意义的变化。安装与参数见 [README](README.md)，本次发布正文见 [发布说明](RELEASE-NOTES.md)。历史提交和安装包保留在 [GitHub Releases](https://github.com/f-e-n-g-0531/dsh-code-review/releases)；本文不把开发日志当作功能介绍。
 
+## 0.87.5 — 主审优先与依赖感知续审
+
+- 先完成所有文件的主审扫描，再执行跨窗口／跨文件综合，避免后续分析在尚有文件未主审时抢先消耗模型调用；继续保留有限续跑、原截止时间和完整覆盖分母。
+- 读取恢复按当前真实就绪阶段排队，跳过依赖未满足的队头；首次精确请求可利用自身保留额度或缓存恢复，不释放其他阶段保留额、不重置总账或检索轮数。
+- 跟进取证输入超限时只移除重复初始源码正文，保留精确编辑、风险／调用线索与已交付证据回执；避免大文件重复正文挤掉新读证据。
+- 未完成原因从阶段关联回文件和报告，保留依赖、分配等待、超时、调用上限与尝试状态；一个阶段受限不再阻止其他健康阶段保留生成。仍受限时明确 partial，不把评论、候选或报告收尾当作审核完成。
+
+## 0.87.4 — 默认交付人能读懂的审核报告
+
+- 默认主文先给是否查完、问题卡、未完成原因和下一步；完整证据与执行台账移到同一报告折叠附录，不要求使用者手动拼接批次。
+- 按原文聚合限制并保留归属和记录；区分轮数、读取分配／共享额度、输入预算及依赖，空发现不暗示通过。
+- 严格区分复核支持、待核实、原有和已反驳；保留项目冲突候选及分页／过期／复用限制，修正 SVN 历史标签。仅本地呈现，不改变 JSON、取证或证据门槛。
+
 ## 0.87.3 — 明确审核指令不再重复确认
 
 - 明确要求审核且内部预览与当前授权范围、模型及发送目的地一致时，工具指导直接继续执行，不再要求第二次人工确认；仅预览或超出授权时仍暂停。

package/DEVELOPMENT.md

@@ -32,6 +32,14 @@
 
 运行 `node scripts/changes-speed-benchmark.mjs [baseline-directory]` 比较真实 review 入口上的 8 文件 SVN 受控候选/反驳夹具，包含 receipt 复核与最终精确原文校验；每次模型响应模拟 20ms。可先将冻结版本的 src 解包到独立目录作为 baseline。比较调用数、峰值并发和原文证据，不把离线计时或 mock 结论一致当作真实质量、token 成本或 45→12 分钟保证。`model-start/model-end` 检查点只记录计时、字节、状态及阶段，不写入源码或推理；各文件 `modelMetrics` 是提供方实际调用（含纠错）累计时间，并行时不可相加当作墙钟耗时。
 
+### 主审优先与依赖感知恢复
+
+启用 `enableStageContinuation` 时，跨窗口／跨文件综合先登记为依赖阶段，待全体文件主审扫描后由 continuation 运行；独立复核可在主审链内进行，受限后进入同一有界队列。读取恢复传入完整当前 ready allocation IDs，跳过依赖未就绪队头但不释放其 floor；首次精确请求可无 release 尝试自身可负担成本，实际 admission 计次，同 revision 无进展不忙重试。未知成本的 scalar admission 仍要求容量释放，不声称它足以支付任意 verifier 预取。
+
+跟进输入超限时只瘦身重复的原始 source text，保留完整编辑／元数据和已读取证据；既有窗口／综合的元数据也不再为压缩而删除。原始输入、当前接收的证据、独立复核与历史复用保持不同信任层。阶段限制按当前生成判定，不用文件曾经受限的 sticky 标记阻止健康阶段缓存；文件总体受限和不完整窗口仍阻止完成。
+
+`continuation.units` 保存真实 pendingReason、依赖与尝试；报告按 fileIds 关联并在附录保留完整身份。模型额度、超时、依赖阻断和读取分配等待不互相冒充。预算仍有余额不保证所有保护中的阶段可运行，全体大请求超过各自 floor 时不偷取其他阶段保留额，仍保留 partial。
+
 ### 大上下文回归与纠正记账
 
 正式变更入口默认 `focusPrimaryContext:true`，纯准备阶段只附带直接关系、C#和调用方线索对应的完整批准上下文对象，序列化最多16KiB／输入四分之一，稳定原顺序保留新旧版本对象。其余来源保留批准目录按需读；不会因缺少检索能力隐藏正文。底层API默认false，设置false可回退。主文件、规则与需求不删减；即使旧输入能容纳整批上下文，也应用该附带上限。
@@ -86,6 +94,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：“将本次报告保存到我指定的位置”。插件本身不会自动在业务仓库创建报告文件。
 
@@ -237,9 +239,9 @@ Git / SVN 历史审查也能使用这些参数；依赖和调用方按对应版
 
 重启后可按原jobId读回保存记录，原运行标记interrupted，不自动继续外发。recovery给出已观察文件/窗口与未完成路径；它不是完整分母或新授权；宿主重启及自动恢复本身不授权外发，补审必须有当前明确授权并重新预览核对。新预览的runtime包含实际加载版本和模块位置，排查不同工作区时分别核对，不根据另一台机器推断。
 
-变更审查的独立文件链默认最多 2 条并行；配置 `changesConcurrency` 为 1～4（1 回退串行），跨文件综合等待相关前置主审结束。配置 `maxRetrievalRounds` 为 0～50，默认为 3，限制每阶段检索请求回合数（不是成功读取次数；非法请求也会消耗回合）（0 只允许最终答复）。配置不是 preview 参数，不改变模型或来源授权；并发仍共享同一份读取/调用预算，额度不足时完成顺序可能影响哪些任务未完成，不能保证与串行逐项结果相同。提供方限流时应降低并发。复核可预取批准快照中候选锚点附近的同侧原文，仍允许追加反证读取并逐字校验；不复用主审结论或其他会话凭据。完整变更计划可容纳时仅生成一次再分发到窗口，否则保留原分窗口计划并在预览估算中体现。
+变更审查的独立文件链默认最多 2 条并行；配置 `changesConcurrency` 为 1～4（1 回退串行），启用阶段续审时先扫描全体文件主审，再调度跨窗口／跨文件综合；恢复队列按真实依赖就绪情况排队，保留其他阶段的读取最低份额。配置 `maxRetrievalRounds` 为 0～50，默认为 3，限制每阶段检索请求回合数（不是成功读取次数；非法请求也会消耗回合）（0 只允许最终答复）。配置不是 preview 参数，不改变模型或来源授权；并发仍共享同一份读取/调用预算，额度不足时完成顺序可能影响哪些任务未完成，不能保证与串行逐项结果相同。提供方限流时应降低并发。复核可预取批准快照中候选锚点附近的同侧原文，仍允许追加反证读取并逐字校验；不复用主审结论或其他会话凭据。完整变更计划可容纳时仅生成一次再分发到窗口，否则保留原分窗口计划并在预览估算中体现。
 
-大文件超出单次输入时按原行号分段。精确差异算不出时使用明确标注的包络，可能包含未变行，不声称精确归因。完整结束但 JSON 语法无效时会按当前阶段 schema 最多请求两次明确纠正，记录额外调用；检索请求非法时整批不执行并明确纠正，回填采用可追溯的滚动工作集、必要时延后重复窗口正文，不虚构证据。主审与复核默认各最多 3 轮检索；到限后只允许最终答复，保留未完成范围，不把已用完预算当成审核通过。不会给错误输出补括号、猜字段或当成无缺陷。
+大文件超出单次输入时按原行号分段。精确差异算不出时使用明确标注的包络，可能包含未变行，不声称精确归因。完整结束但 JSON 语法无效时会按当前阶段 schema 最多请求两次明确纠正，记录额外调用；检索请求非法时整批不执行并明确纠正，回填采用可追溯的滚动工作集、必要时延后重复初始源码正文，保留精确编辑、风险／调用线索和已读证据回执，不虚构证据。主审与复核默认各最多 3 轮检索；到限后只允许最终答复，保留未完成范围，不把已用完预算当成审核通过。不会给错误输出补括号、猜字段或当成无缺陷。
 
 ### 显式续审与私有模型工件
 

package/RELEASE-NOTES.md

@@ -1,17 +1,19 @@
-# v0.87.3 发布说明
+# v0.87.5 发布说明
 
-## 审核授权与内部预览
+## 修复审核执行链路，而不只是整理报告
 
-明确要求审核（例如“用 dsh-code-review 审核 r7364”）且内部预览与当前授权范围、模型及发送目的地一致时，工具描述和后台预览完成提示指导 Agent 直接继续执行，不再机械要求第二次确认。只要求预览、要求等待，或范围／模型／目的地超出授权时仍须取得授权。
+先完成全体文件的主审扫描，再运行跨窗口、跨文件综合，减少后续分析挤占尚未主审文件的模型调用。续审队列按真实依赖就绪集合排队，不再让依赖未满足的 verifier 队头阻挡可运行的 primary；精确已知请求可使用自身保留容量或缓存首次恢复，不扩大共享预算。
 
-此次修复的是 Agent 工具指引与预览完成提示，不新增一键自动执行 API，也不在后台自行推断自然语言授权。Agent 仍须捕获并核对预览，再传 confirmed=true。
+跟进取证超出输入上限时，移除重复的初始源码正文，保留身份、精确编辑、调用／风险线索、已读取证据正文及回执；初始输入和可容纳的小请求不变。
 
-## 保留的安全边界
+阶段停止原因按 fileIds 关联回报告，明确区分前置依赖、读取分配等待、调用预算、超时和尝试耗尽。一个阶段的检索限制不再阻止其他健康阶段缓存已接受生成；原文件仍如实保留受限状态。
 
-服务层确认参数、一次性预览、快照新鲜度、有效期、会话／目录／模型身份、宿主工具权限及独立远端许可不变。重启、保存任务或旧批准本身不授权再次外发。私有模型工件仍需展示隐私警告并取得独立明确同意，不能借审核请求读取。
+## 参考与边界
 
-## 验证
+参考用户指定的 [Open Code Review](https://github.com/alibaba/open-code-review) 的冻结覆盖清单、结构化停止和预算耗尽后保全发现机制；核查本地 a758d9cb 与远端 5c039e815023a05a169b1240ae6b4b24c28270b6 的相关变更。采用独立实现，未复制其源码或模板。不照搬“已有评论即完成”的覆盖推断，也不将 Git merge-base 流程移植为 SVN revision 语义。
 
-补充同步／后台工具描述与终态预览提示回归测试，覆盖明确授权直接继续、仅预览不执行、超授权需询问及私有工件独立同意。发布以全量测试和四矩阵标签 CI 为门禁。
+本次不增加读取总额、不重置检索轮数或重试次数、不放宽证据与新增归因校验。Git／SVN 固定批准范围和独立复核回执仍有效；预算、超时或证据不足时仍可能 partial／uncertain。离线受控回归不是原业务 r7364 的重跑，不承诺真实模型必定查完或固定提速比例。
 
-安装与使用见 [README](README.md)，历史变化见 [变更记录](CHANGELOG.md)，发布门禁见 [开发说明](DEVELOPMENT.md)。发布不等于自动升级或重启当前桌面宿主。
+## 验证与升级
+
+新增 Git／SVN 主审优先、依赖队头阻塞、精确恢复公平性、完整阶段取证输入与停止原因关联回归，并执行全量测试和冻结标签四矩阵 CI。发布不自动安装或重启当前宿主。安装见 [README](README.md)，门禁见 [开发说明](DEVELOPMENT.md)。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feng0531/dsh-code-review",
-  "version": "0.87.3",
+  "version": "0.87.5",
   "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,191 @@
+// 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 ?? '未标明阶段');
+const reasonKeys = ['failureCode', 'blockCode', 'code', 'reason', 'pendingReason'];
+const hasReason = record => typeof record === 'string' ? record !== '' : reasonKeys.some(key => record?.[key] != null && record[key] !== '');
+const unknownReason = label => /未知|原因未记录/.test(label);
+const unitKeys = ['id', 'kind', 'fileIds', 'dependencies', 'status', 'attempts', 'pendingReason', 'stopped'];
+const unitMetadata = unit => Object.fromEntries(unitKeys.filter(key => Object.hasOwn(unit ?? {}, key)).map(key => [key, unit[key]]));
+
+function reason(record = {}) {
+  const value = typeof record === 'string' ? record : record?.failureCode ?? record?.blockCode ?? record?.code ?? record?.reason ?? record?.pendingReason;
+  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 (/STAGE_ATTEMPTS_EXHAUSTED/i.test(text)) return '阶段尝试次数达到上限（不等同于模型调用或读取额度耗尽）';
+  if (/STAGE_ALLOCATION_WAITING/i.test(text)) return '阶段等待读取分配（不代表总额度已耗尽）';
+  if (/STAGE_NO_PROGRESS/i.test(text)) return '阶段未取得进展而停止（未记录具体预算耗尽原因）';
+  if (/STAGE_INTERRUPTED/i.test(text)) return '阶段执行中断，尚待续审';
+  if (/STAGE_FAILED/i.test(text)) return '阶段执行失败';
+  if (/STAGE_TIMEOUT/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, units = []) {
+  const result = [];
+  const limits = [...rows(file?.retrievalLimits), ...rows(file?.groupRetrievalLimits)];
+  const failures = rows(file?.stageFailures);
+  // Compare phase-local evidence before rendering: a legacy unknown must not
+  // obscure a concrete continuation reason for that same stage. Raw values stay in the appendix.
+  const evidence = [...failures, ...limits, ...units.map(item => item.evidence)];
+  const phase = record => record?.phase ?? record?.stage ?? record?.kind;
+  const explained = record => unknownReason(reason(record)) && evidence.some(other => phase(record) != null && phase(other) === phase(record) && !unknownReason(reason(other)));
+  if (['pending', 'blocked', 'failed', 'cancelled', 'running'].includes(file?.status)) {
+    // A missing top-level code does not erase concrete phase/group evidence.
+    const causes = hasReason(file) && !explained(file) ? [file] : [...failures, ...limits].filter(record => hasReason(record) && !explained(record));
+    if (causes.length) result.push(...causes.map(reason));
+    else if (!units.length) result.push(reason(file));
+  }
+  for (const failure of failures.filter(record => !explained(record))) result.push(stage(phase(failure)) + '未完成；' + reason(failure));
+  for (const item of units.filter(item => !explained(item.evidence))) result.push(stage(item.record.kind) + '未完成；' + reason(item.evidence));
+  if (file?.retrievalLimited || limits.length) {
+    result.push(...(limits.length ? limits.filter(record => !explained(record)).map(reason) : units.length ? [] : [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 allUnits = rows(report?.continuation?.units);
+  const byId = new Map(allUnits.filter(unit => unit?.id != null).map(unit => [unit.id, unit]));
+  const completedPrimary = rows(report?.continuation?.completedPrimary);
+  const dependency = id => {
+    const unit = byId.get(id);
+    if (unit) return { ...unitMetadata(unit), paths: paths(unit) };
+    if (typeof id === 'string' && id.startsWith('primary:')) {
+      const fileId = id.slice(8);
+      return { id, kind: 'primary', fileIds: [fileId], paths: [identity(fileId)], status: completedPrimary.includes(fileId) ? 'completed' : 'pending' };
+    }
+    return { id, status: 'unknown' };
+  };
+  const units = allUnits.flatMap((record, position) => {
+    if (!record || record.status === 'completed') return [];
+    const dependencies = rows(record.dependencies).map(dependency);
+    const blocked = dependencies.some(dep => dep.status !== 'completed');
+    // An explicit reason always wins. Dependency readiness is not a call-budget signal.
+    const evidence = !hasReason(record) && blocked ? { ...record, pendingReason: 'DEPENDENCY' } : record;
+    return [{ record, position, dependencies, evidence, paths: paths(record) }];
+  });
+  const unfinished = files.map(record => {
+    const associated = record?.fileId == null ? [] : units.filter(item => rows(item.record.fileIds).includes(record.fileId));
+    return { record, reasons: fileReasons(record, findings, associated), 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, units, 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?.status === 'partial' || 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', 'pendingReason', '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]])))));
+  }
+  if (data.units.length) {
+    output.push('', '### 未完成阶段续审元数据', '按 continuation.units 原始索引保留对应阶段及依赖身份；record 为原始状态元数据，resolvedReason 仅为展示解释，不覆盖原始 pendingReason。');
+    originalDetails(output, data.units.map(item => ({ position: item.position, record: unitMetadata(item.record), paths: item.paths, resolvedReason: reason(item.evidence), dependencies: item.dependencies })));
+  }
+  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/retrieval-loop.mjs

@@ -7,16 +7,33 @@ export { RETRIEVAL_INSTRUCTIONS };
 
 function compactFollowup(input) {
   const p = JSON.parse(input);
-  if (p.windows) {
-    p.windows = p.windows.map(w => ({ ...w, old: { ...w.old, text: undefined }, new: { ...w.new, text: undefined } }));
-    p.windowBodyNotice = 'Window bodies deferred; use approved catalog read. Omitted results are not evidence.';
-  }
-  if (p.sourceMode === 'window-synthesis') {
-    for (const key of ['contextRelations', 'contextRelationNotice', 'cppCallSites', 'cppCallNotice', 'callerBindings', 'callerBindingNotice', 'windowNotice', 'defectGuidance', 'contextNotice', 'contextMode']) delete p[key];
-    if (p.changes) p.changes = { status: p.changes.status, precision: p.changes.precision, edits: p.changes.edits };
-    p.followupNotice = 'Synthesis metadata compacted; windowIndex retains original coordinates. Read approved sides for evidence.';
-  }
-  return JSON.stringify(p);
+  let removed = false;
+  const strip = (source, keys = ['text']) => {
+    if (!source || typeof source !== 'object') return;
+    for (const key of keys) if (typeof source[key] === 'string' && source[key].length) {
+      delete source[key];
+      removed = true;
+    }
+  };
+  const file = value => {
+    if (!value || typeof value !== 'object') return;
+    // Full snapshot files use left/right; windows use old/new. Never traverse
+    // arbitrary claims, exact edits, or retrieved results looking for text.
+    for (const side of ['left', 'right', 'old', 'new']) strip(value[side]);
+  };
+  const envelope = value => {
+    file(value.file);
+    for (const key of ['relatedFiles', 'files', 'windows']) {
+      if (Array.isArray(value[key])) value[key].forEach(file);
+    }
+    if (Array.isArray(value.context)) value.context.forEach(item => strip(item, ['text', 'oldText']));
+  };
+  envelope(p);
+  if (Array.isArray(p.reviews)) p.reviews.forEach(envelope);
+  if (!removed) return input;
+  p.followupSourceNotice = 'Repeated initial source bodies deferred; identity, sides and original coordinates remain. Use approved catalog reader operations for source evidence. Previously supplied bodies are not independent reads or complete coverage; deferred/omitted bodies are not evidence. Retrieved results and receipts are unchanged.';
+  const compact = JSON.stringify(p);
+  return Buffer.byteLength(compact) < Buffer.byteLength(input) ? compact : input;
 }
 
 export function retrievalRequest(request, scope, retrieved = []) {
@@ -105,7 +122,7 @@ export async function retrievalLoop(model, request, scope, { correctProtocol = f
     let parsed = pendingResponse;
     if (!parsed) {
     let { input, instructions } = nextRequest(retrieved);
-    if (correctProtocol && retrieved.length && !fits({ ...request, input, instructions })) input = compactFollowup(input);
+    if (correctProtocol && round > 0 && !fits({ ...request, input, instructions })) input = compactFollowup(input);
     if (!fits({ ...request, input, instructions })) throw new Error('Retrieval input budget exceeded');
     request.signal?.throwIfAborted();
     beforeCall();
@@ -174,7 +191,7 @@ export async function retrievalLoop(model, request, scope, { correctProtocol = f
             next.instructions = request.instructions + '\n' + RETRIEVAL_INSTRUCTIONS + FINAL_SUFFIX;
           }
           next.input = JSON.stringify(value);
-          if (correctProtocol) next.input = compactFollowup(next.input);
+          if (correctProtocol && !fits(next)) next.input = compactFollowup(next.input);
           return next;
         }, signal: request.signal,
       });
@@ -186,7 +203,7 @@ export async function retrievalLoop(model, request, scope, { correctProtocol = f
       let candidate = [...retrieved, item];
       let next = nextRequest(candidate);
       if (correctProtocol) {
-        while (retrieved.length && !fits({ ...next, input: compactFollowup(next.input) })) {
+        while (retrieved.length && !fits(next) && !fits({ ...next, input: compactFollowup(next.input) })) {
           retrieved.shift();
           await request.onProtocolEvent?.({ action: 'prior-retrieval-deferred', notice: 'Prior returned fragment no longer in current prompt; reread approved source for evidence.' });
           candidate = [...retrieved, item];

package/src/review-reader-allocation.mjs

@@ -30,24 +30,39 @@ export function createReviewReaderAllocation(root, units, { maxResumeAttempts =
     return { ...remaining, remainingCalls: Math.max(0, remaining.remainingCalls - protectedCalls), remainingOutputBytes: Math.max(0, remaining.remainingOutputBytes - protectedBytes) };
   };
   const check = (state, cost) => { const remaining = available(state); if (cost.calls > remaining.remainingCalls) fail('call'); if (cost.outputBytes > remaining.remainingOutputBytes) fail('output'); };
-  const resumeWithCost = (id, costForAttempt) => {
-    const state = states.get(id);
+  // Only the host knows dependencies. An explicit COMPLETE current ready-ID set
+  // filters FIFO opportunities, never the protected floors in available().
+  const readyIds = eligibleIds => {
+    if (eligibleIds === undefined) return null;
+    if (!(Array.isArray(eligibleIds) || eligibleIds instanceof Set) || eligibleIds.size > states.size || eligibleIds.length > states.size) throw new Error('Invalid reader resume eligibility');
+    const ready = new Set(eligibleIds);
+    if ([...ready].some(id => !states.has(id))) throw new Error('Invalid reader resume eligibility');
+    return ready;
+  };
+  const resumeWithCost = (id, costForAttempt, { eligibleIds, exact = false } = {}) => {
+    const state = states.get(id), ready = readyIds(eligibleIds);
     if (!state || state.released || !state.yielded) throw new Error('Reader allocation unit unavailable');
     if (state.resumeAttempts >= maxResumeAttempts) return { resumed: false, reason: 'READER_RESUME_ATTEMPTS_EXHAUSTED', attempts: state.resumeAttempts };
-    const head = yielded.find(key => { const row = states.get(key); return row && !row.released && row.yielded && row.resumeAttempts < maxResumeAttempts && row.yieldRevision < releaseRevision; });
-    if (head !== id || state.yieldRevision >= releaseRevision) return { resumed: false, reason: 'READER_RESUME_WAITING', attempts: state.resumeAttempts };
-    state.resumeAttempts++; state.yieldRevision = releaseRevision;
-    yielded.splice(yielded.indexOf(id), 1); yielded.push(id);
+    const waiting = () => ({ resumed: false, reason: 'READER_RESUME_WAITING', attempts: state.resumeAttempts });
+    // One first exact admission may use existing own-floor/cache capacity. Later
+    // opportunities require a release; readiness changes cannot reset this gate.
+    const opportunity = row => row.yieldRevision < releaseRevision || (exact && row.resumeAttempts === 0);
+    const head = yielded.find(key => { const row = states.get(key); return (!ready || ready.has(key)) && row && !row.released && row.yielded && row.resumeAttempts < maxResumeAttempts && opportunity(row); });
+    if (head !== id || !opportunity(state)) return waiting();
+    let failure = null;
     try {
       const cost = costForAttempt();
       if (!cost || !Number.isSafeInteger(cost.calls) || cost.calls < 0 || !Number.isSafeInteger(cost.outputBytes) || cost.outputBytes < 0) throw new Error('Reader allocation preflight unavailable');
       check(state, cost);
-      state.yielded = false; state.pendingReason = null; yielded.splice(yielded.indexOf(id), 1);
-      return { resumed: true, reason: null, attempts: state.resumeAttempts };
     } catch (error) {
       if (!['READER_CALL_BUDGET_EXCEEDED', 'READER_OUTPUT_BUDGET_EXCEEDED'].includes(error?.code)) throw error;
-      return { resumed: false, reason: error.code, attempts: state.resumeAttempts };
+      failure = error.code;
     }
+    state.resumeAttempts++; state.yieldRevision = releaseRevision;
+    yielded.splice(yielded.indexOf(id), 1);
+    if (failure) { yielded.push(id); return { resumed: false, reason: failure, attempts: state.resumeAttempts }; }
+    state.yielded = false; state.pendingReason = null;
+    return { resumed: true, reason: null, attempts: state.resumeAttempts };
   };
   const scopes = new Map();
   return Object.freeze({
@@ -99,17 +114,17 @@ export function createReviewReaderAllocation(root, units, { maxResumeAttempts =
       state.yielded = true; state.yieldRevision = releaseRevision; state.pendingReason = reason; yielded.push(id);
       return { yielded: true, attempts: state.resumeAttempts };
     },
-    resume(id, requests = []) {
+    resume(id, requests = [], { eligibleIds } = {}) {
       const state = states.get(id);
       if (!state || state.released || !state.yielded) throw new Error('Reader allocation unit unavailable');
       if (!Array.isArray(requests) || !requests.length) return { resumed: false, reason: 'READER_RESUME_REQUESTS_REQUIRED', attempts: state.resumeAttempts };
-      return resumeWithCost(id, () => root.preflight(requests));
+      return resumeWithCost(id, () => root.preflight(requests), { eligibleIds, exact: true });
     },
     // Scalar admission is only a retry opportunity, never authority to read.
     // Every actual read still goes through exact preflight and root accounting.
-    resumeBudget(id, { requiredCalls = 1, requiredOutputBytes = 1 } = {}) {
+    resumeBudget(id, { requiredCalls = 1, requiredOutputBytes = 1, eligibleIds } = {}) {
       if (![requiredCalls, requiredOutputBytes].every(value => Number.isSafeInteger(value) && value >= 0) || requiredCalls + requiredOutputBytes === 0) throw new Error('Invalid reader resume budget');
-      return resumeWithCost(id, () => ({ calls: requiredCalls, outputBytes: requiredOutputBytes }));
+      return resumeWithCost(id, () => ({ calls: requiredCalls, outputBytes: requiredOutputBytes }), { eligibleIds });
     },
     release(id) { const state = states.get(id); if (!state) return; if (state.inTransaction) throw new Error('Reader allocation transaction active'); if (!state.released) { state.released = true; releaseRevision++; } },
     summary() { const usage = root.usage(); return { units: states.size, releasedUnits: [...states.values()].filter(state => state.released).length, calls: usage.calls, outputBytes: usage.outputBytes, ...(usage.cacheHits !== undefined ? { cacheHits: usage.cacheHits } : {}) }; },

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';
@@ -194,7 +196,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
   const generationCache = createStageGenerationCache(input, options.resumeState?.stageGenerations ?? []);
   const acceptedStages = new Map(generationCache.records().filter(record => record.phase === 'primary').map(record => [record.key, { generation: record.generation, record, restored: true }]));
   const primarySuspensions = new Map(), correctedStages = new Set();
-  const deferredStages = [], yieldedUnits = new Set(), fileDeadlines = new Map(), primaryStageKeys = new Map();
+  const deferredStages = [], yieldedUnits = new Set(), queuedStageUnits = new Set(), fileDeadlines = new Map(), primaryStageKeys = new Map();
   const checkpointStages = () => {
     if (!options.enableStageContinuation) return;
     report.stageGenerations = generationCache.records().filter(record => record.phase === 'primary');
@@ -202,7 +204,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
   let readerAllocation;
   const stageScope = id => readerAllocation
     ? configureWireBudget(readerAllocation.scope(id), { nativeOutputTools: options.nativeOutputTools === true }) : scope;
-  const releaseStage = id => { if (!yieldedUnits.has(id)) readerAllocation?.release(id); };
+  const releaseStage = id => { if (!yieldedUnits.has(id) && !queuedStageUnits.has(id) && !deferredStages.some(stage => !stage.done && stage.allocationId === id)) readerAllocation?.release(id); };
   const contextSeeds = (reader, request, existing = [], buildRequest = records => retrievalRequest(request, reader, records)) => {
     if (!evidenceContext || !reader || maxRetrievalRounds === 0) return [];
     const payload = JSON.parse(request.input), catalog = reader.catalog();
@@ -280,7 +282,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
     }
     if (signal?.aborted) { state.status = 'cancelled'; state.reason = '用户取消'; return; }
     const assignedGroup = [...groupPrepared].find(([, value]) => value.fileIds.includes(file.id));
-    if (!assignedGroup && (report.modelCalls >= maxCalls || options.remainingCalls?.() <= 0)) { state.reason = '模型调用预算耗尽'; return; }
+    if (!assignedGroup && (report.modelCalls >= maxCalls || options.remainingCalls?.() <= 0)) { state.reason = '模型调用预算耗尽'; state.failureCode = 'PROJECT_MODEL_CALL_LIMIT'; return; }
     const prepared = preparePrimaryInput(input, file, { instructions, scope, grouping: report.grouping, maxInputBytes, riskPlanningMode: options.riskPlanningMode, focusPrimaryContext: options.focusPrimaryContext === true, enableRiskPlanning: options.enableRiskPlanning, skipSmallRiskPlans: options.skipSmallRiskPlans });
     const { changes, payload } = prepared;
     Object.assign(state, prepared.metadata);
@@ -298,8 +300,9 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
         if (report.modelCalls >= maxCalls) throw new Error('Model call budget exceeded');
         report.modelCalls++;
       };
-      let activeReader = scope, activeStage = 'primary';
+      let activeReader = scope, activeStage = 'primary', activeStageLimited = false;
       const onBudgetLimited = info => {
+        activeStageLimited = true;
         if (activeStage !== 'primary') (state.secondaryRetrievalLimits ??= []).push({ phase: activeStage, ...info });
         state.retrievalLimited = true;
         (state.retrievalLimits ??= []).push(info);
@@ -402,6 +405,22 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
         const phase=batch.interaction?'file-interaction':batch.synthesis?'window-synthesis':'primary';
         try{
         activeStage = phase;
+        activeStageLimited = phase === 'primary' && !!groupedGeneration?.groupLimits?.length;
+        // Seal the complete primary sweep before spending reads on secondary synthesis.
+        // A scheduled dependency is not a reader failure and does not consume a retry.
+        if (options.enableStageContinuation && !retry && (batch.synthesis || batch.interaction)) {
+          if (!deferredStages.some(stage => stage.key === key)) deferredStages.push({
+            key, allocationId, fileId: file.id, phase: batch.synthesis ? 'synthesis' : 'interaction',
+            fileIds: batch.interaction?.fileIds ?? [file.id], attempts: 0, requests: [], reason: 'STAGE_DEPENDENCY_PENDING',
+            run: () => invoke(next => executeStage(batch, batchIndex, next, true), { instructions, input: payload }, timeoutMs > 0 ? Math.max(1, fileDeadlines.get(file.id) - performance.now()) : 0, signal),
+          });
+          queuedStageUnits.add(allocationId);
+          if (options.enableVerification) queuedStageUnits.add('verification:' + file.id);
+          if (batch.synthesis) state.continuationPending = true;
+          if (batch.synthesis) state.synthesisStatus = 'pending';
+          if (batch.interaction) Object.assign(report.interactions.find(item => item.groupId === batch.interaction.id), { status: 'pending', reason: 'STAGE_DEPENDENCY_PENDING' });
+          return;
+        }
         if (options.enableStageContinuation && (batch.synthesis || batch.interaction) && (batch.interaction?.fileIds ?? [file.id]).some(id => deferredStages.some(stage => stage.fileId === id && stage.phase === 'primary' && !acceptedStages.has(stage.key)))) {
           defer(Object.assign(new Error('Stage is waiting for accepted primary generations'), { code: 'READER_CALL_BUDGET_EXCEEDED' })); return;
         }
@@ -558,7 +577,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
         }
         request.signal.throwIfAborted();
         if(rounds>1)generated.findings.forEach(f=>{f.reviewRound=batch.round;});
-        if (options.enableStageContinuation && !priorStage && !state.retrievalLimited) {
+        if (options.enableStageContinuation && !priorStage && !activeStageLimited) {
           const record = { key, fileId: file.id, phase, round: batch.round, windowIds: batch.windowIds ?? [], ...(batch.interaction ? { groupId: batch.interaction.id } : {}), generation: { findings: structuredClone(generated.findings), limitations: structuredClone(generated.limitations) } };
           const admission = generationCache.admit(record);
           if (admission.accepted) {
@@ -605,19 +624,19 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
           }
         }
         if (acceptedStages.has(key)) acceptedStages.get(key).completed = !options.enableVerification || generated.findings.every(finding => finding.verification?.status === 'completed');
-        if (batch.synthesis) state.synthesisStatus = 'completed';
+        if (batch.synthesis) state.synthesisStatus = activeStageLimited ? 'pending' : 'completed';
         if (batch.interaction) {
           const interaction=report.interactions.find(p => p.groupId === batch.interaction.id);
           if (combinedInteraction) Object.assign(interaction, { method: 'group-primary-validated-channel', channelGroupId: combinedInteraction.groupId });
-          if(rounds>1){interaction.completedRounds??=[];interaction.completedRounds.push(batch.round);interaction.reviewRounds=rounds;}
-          if(batch.round===rounds)interaction.status='completed';
+          if(rounds>1){interaction.completedRounds??=[];if(!activeStageLimited)interaction.completedRounds.push(batch.round);interaction.reviewRounds=rounds;}
+          if(batch.round===rounds) { interaction.status = activeStageLimited || rounds > 1 && new Set(interaction.completedRounds).size !== rounds ? 'pending' : 'completed'; if (activeStageLimited) interaction.reason = state.secondaryRetrievalLimits?.at(-1)?.code ?? 'STAGE_FAILED'; }
         }
         if (state.windowCoverage && batch.round === 1) {
           state.windowCoverage.completed.push(...batch.windowIds);
           state.windowCoverage.pending = state.windowCoverage.pending.filter(id => !batch.windowIds.includes(id));
         }
         if(rounds>1)state.reviewPasses[batchIndex].status='completed';
-        if (retry) { const pending = deferredStages.find(stage => stage.key === key); if (pending) pending.succeeded = !options.enableVerification || generated.findings.every(finding => finding.verification?.status === 'completed'); }
+        if (retry) { const pending = deferredStages.find(stage => stage.key === key); if (pending) { pending.succeeded = !activeStageLimited && (!options.enableVerification || generated.findings.every(finding => finding.verification?.status === 'completed')); if (activeStageLimited) pending.reason = state.retrievalLimits?.at(-1)?.code ?? 'STAGE_FAILED'; } }
         await options.onProgress?.({stage:'window-complete',snapshotId:input.id,fileId:file.id,path:file.path,windowIds:batch.windowIds,round:batch.round,findings:generated.findings,windowCoverage:state.windowCoverage});
         }catch(error){
           enclosingRequest.signal.throwIfAborted();
@@ -738,7 +757,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
   }, dependencies, fileConcurrency);
   if (options.enableStageContinuation === true && deferredStages.length && !signal.aborted) {
     const primaryDone = input.files.filter(file => file.eligibility === 'reviewable' && (options.resumeState?.completed?.some(row => row.fileId === file.id) || primaryStageKeys.get(file.id)?.length && primaryStageKeys.get(file.id).every(key => acceptedStages.has(key)))).map(file => file.id);
-    const units = deferredStages.map((stage, index) => ({ id: hash(stage.key), kind: stage.phase, fileIds: stage.fileIds,
+    const units = deferredStages.map((stage, index) => ({ id: hash(stage.key), kind: stage.phase, fileIds: stage.fileIds, pendingReason: stage.reason,
       dependencies: stage.phase === 'primary'
         ? deferredStages.slice(0, index).filter(other => other.phase === 'primary' && other.fileId === stage.fileId).map(other => hash(other.key))
         : stage.fileIds.flatMap(id => { const pending = deferredStages.filter(other => other.phase === 'primary' && other.fileId === id); return pending.length ? pending.map(other => hash(other.key)) : ['primary:' + id]; }) }));
@@ -751,17 +770,26 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
     }
     for (let pass = 0; pass < 2; pass++) {
       let progressed = false;
-      for (const stage of deferredStages) {
+      for (const stage of [...deferredStages].sort((a, b) => (a.phase === 'primary' ? 0 : a.phase === 'verification' ? 1 : 2) - (b.phase === 'primary' ? 0 : b.phase === 'verification' ? 1 : 2))) {
         if (stage.done || !continuation.ready().some(unit => unit.id === hash(stage.key))) continue;
-        if (performance.now() >= fileDeadlines.get(stage.fileId) || signal.aborted || report.modelCalls >= maxCalls) { continuation.stop(hash(stage.key), 'STAGE_NO_PROGRESS'); continue; }
-        const admitted = !yieldedUnits.has(stage.allocationId) ? { resumed: true } : stage.requests.length ? readerAllocation.resume(stage.allocationId, stage.requests) : readerAllocation.resumeBudget(stage.allocationId);
-        if (!admitted.resumed) continue;
+        if (performance.now() >= fileDeadlines.get(stage.fileId) || signal.aborted || report.modelCalls >= maxCalls || options.remainingCalls?.() <= 0) {
+          stage.reason = signal.aborted ? 'STAGE_CANCELLED' : performance.now() >= fileDeadlines.get(stage.fileId) ? 'STAGE_TIMEOUT' : 'PROJECT_MODEL_CALL_LIMIT';
+          continuation.stop(hash(stage.key), stage.reason); continue;
+        }
+        const eligibleIds = [...new Set(deferredStages.filter(candidate => !candidate.done && continuation.ready().some(unit => unit.id === hash(candidate.key))).map(candidate => candidate.allocationId))];
+        const admitted = !yieldedUnits.has(stage.allocationId) ? { resumed: true } : stage.requests.length ? readerAllocation.resume(stage.allocationId, stage.requests, { eligibleIds }) : readerAllocation.resumeBudget(stage.allocationId, { eligibleIds });
+        if (!admitted.resumed) { stage.reason = ['READER_CALL_BUDGET_EXCEEDED', 'READER_OUTPUT_BUDGET_EXCEEDED'].includes(admitted.reason) ? admitted.reason : 'STAGE_ALLOCATION_WAITING'; continue; }
         yieldedUnits.delete(stage.allocationId);
+        if (!stage.allocationId.startsWith('verification:') || !deferredStages.some(other => other !== stage && !other.done && other.fileId === stage.fileId)) queuedStageUnits.delete(stage.allocationId);
         const token = continuation.start(hash(stage.key), { signal });
         stage.attempts++; await stage.run();
         progressed = true;
-        if (stage.succeeded && !yieldedUnits.has(stage.allocationId)) { stage.done = true; continuation.complete(hash(stage.key), token.attempt, { signal }); if (!deferredStages.some(other => other !== stage && !other.done && other.allocationId === stage.allocationId)) readerAllocation.release(stage.allocationId); }
-        else { continuation.yield(hash(stage.key), stage.reason); if (!yieldedUnits.has(stage.allocationId)) continuation.stop(hash(stage.key), 'STAGE_FAILED'); }
+        if (stage.succeeded && !yieldedUnits.has(stage.allocationId)) { stage.done = true; continuation.complete(hash(stage.key), token.attempt, { signal }); if (!deferredStages.some(other => other !== stage && !other.done && other.allocationId === stage.allocationId) && !queuedStageUnits.has(stage.allocationId)) readerAllocation?.release(stage.allocationId); }
+        else { const cause = stage.reason === 'STAGE_DEPENDENCY_PENDING' ? 'STAGE_FAILED' : stage.reason ?? 'STAGE_FAILED'; continuation.yield(hash(stage.key), cause); if (!yieldedUnits.has(stage.allocationId)) continuation.stop(hash(stage.key), cause); }
+        if (!deferredStages.some(other => !other.done && other.fileId === stage.fileId)) {
+          queuedStageUnits.delete('verification:' + stage.fileId);
+          releaseStage('verification:' + stage.fileId);
+        }
       }
       if (!progressed) break;
     }
@@ -769,6 +797,10 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
     for (const [id, keys] of primaryStageKeys) if (!primaryDone.includes(id) && keys.length && keys.every(key => acceptedStages.has(key))) primaryDone.push(id);
     report.stageContinuation = continuation.summary();
     report.continuation = continuation.checkpoint();
+    for (const unit of report.continuation.units) if (unit.status !== 'completed') {
+      const stage = deferredStages.find(item => hash(item.key) === unit.id);
+      if (stage?.reason && !unit.stopped) unit.pendingReason = stage.reason;
+    }
     report.continuationOptions = continuationOptions;
     for (const file of input.files) {
       const result = fileResults[input.files.indexOf(file)];
@@ -778,7 +810,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
     checkpointStages();
     await options.onResumeCheckpoint?.({ ...report, files: fileResults.map(result => result.state), findings: fileResults.flatMap(result => result.findings), limitations: [...report.limitations, ...fileResults.flatMap(result => result.limitations)] });
   }
-  for (const id of yieldedUnits) readerAllocation?.release(id);
+  for (const id of new Set([...yieldedUnits, ...queuedStageUnits])) readerAllocation?.release(id);
   if (checkpointFailed) throw checkpointFailure;
   for (const result of fileResults) if (result?.state.continuationPending === false) { const state = result.state; state.resumeEligible = state.status === 'completed' && !state.stageFailures?.length && !state.reviewPasses?.some(pass => pass.status !== 'completed') && !state.windowCoverage?.pending?.length && !state.retrievalLimited && result.findings.every(finding => finding.verification?.status === 'completed') && report.interactions.filter(item => item.fileIds?.includes(state.fileId)).every(item => item.status === 'completed'); }
   report.files = fileResults.map(result => result.state);
@@ -793,7 +825,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
   report.selection = { total: input.files.length, reviewable: reviewableCount, excluded: input.files.filter(f => f.eligibility === 'excluded').length, blocked: input.files.filter(f => f.eligibility === 'blocked').length };
   if (!reviewableCount) report.limitations.push({ text: input.files.length ? '没有可审查文件；排除或阻塞不表示代码审核通过。' : '未选择变更文件，没有执行代码审核。' });
   const unfinished = report.files.some(f => !['completed', 'excluded'].includes(f.status));
-  report.status = signal?.aborted ? 'cancelled' : unfinished || report.limitations.length ? 'partial' : 'completed';
+  report.status = signal?.aborted ? 'cancelled' : unfinished || report.limitations.length || report.stageContinuation?.pending || report.files.some(file => file.synthesisStatus && file.synthesisStatus !== 'completed') ? 'partial' : 'completed';
   if (report.files.some(f => f.status === 'failed') && !report.files.some(f => f.status === 'completed')) report.status = signal?.aborted ? 'cancelled' : 'failed';
   report.coverage = Object.fromEntries(['completed', 'excluded', 'blocked', 'failed', 'cancelled', 'pending'].map(s => [s, report.files.filter(f => f.status === s).length]));
   if (scope) {
@@ -802,7 +834,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
   }
   report.regressionCoverage = Object.fromEntries(['introduced', 'preexisting', 'uncertain', 'unassessed'].map(classification => [classification, report.findings.filter(f => (f.verification?.regression?.classification ?? 'unassessed') === classification).length]));
   report.findingGroups = groupDuplicateFindings(report.findings);
-  for (const state of report.files) state.resumeEligible = state.status === 'completed' && !state.stageFailures?.length && !state.reviewPasses?.some(pass => pass.status !== 'completed') && !state.windowCoverage?.pending?.length && !state.retrievalLimited && report.findings.filter(f => f.fileId === state.fileId).every(f => f.verification?.status === 'completed') && report.interactions.filter(item => item.fileIds?.includes(state.fileId)).every(item => item.status === 'completed');
+  for (const state of report.files) state.resumeEligible = state.status === 'completed' && !state.continuationPending && (!state.synthesisStatus || state.synthesisStatus === 'completed') && !state.stageFailures?.length && !state.reviewPasses?.some(pass => pass.status !== 'completed') && !state.windowCoverage?.pending?.length && !state.retrievalLimited && report.findings.filter(f => f.fileId === state.fileId).every(f => f.verification?.status === 'completed') && report.interactions.filter(item => item.fileIds?.includes(state.fileId)).every(item => item.status === 'completed');
   await options.onResumeCheckpoint?.(report);
   report.followup = coverageFollowup(report);
   if (scope) report.readerBudget = { ...scope.usage(), ...scope.budget(), ...readerLimits };
@@ -852,7 +884,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 +893,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 +912,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';
 }

package/src/stage-continuation.mjs

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 const KINDS = new Set(['primary', 'verification', 'synthesis', 'interaction']);
-const REASONS = new Set(['READER_CALL_BUDGET_EXCEEDED', 'READER_OUTPUT_BUDGET_EXCEEDED', 'STAGE_INTERRUPTED', 'STAGE_CANCELLED', 'STAGE_TIMEOUT', 'STAGE_NO_PROGRESS', 'STAGE_ATTEMPTS_EXHAUSTED', 'STAGE_FAILED']);
+const REASONS = new Set(['READER_CALL_BUDGET_EXCEEDED', 'READER_OUTPUT_BUDGET_EXCEEDED', 'STAGE_INTERRUPTED', 'STAGE_CANCELLED', 'STAGE_TIMEOUT', 'STAGE_NO_PROGRESS', 'STAGE_ATTEMPTS_EXHAUSTED', 'STAGE_FAILED', 'STAGE_DEPENDENCY_PENDING', 'STAGE_ALLOCATION_WAITING', 'PROJECT_MODEL_CALL_LIMIT', 'RETRIEVAL_ROUND_BUDGET_EXCEEDED', 'RETRIEVAL_FINAL_RESPONSE_REQUIRED']);
 const fail = code => Object.assign(new Error(code), { code });
 const canonical = value => Array.isArray(value) ? value.map(canonical) : value && typeof value === 'object' ? Object.fromEntries(Object.keys(value).sort().filter(key => value[key] !== undefined).map(key => [key, canonical(value[key])])) : value;
 const digest = value => createHash('sha256').update(JSON.stringify(canonical(value))).digest('hex');
@@ -15,7 +15,7 @@ export function createStageContinuation(snapshot, options, { completedPrimary =
   const primary = [...completedPrimary].sort(), states = new Map();
   for (const unit of units) {
     if (!unit || typeof unit.id !== 'string' || !unit.id || unit.id.length > 500 || states.has(unit.id) || unit.id.startsWith('primary:') || !KINDS.has(unit.kind) || !Array.isArray(unit.fileIds) || !unit.fileIds.length || new Set(unit.fileIds).size !== unit.fileIds.length || unit.fileIds.some(id => !fileIds.has(id)) || !Array.isArray(unit.dependencies ?? []) || new Set(unit.dependencies ?? []).size !== (unit.dependencies ?? []).length) throw fail('INVALID_STAGE_UNIT');
-    states.set(unit.id, { id: unit.id, kind: unit.kind, fileIds: [...unit.fileIds], dependencies: [...(unit.dependencies ?? [])], status: 'pending', attempts: 0, pendingReason: null, stopped: false });
+    states.set(unit.id, { id: unit.id, kind: unit.kind, fileIds: [...unit.fileIds], dependencies: [...(unit.dependencies ?? [])], status: 'pending', attempts: 0, pendingReason: REASONS.has(unit.pendingReason) ? unit.pendingReason : null, stopped: false });
   }
   const visit = (id, visiting = new Set(), visited = new Set()) => {
     if (visited.has(id)) return;