@feng0531/dsh-code-review 0.89.0 → 0.90.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 本文件介绍对使用者有意义的变化。安装与参数见 [README](README.md)，本次发布正文见 [发布说明](RELEASE-NOTES.md)。历史提交和安装包保留在 [GitHub Releases](https://github.com/f-e-n-g-0531/dsh-code-review/releases)；本文不把开发日志当作功能介绍。
 
+## 0.90.0 — 清晰结论与有界复审闭环
+
+- 数量优先摘要、稳定候选编号与严重程度排序，分开不确定和未完成，保留全部原始证据。
+- 确定性风险投入与高风险候选独立反证，共享额度和新回执，反证失败不再记为完成；不使用多数票替代证据。
+- owned历史台账、人工处置与最多三轮关联修复链；显式差异复审可省未变主审但始终partial，默认未知依赖全新主审，取消成果不丢失。
+- 真实事件评测合同保留全部运行分母，未裁决无金标；r7364归档质量指标未知，不宣称已解决或提速。
+
 ## 0.89.0 — 超限分组的真实子智能体并行
 
 - 整体路径只有完整输入超限分组时创建真实spawn子会话，默认2组、可配1～4；同组持续上下文补读，主审全部收尾后集中复核。默认策略仍staged。

package/README.md

@@ -288,6 +288,16 @@ Git / SVN 历史审查也能使用这些参数；依赖和调用方按对应版
 
 当前仅支持 fresh 单轮 changes；多轮、旧任务恢复及 project 明确拒绝，预览显示 `resumeSupported:false`。超大完整文件显示 blocked，不截断或把差异窗口冒充全文；多批跨边界未核查保持 partial。身份、原文定位、归因、独立复核回执及来源新鲜度校验不变。默认仍为 `staged`；整体路径尚无真实业务同条件质量与耗时验收，不宜把单测调用减少当作业务问题已解决。配置由宿主插件管理方式加载，发布不会自动安装或重启宿主。
 
+## 风险投入、发现台账与复审
+
+`reviewEffort` 可选 `auto`（默认）、`quick`、`standard`、`deep`，在preview中明确。它是对批准变更的有界确定性检查，不额外调用模型规划；quick也不跳过原文、归因和独立复核。高风险线索只改变检查方向，不证明缺陷。深度模式下仅已获首轮支持的high/critical候选增加一次独立反证复核，使用新的读取回执；不把首轮结论传给第二位验证者。两次结论分歧、证据不足或反证未完成均保守处理，不按多数票升级。插件配置 `enableCounterVerification:false` 可关闭额外反证；开启状态在preview绑定。它可能增加调用和耗时，不承诺普遍提速。
+
+变更审查可在新后台preview传 `rereviewFromJobId` 接续本会话、相同仓库/模型/规则/需求政策的终态且未过期报告。每轮仍重新捕获、预览和授权；旧回执及结论不进入本轮证据。关联修复链第三轮提示重新考虑方案，第四轮拒绝；不是跨任务全局次数锁。可用 `findingOutcomes` 记录已知发现的 `fixed/refuted/intentional/deferred` 与原因，人工标记是处置声明，不证明修复。相同精确定位与缺陷主张保持台账身份，不因行号移动重复建项；未再次观察不自动关闭。
+
+默认 `rereviewScope:"full"`，未知完整依赖图时保持全新主审。明确选择 `rereviewScope:"diff-only"` 才将新旧两侧、属性和来源指纹都未变的主文件保留为未重审；本轮完整批准来源仍可检索。预览列出primary与unreviewed路径，实际省略未变主文件时报告强制partial，不能当作跨文件影响已排除或全范围通过。取消/失败终态不被partial覆盖。上述修复链和差异复审仅changes支持；project支持风险投入但不接受历史修复链参数。
+
+报告首屏先给复核支持数量和优先候选编号，分开已复核不确定与复核未完成，显示未查范围。正文按类别与严重程度展示，附录保留原候选顺序与完整证据。真实事件评测见[仓库评测说明](https://github.com/f-e-n-g-0531/dsh-code-review/blob/main/evaluation/README.md)；没有专家确认和完整实际结果时不输出命中率。
+
 ## 工具调用流程（给需要精确指定参数的人）
 
 普通使用者只需上面的对话请求，不必手工构造 ID。需要精确控制时，让 Agent 按下列顺序调用：

package/RELEASE-NOTES.md

@@ -1,17 +1,15 @@
-# v0.89.0 发布说明
+# v0.90.0 发布说明
 
-## 真正超限后，分组由子智能体并行处理
+## 报告、收敛复审、风险投入与真实事件评测统一优化
 
-整体路径保持能装下就整体主审；只有完整输入超限形成多个组时，使用宿主真实spawn子智能体，`wholeScopeConcurrency` 默认2、可设1～4。每组一个独立Session和持续上下文，补读使用原会话，不把普通ctx.llm并发包装称为子智能体。全部主审收尾后仍集中独立复核；默认策略仍staged，整体路径需显式开启。
+- 结论首屏按数量说明复核支持的新增／既有／当前源码问题，分开已复核不确定和复核未完成，优先列出严重候选编号与未查范围；不把空发现等同通过。原始候选及证据保持不变。
+- 新增确定性风险投入auto/quick/standard/deep，不增加独立模型规划；quick保留严格校验。深度模式仅对首轮已支持的high/critical候选增加新回执的独立反证，不给第二验证者首轮结论；分歧保守不确定，反证失败明确incomplete，不缓存成完成。反证共用原预算、取消和来源边界，可能增加时间，不承诺提速。
+- 变更审查新增owned终态报告修复链，fresh preview与授权不可省。稳定指纹合并重复定位和缺陷主张，人工fixed/refuted/intentional/deferred仅记录处置，不证明当前状态；未再次观察不自动fixed。关联链第三轮要求step-back，第四轮拒绝，不是全局次数锁。
+- 默认全新主审。显式diff-only复审才减少完全未变文件的主审目标，批准原源仍可检索，跳过范围明确未重审，实际省略主文件时报告保持partial；未知依赖不得自动推断完整覆盖。不构造虚假历史差异，不继承旧回执或授权。取消与失败终态保留。修复链仅changes支持，project支持风险投入。
+- 新增离线真实事件评测合同：固定快照/版本/模型及预注册全部运行，专家裁决绑定实际报告摘要哈希和候选序号；未裁决不作金标，缺失／失败／partial不从分母消失。分别统计误报、有害建议、未完成和操作耗时，不以最佳一次或模型自评作为成绩。
 
-预览绑定并发数及执行方式，执行前重核宿主能力；缺失受限预设或结构化子会话能力明确拒绝，不隐藏回退。子会话只获得批准快照broker与结构化提交工具，不继承任意文件、shell、网络或递归委托能力。内部snapshot工具虽可能在父目录可见，但父会话及未绑定child在读取前拒绝。
+## 验证与未完成边界
 
-多个child共享唯一读取账本与同步模型生成尝试总账；每次实际逻辑LLM调用先校验身份、路由、工具集合与输入容量再扣账。这里统计模型生成尝试和逻辑LLM输入，不声称统计adapter内部HTTP重试或最终HTTP字节。宿主提示及历史开销可能使规划组在发送前受限，不截断完整文件掩盖。
+本轮有合同、生产服务夹具、取消／身份／预算／定位回归与实际宿主独立离线子会话兼容验收；离线子会话只验证transport，不代表新增风险或反证管线真实模型成绩。r7364公开归档确证旧0.87.9为156次调用、861.351秒及大量未完成，但缺少完整原report JSON与专家确认标签，评测保持unadjudicated、质量指标null，不重建假报告或混用新鲜快照。没有同条件真实模型质量／耗时改善结论。
 
-取消主动停止并等待子会话清理；检查点FIFO入队时冻结，存储错误中断并等待其他工作收尾，保留首个致命原因。统一报告按批准顺序汇总。多组跨边界未核查仍partial，不降低质量门槛。子会话由宿主按独立Session记录，可能含批准源码，不等同插件私有工件存储；不自动读这些会话作为审查证据。
-
-## 验证边界
-
-使用实际安装宿主的Agent/Session/Inbox/Loop/LLM/原生执行器/预设/子智能体运行时，在独立离线Context中验证file与group结构化路径：两个真实child并行，每个同id两次模型生成，中间读取批准fixture后保留上下文；只暴露snapshot与structured_output，结构化终态完成后释放，未绑定父读取拒绝。工作目录get/set、snapshot和模型提供方使用离线fixture，没有真实提供方调用、没有修改运行宿主。此证据证明执行契约，不证明真实业务质量、r7364闭环或提速。
-
-本版不自动安装、改配置或重启宿主。配置见[使用说明](README.md)，发布门禁见[开发说明](DEVELOPMENT.md)。
+本版保持只读，不自动修改／合并业务代码，不替代所需人类审批，不自动安装、改宿主配置或重启。配置见[使用说明](README.md)，正式门禁见[开发说明](DEVELOPMENT.md)，设计借鉴[Anthropic文章](https://claude.dev/blog/solving-code-review-at-anthropic/)。

package/evaluation/README.md

@@ -17,6 +17,12 @@
 
 第二条命令只读取固定合成输入，校验内容指纹并计算初始输入大小，不调用模型。输出不含源码或答案标签；它也不是宿主执行授权。
 
+## 真实事件评测合同
+
+[incident-eval.mjs](incident-eval.mjs)校验并评估外部注入的完整实际report与专家裁决，[schema](incidents.schema.json)定义固定快照／版本／模型身份、预注册全部runIds和confirmed/unadjudicated。confirmed中的reviewer与judgementRef是外部裁决声明，不是加密签名；评测器不自动确认专家身份或从模型判定推导金标。候选裁决必须绑定report精确JSON SHA256与索引。缺失、失败和partial保留所有预注册分母；未裁决或无金标时precision/recall为null，不以0冒充无缺陷。误报、有害建议、已处置与未完成分别统计。
+
+运行`node --test test/incident-eval.test.mjs`仅验证记账合同，不是业务成绩。真实业务素材、答案和原始会话保持仓库外，不进入安装包；模型输入不包含金标。当前r7364归档只验证旧调用和状态观察，缺完整report JSON与专家裁决，因此不宣称实际召回率或新版改进。任何prompt／工具／模型变化应重新运行同一组全部案例，不选最佳一次。可由现有registered-tool live runner保存新鲜预览和终态回执，再人工独立裁决；不直连provider、不自动读取私有模型工件。
+
 ## 真实模型观察
 
 已有六次小规模观察见 [试跑结果](PILOT-RESULTS.md)。其中一次证据复核未完成，其他结果也不能外推成质量指标。新评测仍后置，开始条件见 [运行条件](PILOT-GATE.md)。

package/index.mjs

@@ -10,7 +10,7 @@ export const name = 'dsh-code-review';
 export const inject = ['tools', 'llm'];
 
 const PREVIEW_DESCRIPTION = 'Preview Git/SVN working-copy or Git commit/range review scope and model destination without sending source to a model. repositoryPath selects an explicit child repository relative to session workspace; file paths are repository-relative. Each session reviews one selected repository independently; reviewMode=project selects tracked current source instead of changes; changeScope=staged or unstaged narrows a Git working-copy review to the index or to unstaged edits. Always capture and inspect the preview internally before execution. An explicit user request to review the selected code already authorizes execution within that request: proceed without asking the user to confirm the same review again. Ask only if the preview exceeds the requested scope or changes the authorized model/destination, or authorization is unclear. Never execute if the user requested preview only or explicitly asked to wait for confirmation. Preserve host tool permissions and all snapshot/identity checks.';
-const PREVIEW_PARAMETERS = { type: 'object', additionalProperties: false, properties: { resumeFromJobId: { type: 'string', description: 'Explicit terminal job to reuse identity-matching completed chains. Requires a fresh captured preview, confirmation and authorization; does not restore old approval.' }, reviewMode: {type:'string',enum:['changes','project'],description:'project reviews all tracked current files, including unchanged files, in bounded batches with shared session budget. Does not include ignored/untracked/external contents. Each DSH session owns independent preview, lock and model budget.'}, changeScope: {type:'string',enum:['worktree','staged','unstaged'],description:'Git working-copy comparison scope. worktree (default) compares HEAD to the working tree (net change); staged compares HEAD to the index so only staged content is reviewed; unstaged compares the index to the working tree so only unstaged edits are reviewed and staged content is the old side. Requires a Git working copy; mutually exclusive with Git history, SVN parameters and project mode.'}, svnReplacementBaseRevision: {type:'string',description:'Working-copy file replacement only: explicitly compare to this fixed repository revision at the target URL. Not local BASE and not proof of the removed-node revision. Requires separate remote opt-in when applicable; identity and properties frozen in preview.'}, svnReplacementAllowNetwork: {type:'boolean',description:'Explicit permission to read the selected working-copy target URL at svnReplacementBaseRevision. Does not permit arbitrary URLs, updates, merges or writes.'}, svnBasePath: {type:'string',description:'Explicit old endpoint path relative to the current SVN repository root; requires svnTargetPath and fixed revision range. Not an arbitrary URL. Same repository UUID required.'}, svnTargetPath: {type:'string',description:'Explicit new endpoint repository-relative path paired with svnBasePath. Each side content/context stays at its URL/revision; shared capture budgets and remote opt-in apply.'}, svnEffectiveMergeinfo: { type: 'boolean', description: 'Explicit SVN opt-in to bounded BASE/working or fixed-history ancestor mergeinfo property reads on each selected side. Offline for working copies; history uses existing remote permission and budgets. Mixed BASE revisions, unsafe ancestors or incomplete URL boundaries remain unknown. No branch source reads or merge attribution.' }, svnRevision: { type: 'string', description: 'SVN fixed numeric revision reviewed against revision minus one. Requires SVN working-copy root; no HEAD/date aliases.' }, svnBaseRevision: { type: 'string', description: 'SVN fixed numeric old endpoint; requires svnTargetRevision, mutually exclusive with svnRevision and Git revision parameters.' }, svnTargetRevision: { type: 'string', description: 'SVN fixed numeric new endpoint, greater than old endpoint. Fixed repository objects, not working-copy text. Supports explicitly selected target context with verified baseline provenance and target rules; explicit old-only context is also supported with fixed SVN provenance; autoContext follows at most three independent fixed-side dependency layers with bounded parent listings and shared capture budgets; callerScopePaths supports bounded fixed-side SVN historical literal discovery; only matched sides captured, never complete caller coverage.' }, svnAllowNetwork: { type: 'boolean', description: 'Explicit opt-in to read the working-copy repository URL at fixed SVN revisions during preview/execute; preview sends no source to a model. Required for non-file repository URLs; default denies remote access. Does not allow checkout/update/merge or arbitrary URLs.' }, reviewRounds: { type: 'integer', minimum: 1, maximum: 3, description: 'Explicit independent review passes, default 1. Preview discloses extra sends; later passes omit the first risk plan. Shares existing timeout, call and retrieval budgets, not provider reasoning effort. Bound to this preview; execute cannot override.' }, oldContextPaths: { type: 'array', maxItems: 20, items: { type: 'string' }, description: 'Explicit Git/SVN historical baseline-only context paths. Git uses fixed blobs; SVN uses UUID/URL/peg/operative revision/hash. Shares 20 context slots. No target text is inferred; selected old changes reuse original identity, excluded changes cannot reenter. Unsupported on working reviews.' }, callerScopePaths: { type: 'array', minItems: 1, maxItems: 4, items: { type: 'string' }, description: 'Explicit non-root repository-relative directories for bounded tracked literal reverse import/include discovery. Git/SVN working review or fixed Git/SVN historical review. SVN uses offline normal nodes, rejects unsafe ancestor states and special/keyword properties. Historical sides share scan budgets and use object blobs only. Preview reads candidate bodies, including nonmatches; only captured matching context is sent. Navigation only, not complete caller coverage.' }, businessRequirement: { type: 'string', maxLength: 16384, description: 'Optional business constraint text up to 16KiB UTF8; untrusted data, not evidence or permission. Bound to preview and sent in review phases.' }, commit: { type: 'string', description: 'Git commit versus sole parent; root empty, merge requires range.' }, baseRevision: { type: 'string', description: 'Git old endpoint; requires targetRevision, mutually exclusive with commit.' }, targetRevision: { type: 'string', description: 'Git new endpoint, exact tree endpoints not merge-base. Explicit context uses target tree with available baseline provenance; oldContextPaths is baseline-only. Historical caller discovery scans fixed sides; explicit rules use target-tree blobs.' }, repositoryPath: { type: 'string', description: 'Workspace-relative explicit child Git/SVN repository root, forward slashes; omit for current repository.' }, selectedPaths: { type: 'array', items: { type: 'string' }, maxItems: 200 }, autoContext: { type: 'boolean', description: 'Opt in to tracked literal import/include context shown in preview. Working Git follows changed and explicitly selected context sources at most 3 dependency layers under shared 512 exact probes, 20 candidates/context slots, 1MiB source and 30s verification budget. Git history follows at most 3 baseline/target dependency layers with shared limits, object reads only; SVN follows at most 3 safe offline current-side layers with exact path probes and node/ancestor identity verification, sharing limits; no SVN historical review. Not semantic binding or complete definitions.' }, contextPaths: { type: 'array', items: { type: 'string' }, maxItems: 20 }, rulePaths: { type: 'array', items: { type: 'string' }, maxItems: 4 } } };
+const PREVIEW_PARAMETERS = { type: 'object', additionalProperties: false, properties: { rereviewScope:{type:'string',enum:['full','diff-only'],description:'Changes only: explicit diff-only re-review omits unchanged primary files but retains approved retrieval context; unknown cross-file impact remains partial, never reuse old evidence. Requires rereviewFromJobId and fresh preview approval.'}, reviewEffort: {type:'string',enum:['auto','quick','standard','deep'],description:'Deterministic review effort policy; every tier retains strict evidence checks. No automatic human approval.'}, rereviewFromJobId:{type:'string',description:'Owned terminal review history for a fresh review-fix cycle; requires fresh snapshot preview and approval, never inherits old evidence or approval. Maximum three linked cycles.'}, findingOutcomes:{type:'array',maxItems:200,items:{type:'object',additionalProperties:false,properties:{id:{type:'string'},decision:{type:'string',enum:['fixed','refuted','intentional','deferred']},reason:{type:'string'}},required:['id','decision','reason']},description:'Explicit human dispositions of known historical findings; claims only, not proof of a fix. Requires rereviewFromJobId.'}, resumeFromJobId: { type: 'string', description: 'Explicit terminal job to reuse identity-matching completed chains. Requires a fresh captured preview, confirmation and authorization; does not restore old approval.' }, reviewMode: {type:'string',enum:['changes','project'],description:'project reviews all tracked current files, including unchanged files, in bounded batches with shared session budget. Does not include ignored/untracked/external contents. Each DSH session owns independent preview, lock and model budget.'}, changeScope: {type:'string',enum:['worktree','staged','unstaged'],description:'Git working-copy comparison scope. worktree (default) compares HEAD to the working tree (net change); staged compares HEAD to the index so only staged content is reviewed; unstaged compares the index to the working tree so only unstaged edits are reviewed and staged content is the old side. Requires a Git working copy; mutually exclusive with Git history, SVN parameters and project mode.'}, svnReplacementBaseRevision: {type:'string',description:'Working-copy file replacement only: explicitly compare to this fixed repository revision at the target URL. Not local BASE and not proof of the removed-node revision. Requires separate remote opt-in when applicable; identity and properties frozen in preview.'}, svnReplacementAllowNetwork: {type:'boolean',description:'Explicit permission to read the selected working-copy target URL at svnReplacementBaseRevision. Does not permit arbitrary URLs, updates, merges or writes.'}, svnBasePath: {type:'string',description:'Explicit old endpoint path relative to the current SVN repository root; requires svnTargetPath and fixed revision range. Not an arbitrary URL. Same repository UUID required.'}, svnTargetPath: {type:'string',description:'Explicit new endpoint repository-relative path paired with svnBasePath. Each side content/context stays at its URL/revision; shared capture budgets and remote opt-in apply.'}, svnEffectiveMergeinfo: { type: 'boolean', description: 'Explicit SVN opt-in to bounded BASE/working or fixed-history ancestor mergeinfo property reads on each selected side. Offline for working copies; history uses existing remote permission and budgets. Mixed BASE revisions, unsafe ancestors or incomplete URL boundaries remain unknown. No branch source reads or merge attribution.' }, svnRevision: { type: 'string', description: 'SVN fixed numeric revision reviewed against revision minus one. Requires SVN working-copy root; no HEAD/date aliases.' }, svnBaseRevision: { type: 'string', description: 'SVN fixed numeric old endpoint; requires svnTargetRevision, mutually exclusive with svnRevision and Git revision parameters.' }, svnTargetRevision: { type: 'string', description: 'SVN fixed numeric new endpoint, greater than old endpoint. Fixed repository objects, not working-copy text. Supports explicitly selected target context with verified baseline provenance and target rules; explicit old-only context is also supported with fixed SVN provenance; autoContext follows at most three independent fixed-side dependency layers with bounded parent listings and shared capture budgets; callerScopePaths supports bounded fixed-side SVN historical literal discovery; only matched sides captured, never complete caller coverage.' }, svnAllowNetwork: { type: 'boolean', description: 'Explicit opt-in to read the working-copy repository URL at fixed SVN revisions during preview/execute; preview sends no source to a model. Required for non-file repository URLs; default denies remote access. Does not allow checkout/update/merge or arbitrary URLs.' }, reviewRounds: { type: 'integer', minimum: 1, maximum: 3, description: 'Explicit independent review passes, default 1. Preview discloses extra sends; later passes omit the first risk plan. Shares existing timeout, call and retrieval budgets, not provider reasoning effort. Bound to this preview; execute cannot override.' }, oldContextPaths: { type: 'array', maxItems: 20, items: { type: 'string' }, description: 'Explicit Git/SVN historical baseline-only context paths. Git uses fixed blobs; SVN uses UUID/URL/peg/operative revision/hash. Shares 20 context slots. No target text is inferred; selected old changes reuse original identity, excluded changes cannot reenter. Unsupported on working reviews.' }, callerScopePaths: { type: 'array', minItems: 1, maxItems: 4, items: { type: 'string' }, description: 'Explicit non-root repository-relative directories for bounded tracked literal reverse import/include discovery. Git/SVN working review or fixed Git/SVN historical review. SVN uses offline normal nodes, rejects unsafe ancestor states and special/keyword properties. Historical sides share scan budgets and use object blobs only. Preview reads candidate bodies, including nonmatches; only captured matching context is sent. Navigation only, not complete caller coverage.' }, businessRequirement: { type: 'string', maxLength: 16384, description: 'Optional business constraint text up to 16KiB UTF8; untrusted data, not evidence or permission. Bound to preview and sent in review phases.' }, commit: { type: 'string', description: 'Git commit versus sole parent; root empty, merge requires range.' }, baseRevision: { type: 'string', description: 'Git old endpoint; requires targetRevision, mutually exclusive with commit.' }, targetRevision: { type: 'string', description: 'Git new endpoint, exact tree endpoints not merge-base. Explicit context uses target tree with available baseline provenance; oldContextPaths is baseline-only. Historical caller discovery scans fixed sides; explicit rules use target-tree blobs.' }, repositoryPath: { type: 'string', description: 'Workspace-relative explicit child Git/SVN repository root, forward slashes; omit for current repository.' }, selectedPaths: { type: 'array', items: { type: 'string' }, maxItems: 200 }, autoContext: { type: 'boolean', description: 'Opt in to tracked literal import/include context shown in preview. Working Git follows changed and explicitly selected context sources at most 3 dependency layers under shared 512 exact probes, 20 candidates/context slots, 1MiB source and 30s verification budget. Git history follows at most 3 baseline/target dependency layers with shared limits, object reads only; SVN follows at most 3 safe offline current-side layers with exact path probes and node/ancestor identity verification, sharing limits; no SVN historical review. Not semantic binding or complete definitions.' }, contextPaths: { type: 'array', items: { type: 'string' }, maxItems: 20 }, rulePaths: { type: 'array', items: { type: 'string' }, maxItems: 4 } } };
 const EXECUTE_DESCRIPTION = 'Execute a previewed read-only code review using the current DSH model. Sends the approved snapshot to the current Agent model under DSH tool execution policy; no separate plugin approval prompt. confirmed=true attests that the current user explicitly requested this review and the inspected preview matches that authorization; it does not require a second confirmation message. Never execute a preview-only or explicit wait-for-confirmation request, or exceed authorized scope/model/destination. Never modifies the reviewed repository.';
 const EXECUTE_PARAMETERS = { type: 'object', additionalProperties: false, properties: { previewId: { type: 'string' }, confirmed: { type: 'boolean', description: 'True only when the current user explicitly authorized this review and the inspected preview matches the requested scope/model/destination. The original explicit review request is sufficient; do not ask again for the same review. Preview-only or explicit wait-for-confirmation requests do not authorize execution.' } }, required: ['previewId', 'confirmed'] };
 
@@ -21,7 +21,7 @@ export function apply(ctx, config = {}) {
   registerSnapshotTool(ctx);
   attachReviewChildMiddleware(ctx);
   ctx.on('dispose', () => hostChildren.dispose());
-  const service = createReviewService(ctx.llm, { hostChildren, wholeScopeConcurrency: config.wholeScopeConcurrency ?? 2, executionStrategy: config.executionStrategy ?? 'staged', maxInputBytes: config.maxInputBytes ?? 96 * 1024, allowModelSending: true, nativeOutputTools: true, enableGroupPrimary: true, enableEvidenceContext: config.enableEvidenceContext ?? true, inlineInteractionRisks: config.inlineInteractionRisks ?? true, enableMigrationContracts: config.enableMigrationContracts ?? true, enableMigrationRegression: config.enableMigrationRegression ?? true, enableGroupInteractions: config.enableGroupInteractions ?? true, enableStageContinuation: config.enableStageContinuation ?? true, enableRiskPlanning: true, enableBusinessGrouping: true, enableAnchorCorrection: true, projectConcurrency: config.projectConcurrency ?? DEFAULT_PROJECT_CONCURRENCY, riskPlanningMode: config.riskPlanningMode ?? 'auto', readerBudgetPolicy: config.readerBudgetPolicy ?? 'scaled', optimizeReviewCalls: true, enablePrimarySeeds: true, focusPrimaryContext: config.focusPrimaryContext ?? true, enableSearchSeeds: config.enableSearchSeeds ?? true, changesConcurrency: config.changesConcurrency ?? 2, maxRetrievalRounds: config.maxRetrievalRounds ?? 3, authorize: async () => true });
+  const service = createReviewService(ctx.llm, { reviewEffort: config.reviewEffort ?? 'auto', enableCounterVerification: config.enableCounterVerification ?? true, hostChildren, wholeScopeConcurrency: config.wholeScopeConcurrency ?? 2, executionStrategy: config.executionStrategy ?? 'staged', maxInputBytes: config.maxInputBytes ?? 96 * 1024, allowModelSending: true, nativeOutputTools: true, enableGroupPrimary: true, enableEvidenceContext: config.enableEvidenceContext ?? true, inlineInteractionRisks: config.inlineInteractionRisks ?? true, enableMigrationContracts: config.enableMigrationContracts ?? true, enableMigrationRegression: config.enableMigrationRegression ?? true, enableGroupInteractions: config.enableGroupInteractions ?? true, enableStageContinuation: config.enableStageContinuation ?? true, enableRiskPlanning: true, enableBusinessGrouping: true, enableAnchorCorrection: true, projectConcurrency: config.projectConcurrency ?? DEFAULT_PROJECT_CONCURRENCY, riskPlanningMode: config.riskPlanningMode ?? 'auto', readerBudgetPolicy: config.readerBudgetPolicy ?? 'scaled', optimizeReviewCalls: true, enablePrimarySeeds: true, focusPrimaryContext: config.focusPrimaryContext ?? true, enableSearchSeeds: config.enableSearchSeeds ?? true, changesConcurrency: config.changesConcurrency ?? 2, maxRetrievalRounds: config.maxRetrievalRounds ?? 3, authorize: async () => true });
   ctx.tools.register({
     name: 'code_review_preview', description: PREVIEW_DESCRIPTION, parameters: PREVIEW_PARAMETERS, output: reviewToolOutput,
     async execute(args, exec) { const preview = await service.preview(args, exec); return { json: JSON.stringify(preview), markdown: '' }; },

package/package.json

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

package/src/approved-retrieval.mjs

@@ -0,0 +1,13 @@
+import { isDeepStrictEqual } from 'node:util';
+// Internal scope projection only; never an extra public source authority.
+export function approvedRetrievalSnapshot(review,approved=review) {
+  if(approved===review)return review;
+  if(!approved||review.id!==approved.id||!Array.isArray(review.files)||review.files.length!==approved.files?.length)throw new Error('Incremental source identity mismatch');
+  const expected=structuredClone(approved);
+  for(let i=0;i<review.files.length;i++){
+    const target=review.files[i],source=expected.files[i];
+    if(target.eligibility==='excluded'&&target.reason==='incremental-unchanged-not-reviewed'&&source.eligibility==='reviewable'){source.eligibility=target.eligibility;source.reason=target.reason;}
+  }
+  if(!isDeepStrictEqual(expected,review))throw new Error('Incremental projection changed approved source or metadata');
+  return structuredClone(approved);
+}

package/src/background-review.mjs

@@ -83,6 +83,7 @@ async function startBackgroundJob(args, exec, jobs, service) {
     const detached = {
       ...exec, agent: original, signal,
       resolveReviewResume: id => jobs.resume(id, exec),
+      resolvePriorReview: id => jobs.priorReview(id, exec),
       reviewResumeCheckpoint: saveResumeState,
       onModelArtifact: artifact,
       reviewCheckpoint: async value => {

package/src/counter-verification.mjs

@@ -0,0 +1,48 @@
+import { verificationLoop } from './verification-loop.mjs';
+
+const confirmed = value => value?.verdict === 'supported' && Array.isArray(value.evidence) && value.evidence.length > 0 && value.evidence.every(ref => ref?.status === 'references-validated');
+const classification = value => value?.regression?.classification;
+const comparable = value => ['introduced', 'preexisting'].includes(classification(value)) && value.regression.status === 'comparison-references-validated';
+const fatal = (error, options) => ['MODEL_ARTIFACT_FAILED', 'CHECKPOINT_FAILED', 'RESUME_CHECKPOINT_FAILED'].includes(error?.code) || options.isFatalError?.(error) === true;
+
+// Input baseline must be the just-completed strict verificationLoop result, not
+// historical findings or model-supplied verdicts. This pass grants no authority.
+export async function runCounterVerification(model, request, candidates, baseline, scope, options = {}) {
+  request.signal?.throwIfAborted();
+  if (!Array.isArray(candidates) || candidates.length > 50 || !Array.isArray(baseline) || baseline.length !== candidates.length) throw new Error('Invalid counterverification candidates or baseline');
+  if (options.enabled !== undefined && typeof options.enabled !== 'boolean') throw new Error('Invalid counterverification policy');
+  if (options.isFatalError !== undefined && typeof options.isFatalError !== 'function') throw new Error('Invalid counterverification fatal predicate');
+  const results = structuredClone(baseline);
+  if (options.enabled !== true) return results;
+  const indices = candidates.flatMap((candidate, index) => ['critical', 'high'].includes(candidate?.severity) && confirmed(baseline[index]) ? [index] : []);
+  if (!indices.length) return results;
+  const independent = indices.map(index => {
+    const value = structuredClone(candidates[index]);
+    delete value.verification;
+    delete value.counterVerification;
+    return value;
+  });
+  let counter, failureCode;
+  try {
+    counter = await verificationLoop(model, request, independent, scope, { ...options, verificationFocus: 'counterevidence', correctProtocol: false });
+    request.signal?.throwIfAborted();
+  } catch (error) {
+    request.signal?.throwIfAborted();
+    if (error?.name === 'AbortError' || fatal(error, options)) throw error;
+    // Never echo an untrusted model exception (which may contain source text).
+    failureCode = 'COUNTER_VERIFICATION_INCOMPLETE';
+  }
+  indices.forEach((index, offset) => {
+    const original = baseline[index], extra = counter?.[offset];
+    const metadata = extra ? { status: 'completed', result: structuredClone(extra), baselineResult: structuredClone(original) } : { status: 'incomplete', failureCode, baselineResult: structuredClone(original) };
+    results[index].counterVerification = metadata;
+    if (extra && confirmed(extra) && comparable(original) && comparable(extra) && classification(original) === classification(extra)) return;
+    // Preserve both independent records. Uncertainty is a conservative aggregate,
+    // not a new model verdict or evidence borrowed from the second receipt table.
+    results[index].verdict = 'uncertain';
+    results[index].reason = extra ? 'Independent counterevidence verification did not confirm the same supported classification.' : 'Independent counterevidence verification is incomplete.';
+    results[index].causality = 'unverified';
+    results[index].regression = { classification: 'uncertain', reason: results[index].reason, oldEvidence: [], newEvidence: [], causality: 'unverified' };
+  });
+  return results;
+}

package/src/finding-ledger.mjs

@@ -0,0 +1,169 @@
+import { createHash } from 'node:crypto';
+
+// Navigation and human disposition metadata only. Never a source/evidence receipt,
+// verification result, coverage certificate, approval, or permission to run again.
+const MAX_CYCLES = 3;
+const LIMIT = 10000;
+const TRUST = 'historical-metadata-not-evidence';
+const digest = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const fail = message => { throw new Error('Finding ledger: ' + message); };
+const text = value => typeof value === 'string' && value.trim().length > 0 && value.length <= 16000;
+const hash = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const record = value => value && typeof value === 'object' && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+function exact(value, keys) {
+  if (!record(value) || Reflect.ownKeys(value).some(key => typeof key !== 'string' || !keys.includes(key) || !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), 'value'))) fail('unknown or invalid fields');
+}
+function list(value) { if (!Array.isArray(value) || value.length > LIMIT) fail('invalid or excessive list'); }
+function path(value) {
+  // SVN uses the canonical repository root for directory property changes.
+  if (value === '.') return value;
+  if (!text(value) || value.includes('\\') || value.includes('\0') || value.startsWith('/') || /^[a-z]:/i.test(value) || value.split('/').some(part => !part || part === '.' || part === '..')) fail('invalid repository-relative path');
+  return value;
+}
+function identityValue(value) {
+  const keys = ['repository', 'route', 'rulesHash', 'requirementPolicyHash'];
+  exact(value, keys);
+  if (!text(value.repository) || !text(value.route) || !hash(value.rulesHash) || !hash(value.requirementPolicyHash)) fail('invalid identity');
+  return Object.fromEntries(keys.map(key => [key, value[key]]));
+}
+function sameIdentity(left, right) { if (JSON.stringify(left) !== JSON.stringify(right)) fail('identity mismatch'); }
+function freeze(value) {
+  if (value && typeof value === 'object') { for (const item of Object.values(value)) freeze(item); Object.freeze(value); }
+  return value;
+}
+function decisionValue(value) {
+  exact(value, ['decision', 'reason', 'cycle']);
+  if (!['fixed', 'refuted', 'intentional', 'deferred'].includes(value.decision) || !text(value.reason) || !Number.isInteger(value.cycle) || value.cycle < 1 || value.cycle > MAX_CYCLES) fail('invalid human decision');
+  return { decision: value.decision, reason: value.reason, cycle: value.cycle };
+}
+function validatePrevious(value, identity) {
+  exact(value, ['schemaVersion', 'identity', 'originSnapshotId', 'chainOrigin', 'cycle', 'maxCycles', 'nextAction', 'trust', 'snapshotId', 'findings']);
+  sameIdentity(identityValue(value.identity), identity);
+  if (value.schemaVersion !== 1 || value.trust !== TRUST || value.maxCycles !== MAX_CYCLES || !Number.isInteger(value.cycle) || value.cycle < 1 || value.cycle > MAX_CYCLES || !text(value.snapshotId) || !text(value.originSnapshotId) || value.chainOrigin !== digest([identity, value.originSnapshotId]) || value.nextAction !== (value.cycle === MAX_CYCLES ? 'step-back' : 'human-review')) fail('invalid chain');
+  list(value.findings);
+  const ids = new Set();
+  const findings = value.findings.map(item => {
+    exact(item, ['id', 'path', 'side', 'anchorHash', 'claimHash', 'matchable', 'firstSeen', 'lastSeen', 'observation', 'findingIndices', 'humanDecisions']);
+    path(item.path);
+    if (item.path === '.' && !['property', 'file'].includes(item.side)) fail('root findings require property or file anchor');
+    if (!hash(item.id) || ids.has(item.id) || !hash(item.anchorHash) || !hash(item.claimHash) || !['old', 'new', 'property', 'file'].includes(item.side) || typeof item.matchable !== 'boolean' || item.matchable !== (item.side !== 'file') || !['new', 'repeated', 'not-observed'].includes(item.observation) || !Number.isInteger(item.firstSeen) || !Number.isInteger(item.lastSeen) || item.firstSeen < 1 || item.lastSeen < item.firstSeen || item.lastSeen > value.cycle) fail('invalid historical finding');
+    list(item.findingIndices); list(item.humanDecisions);
+    if (item.findingIndices.some(index => !Number.isSafeInteger(index) || index < 0) || new Set(item.findingIndices).size !== item.findingIndices.length) fail('invalid finding indices');
+    const humanDecisions = item.humanDecisions.map(decisionValue);
+    if (humanDecisions.length > MAX_CYCLES || humanDecisions.some(d => d.cycle > value.cycle) || new Set(humanDecisions.map(d => d.cycle)).size !== humanDecisions.length) fail('invalid decision history');
+    const expected = digest([identity.repository, item.path, item.side, item.anchorHash, item.claimHash, item.matchable ? null : value.chainOrigin, item.matchable ? null : item.firstSeen]);
+    if (item.id !== expected) fail('invalid finding fingerprint');
+    ids.add(item.id);
+    return { ...item, findingIndices: [], humanDecisions };
+  });
+  return { ...value, findings };
+}
+
+/** Accepts the real report.findings shape from review.mjs (including project reports).
+ * Does not mutate or copy report verification, evidence receipts, status or source.
+ * Hashes exact source anchor and defect claim; prose drift deliberately makes a new
+ * candidate rather than heuristically merging distinct causes by title/path.
+ */
+export function buildFindingLedger(report, identity, options = {}) {
+  identity = identityValue(identity);
+  exact(options, ['previous', 'outcomes']);
+  if (!record(report) || !text(report.snapshotId)) fail('invalid current report');
+  list(report.findings);
+  const previous = options.previous === undefined ? undefined : validatePrevious(options.previous, identity);
+  if (previous?.cycle === MAX_CYCLES) fail('cycle cap reached; step back with human review, not automatic approval');
+  const cycle = (previous?.cycle ?? 0) + 1;
+  const originSnapshotId = previous?.originSnapshotId ?? report.snapshotId;
+  const chainOrigin = digest([identity, originSnapshotId]);
+  const rows = new Map((previous?.findings ?? []).map(item => [item.id, { ...item, observation: 'not-observed' }]));
+  report.findings.forEach((finding, index) => {
+    if (!record(finding)) fail('invalid current finding');
+    const mapped = finding.path === undefined && Array.isArray(report.files) ? report.files.filter(file => file.fileId === finding.fileId && (finding.batchSnapshotId === undefined || file.batchSnapshotId === finding.batchSnapshotId)) : [];
+    const findingPath = path(finding.path ?? (mapped.length === 1 ? mapped[0].path : undefined)), anchor = finding.anchor;
+    if (!record(anchor) || !['line', 'property', 'file'].includes(anchor.kind)) fail('invalid current anchor');
+    if (findingPath === '.' && !['property', 'file'].includes(anchor.kind)) fail('root findings require property or file anchor');
+    const side = anchor.kind === 'line' ? anchor.side : anchor.kind;
+    if (anchor.kind === 'line' && (!['old', 'new'].includes(side) || !text(anchor.snippet))) fail('missing exact snippet/side');
+    if (anchor.kind === 'property' && !text(anchor.name)) fail('missing exact property');
+    for (const key of ['evidence', 'trigger', 'impact']) if (!text(finding[key])) fail('missing defect claim');
+    const a = finding.attribution;
+    const causal = ['beforeBehavior', 'afterBehavior', 'reason'].map(key => {
+      if (a?.[key] !== undefined && !text(a[key])) fail('invalid causal claim');
+      return a?.[key] ?? null;
+    });
+    // Qualified interaction refs differentiate cross-file claims without transferring receipts.
+    const interaction = finding.interaction?.editRefs;
+    if (interaction !== undefined) {
+      list(interaction);
+      for (const ref of interaction) if (!record(ref) || !text(ref.fileId) || !text(ref.editId)) fail('invalid interaction claim');
+    }
+    const claimHash = digest([finding.evidence, finding.trigger, finding.impact, causal, interaction?.map(ref => [ref.fileId, ref.editId]).sort() ?? null]);
+    const anchorHash = digest(anchor.kind === 'line' ? anchor.snippet : anchor.kind === 'property' ? anchor.name : 'file');
+    const matchable = anchor.kind !== 'file';
+    const id = digest([identity.repository, findingPath, side, anchorHash, claimHash, matchable ? null : chainOrigin, matchable ? null : cycle]);
+    const existing = rows.get(id);
+    if (existing) { existing.observation = existing.firstSeen === cycle ? 'new' : 'repeated'; existing.lastSeen = cycle; existing.findingIndices.push(index); }
+    else rows.set(id, { id, path: findingPath, side, anchorHash, claimHash, matchable, firstSeen: cycle, lastSeen: cycle, observation: 'new', findingIndices: [index], humanDecisions: [] });
+  });
+  const outcomes = options.outcomes ?? [];
+  list(outcomes);
+  const decided = new Set();
+  for (const outcome of outcomes) {
+    exact(outcome, ['id', 'decision', 'reason']);
+    const item = rows.get(outcome.id);
+    if (!item || decided.has(outcome.id)) fail('unknown or duplicate outcome id');
+    decided.add(outcome.id);
+    item.humanDecisions.push(decisionValue({ decision: outcome.decision, reason: outcome.reason, cycle }));
+  }
+  if (rows.size > LIMIT) fail('excessive historical findings');
+  return freeze({ schemaVersion: 1, identity, originSnapshotId, chainOrigin, cycle, maxCycles: MAX_CYCLES, nextAction: cycle === MAX_CYCLES ? 'step-back' : 'human-review', trust: TRUST, snapshotId: report.snapshotId, findings: [...rows.values()] });
+}
+
+function snapshotMetadata(value) {
+  exact(value, ['identity', 'snapshotId', 'files']);
+  const identity = identityValue(value.identity);
+  if (!text(value.snapshotId)) fail('invalid snapshot metadata');
+  list(value.files);
+  const files = new Map();
+  for (const file of value.files) {
+    exact(file, ['path', 'hash', 'dependencies']);
+    const name = path(file.path);
+    if (files.has(name) || file.hash !== undefined && !hash(file.hash)) fail('invalid or duplicate source hash');
+    const dependencies = file.dependencies;
+    if (dependencies !== undefined) {
+      list(dependencies);
+      const seen = new Set();
+      for (const dep of dependencies) {
+        exact(dep, ['path', 'hash']); path(dep.path);
+        if (seen.has(dep.path) || dep.hash !== undefined && !hash(dep.hash)) fail('invalid dependency');
+        seen.add(dep.path);
+      }
+    }
+    files.set(name, file);
+  }
+  return { identity, files };
+}
+
+/** Explicit complete dependency lists are caller-supplied metadata, not discovery
+ * or proof. Unknown/changing deps conservatively invalidate their transitive users.
+ * Even unchanged paths are navigation only, never full coverage or reused evidence.
+ */
+export function planIncrementalReview(previous, current) {
+  const old = snapshotMetadata(previous), next = snapshotMetadata(current);
+  sameIdentity(old.identity, next.identity);
+  const safe = new Set();
+  for (const [name, file] of next.files) {
+    const before = old.files.get(name);
+    if (!before || !hash(file.hash) || file.hash !== before.hash || !Array.isArray(file.dependencies) || !Array.isArray(before.dependencies)) continue;
+    const deps = list => list.map(dep => [dep.path, dep.hash]).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    if (JSON.stringify(deps(file.dependencies)) !== JSON.stringify(deps(before.dependencies))) continue;
+    if (file.dependencies.every(dep => hash(dep.hash) && next.files.get(dep.path)?.hash === dep.hash && old.files.get(dep.path)?.hash === dep.hash)) safe.add(name);
+  }
+  // Fixed point is cycle-safe: an unchanged, fully-known dependency cycle is safe
+  // navigation; any unknown/changed member invalidates every reachable dependent.
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const name of safe) if (next.files.get(name).dependencies.some(dep => !safe.has(dep.path))) { safe.delete(name); changed = true; }
+  }
+  return freeze({ freshReviewPaths: [...next.files.keys()].filter(name => !safe.has(name)), unchangedNavigationPaths: [...next.files.keys()].filter(name => safe.has(name)), removedPaths: [...old.files.keys()].filter(name => !next.files.has(name)), coverage: false, trust: TRUST, requiresFreshEvidence: true });
+}

package/src/incremental-review.mjs

@@ -0,0 +1,95 @@
+import { createHash } from 'node:crypto';
+import { planIncrementalReview } from './finding-ledger.mjs';
+
+const fail = message => { throw new Error('Incremental review: ' + message); };
+const object = value => value && typeof value === 'object' && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+const hash = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+function exact(value, keys) {
+  if (!object(value) || Reflect.ownKeys(value).some(key => typeof key !== 'string' || !keys.includes(key) || !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), 'value'))) fail('unknown metadata field');
+}
+function canonical(value) {
+  if (value === undefined) return null;
+  if (value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number' && Number.isFinite(value)) return value;
+  if (Array.isArray(value)) return value.map(canonical);
+  if (!object(value)) fail('non-JSON snapshot metadata');
+  return Object.fromEntries(Object.keys(value).sort().map(key => [key, canonical(value[key])]));
+}
+const digest = value => createHash('sha256').update(JSON.stringify(canonical(value))).digest('hex');
+
+// Includes BOTH approved source sides, existence, properties, mappings and source
+// provenance. A right-text hash alone would silently miss changed old-side diffs.
+export function incrementalFileHash(file) {
+  if (!object(file)) fail('invalid snapshot file');
+  return digest(Object.fromEntries(Object.entries(file).filter(([key]) => !['id', 'eligibility', 'reason'].includes(key))));
+}
+
+// A changed approved context/rule/requirement invalidates automatic safe narrowing.
+// Explicit user-selected partial re-review is not a complete dependency check. This is a local policy binding, never defect evidence.
+export function incrementalContextHash(snapshot) {
+  return digest([snapshot.context ?? [], snapshot.rules ?? [], snapshot.businessRequirement ?? null]);
+}
+
+/** Pure primary selection; never creates last-reviewed-right -> current-right diff.
+ * previousManifest must be owned host metadata, not model/public request data.
+ * Automatic narrowing requires repository-wide complete graph attestation, never inferred
+ * from empty dependency lists or partial import/caller navigation. No attestation
+ * is available in today's capture path, so automatic production use stays full.
+ * An explicit diff-only user scope may omit unchanged primaries, always partial.
+ * The caller MUST construct retrieval from retrievalSnapshot (original approved
+ * source catalog) and use reviewSnapshot for primary scheduling. Skipped files
+ * are unreviewed, not completed; caller MUST enforce plan.requiredReportStatus.
+ */
+export function buildIncrementalSelection(approvedFreshSnapshot, options) {
+  exact(options, ['previousManifest', 'currentManifest', 'dependencyGraph', 'capturePolicyUnchanged', 'explicitDiffOnly']);
+  if (options.capturePolicyUnchanged !== undefined && typeof options.capturePolicyUnchanged !== 'boolean') fail('invalid policy binding');
+  const snapshot = approvedFreshSnapshot;
+  if (!object(snapshot) || typeof snapshot.id !== 'string' || !snapshot.id || !Array.isArray(snapshot.files) || snapshot.files.length > 200 || !Array.isArray(snapshot.context) || snapshot.context.length > 100) fail('invalid approved snapshot');
+  const { previousManifest, currentManifest, dependencyGraph } = options;
+  // Also validates exact manifest schemas/identities/paths/hash shapes. A graph
+  // assertion cannot bypass repository, route, rule or requirement-policy binding.
+  const incremental = planIncrementalReview(previousManifest, currentManifest);
+  if (currentManifest.snapshotId !== snapshot.id) fail('fresh snapshot identity mismatch');
+  const current = new Map(currentManifest.files.map(file => [file.path, file]));
+  if (current.size !== snapshot.files.length) fail('manifest inventory mismatch');
+  const ids = new Set(), paths = new Set();
+  for (const file of snapshot.files) {
+    if (!object(file) || typeof file.id !== 'string' || !file.id || ids.has(file.id) || paths.has(file.path) || !['reviewable', 'excluded', 'blocked'].includes(file.eligibility)) fail('invalid snapshot inventory');
+    ids.add(file.id); paths.add(file.path);
+    if (!current.has(file.path) || current.get(file.path).hash !== incrementalFileHash(file)) fail('manifest source mismatch');
+  }
+  let graphKnown = false;
+  if (dependencyGraph !== undefined) {
+    exact(dependencyGraph, ['status', 'repositoryWide', 'previousSnapshotId', 'currentSnapshotId', 'previousContextHash', 'currentContextHash']);
+    if (!['complete', 'unknown'].includes(dependencyGraph.status) || typeof dependencyGraph.repositoryWide !== 'boolean') fail('invalid dependency graph metadata');
+    if (dependencyGraph.status === 'complete') {
+      if (dependencyGraph.previousSnapshotId !== previousManifest.snapshotId || dependencyGraph.currentSnapshotId !== snapshot.id || !hash(dependencyGraph.previousContextHash) || dependencyGraph.currentContextHash !== incrementalContextHash(snapshot)) fail('dependency graph binding mismatch');
+      graphKnown = dependencyGraph.repositoryWide === true && dependencyGraph.previousContextHash === dependencyGraph.currentContextHash;
+    }
+  }
+  // Any unknown dependency inventory makes the WHOLE repository graph unknown.
+  // A seemingly isolated unchanged file cannot rule out uncaptured reverse users.
+  const inventoriesKnown = [previousManifest, currentManifest].every(manifest => manifest.files.every(file => hash(file.hash) && Array.isArray(file.dependencies) && file.dependencies.every(dep => hash(dep.hash) && manifest.files.some(target => target.path === dep.path && target.hash === dep.hash))));
+  const safe = options.capturePolicyUnchanged === true && graphKnown && inventoriesKnown ? new Set(incremental.unchangedNavigationPaths) : new Set();
+  if (options.explicitDiffOnly !== undefined && typeof options.explicitDiffOnly !== 'boolean') fail('invalid explicit diff-only selection');
+  if (options.explicitDiffOnly === true) {
+    const old=new Map(previousManifest.files.map(file=>[file.path,file.hash]));
+    for(const file of snapshot.files) if(old.get(file.path)===incrementalFileHash(file)) safe.add(file.path);
+  }
+  const unreviewed = snapshot.files.filter(file => file.eligibility === 'reviewable' && safe.has(file.path));
+  const unreviewedPaths = unreviewed.map(file => file.path);
+  const skipped = new Set(unreviewedPaths);
+  const excludedRecords = unreviewed.map(file => ({ fileId: file.id, path: file.path, status: 'excluded', reason: 'incremental-unchanged-not-reviewed' }));
+  const reviewSnapshot = { ...snapshot, files: snapshot.files.map(file => skipped.has(file.path) ? { ...file, eligibility: 'excluded', reason: 'incremental-unchanged-not-reviewed' } : file) };
+  const plan = {
+    mode: skipped.size ? (options.explicitDiffOnly ? 'explicit-diff-only-subset' : 'incremental-primary-subset') : 'full-fresh-primary',
+    primaryPaths: reviewSnapshot.files.filter(file => file.eligibility === 'reviewable').map(file => file.path),
+    unreviewedPaths, removedPaths: incremental.removedPaths, excludedRecords,
+    requiredReportStatus: skipped.size ? 'partial' : null,
+    coverage: false, requiresFreshEvidence: true,
+    notice: skipped.size ? 'Unchanged primaries were not reviewed; original approved sources remain retrieval context only. No full coverage, fix verification, new incremental baseline, or prior receipt reuse.' : 'No safe narrowing; fresh primary scope retained. Unknown repository dependencies require full review, not assumed isolation.',
+  };
+  // Freeze only newly authored metadata. Never freeze caller-owned snapshot/body.
+  for (const key of ['primaryPaths', 'unreviewedPaths', 'removedPaths', 'excludedRecords']) Object.freeze(plan[key]);
+  for (const row of excludedRecords) Object.freeze(row);
+  return Object.freeze({ reviewSnapshot, retrievalSnapshot: snapshot, plan: Object.freeze(plan) });
+}

package/src/project-execution.mjs

@@ -1,3 +1,5 @@
+import { reviewEffortPolicy } from './review-effort.mjs';
+import { PROJECT_REVIEW_INSTRUCTIONS } from './prompts.mjs';
 import { reviewSnapshot } from './review.mjs';
 import { retrievalRounds } from './review-execution-policy.mjs';
 
@@ -9,7 +11,7 @@ export function projectConcurrency(value = DEFAULT_PROJECT_CONCURRENCY) {
 
 // Parallelize independent approved snapshots, never dependent stages within a batch.
 // Admission and the shared call reservation are synchronous; completion order is not report order.
-export async function reviewProjectBatches(batches, model, { concurrency = DEFAULT_PROJECT_CONCURRENCY, remainingCalls, signal, onProgress, maxRetrievalRounds = 3, resumeStates, onResumeCheckpoint, onModelArtifact, enableGroupPrimary = false, nativeOutputTools = false } = {}) {
+export async function reviewProjectBatches(batches, model, { concurrency = DEFAULT_PROJECT_CONCURRENCY, reviewEffortMode = 'auto', enableCounterVerification = false, remainingCalls, signal, onProgress, maxRetrievalRounds = 3, resumeStates, onResumeCheckpoint, onModelArtifact, enableGroupPrimary = false, nativeOutputTools = false } = {}) {
   projectConcurrency(concurrency);
   retrievalRounds(maxRetrievalRounds);
   if (!Array.isArray(batches) || typeof remainingCalls !== 'function') throw new Error('Invalid project execution');
@@ -25,7 +27,10 @@ export async function reviewProjectBatches(batches, model, { concurrency = DEFAU
       const batch = batches[index];
       try {
         if (batchSignal.aborted || remainingCalls() <= 0) { results[index] = unstarted(batch); continue; }
+        const effort=reviewEffortPolicy(batch,{mode:reviewEffortMode});
         results[index] = await reviewSnapshot(batch, model, {
+          instructions: PROJECT_REVIEW_INSTRUCTIONS + '\nReview focus (not proof): ' + JSON.stringify(effort.checks),
+          enableCounterVerification:enableCounterVerification && effort.counterVerification.eligible,
           signal: batchSignal, maxCalls: remainingCalls(), remainingCalls, enableRetrieval: true, enableVerification: true,
           enableGroupPrimary, nativeOutputTools, enableAnchorCorrection: true, correctProtocol: true, maxRetrievalRounds,
           resumeState: resumeStates?.get(batch.id), onResumeCheckpoint: onResumeCheckpoint ? report => onResumeCheckpoint(batch, report) : undefined, onModelArtifact,

package/src/project-review-service.mjs

@@ -1,3 +1,4 @@
+import { reviewEffortPolicy, reviewEffortMode } from './review-effort.mjs';
 import { previewValidity } from './preview-validity.mjs';
 import { REVIEW_RUNTIME } from './runtime-identity.mjs';
 import { buildResumeState, validateResumeState } from './review-resume.mjs';
@@ -72,10 +73,12 @@ async function captureProject(cwd, args, signal) {
   return { ...result, id: hash(JSON.stringify(result)) };
 }
 
-export function createProjectReviewService(llm, { executionStrategy = 'staged', allowModelSending = false, authorize = async () => false, now = Date.now, ttlMs = 300000, maxPreviews = 8, projectMaxCalls = Number.MAX_SAFE_INTEGER, projectConcurrency = DEFAULT_PROJECT_CONCURRENCY, maxRetrievalRounds = 3, nativeOutputTools = false, enableGroupPrimary = false } = {}) {
+export function createProjectReviewService(llm, { reviewEffort = 'auto', enableCounterVerification = false, executionStrategy = 'staged', allowModelSending = false, authorize = async () => false, now = Date.now, ttlMs = 300000, maxPreviews = 8, projectMaxCalls = Number.MAX_SAFE_INTEGER, projectConcurrency = DEFAULT_PROJECT_CONCURRENCY, maxRetrievalRounds = 3, nativeOutputTools = false, enableGroupPrimary = false } = {}) {
   for (const n of [ttlMs, maxPreviews]) if (!Number.isSafeInteger(n) || n < 1) throw new Error('Invalid project preview limit');
   if (!Number.isSafeInteger(projectMaxCalls) || projectMaxCalls < 1) throw new Error('Invalid project model call limit');
 
+  reviewEffortMode(reviewEffort);
+  if(typeof enableCounterVerification!=='boolean')throw new Error('Invalid counterverification policy');
   validateProjectConcurrency(projectConcurrency);
   retrievalRounds(maxRetrievalRounds);
   if (typeof nativeOutputTools !== 'boolean' || typeof enableGroupPrimary !== 'boolean') throw new Error('Invalid project execution options');
@@ -94,16 +97,17 @@ export function createProjectReviewService(llm, { executionStrategy = 'staged',
       if (executionStrategy === 'whole-scope') throw new Error('Whole-scope currently supports fresh single-round changes only; project requires explicit staged configuration');
       if (busy) throw new Error('Review service busy');
       if (!args || typeof args !== 'object') throw new Error('Project preview parameters required');
-      if (Object.keys(args).some(k => !['reviewMode', 'repositoryPath', 'selectedPaths', 'resumeFromJobId'].includes(k)) || args.reviewMode !== 'project') throw new Error('Project mode supports only reviewMode/repositoryPath/selectedPaths; change/history context parameters are not project parameters');
+      if (Object.keys(args).some(k => !['reviewMode', 'repositoryPath', 'selectedPaths', 'resumeFromJobId', 'reviewEffort'].includes(k)) || args.reviewMode !== 'project') throw new Error('Project mode supports only reviewMode/repositoryPath/selectedPaths; change/history context parameters are not project parameters');
       const current = owner(exec);
       busy = true;
       try {
         const captureArgs = structuredClone(args);
+        const effortMode=reviewEffortMode(captureArgs.reviewEffort ?? reviewEffort); delete captureArgs.reviewEffort;
         const sourceJobId = captureArgs.resumeFromJobId; delete captureArgs.resumeFromJobId;
         if (sourceJobId !== undefined && (typeof sourceJobId !== 'string' || !/^[a-f0-9-]{36}$/.test(sourceJobId) || typeof exec.resolveReviewResume !== 'function')) throw new Error('Invalid or unavailable resume job');
         const saved = sourceJobId === undefined ? undefined : await exec.resolveReviewResume(sourceJobId);
         const s = await captureProject(current.cwd, captureArgs, signalFor(exec));
-        const identity = resumeIdentity(captureArgs, current.route);
+        const identity = resumeIdentity({...captureArgs,reviewEffort:effortMode,enableCounterVerification}, current.route);
         let resumeStates;
         if (saved !== undefined) {
           if (saved?.schemaVersion !== 1 || saved.mode !== 'project' || !Array.isArray(saved.batches)) throw new Error('Invalid project resume checkpoint');
@@ -119,7 +123,7 @@ export function createProjectReviewService(llm, { executionStrategy = 'staged',
         while (previews.size >= maxPreviews) previews.delete(previews.keys().next().value);
         const previewId = randomUUID();
         const expires = now() + ttlMs;
-        previews.set(previewId, { ...current, args: captureArgs, snapshotId: s.id, resumeStates, sourceJobId, expires });
+        previews.set(previewId, { ...current, args: captureArgs, snapshotId: s.id, effortMode, resumeStates, sourceJobId, expires });
         return {
           ...(resumeStates ? { resume: { sourceJobId, reusableFiles: [...resumeStates.values()].reduce((sum, state) => sum + state.completed.length, 0) } } : {}),
           previewId, expiresAt: new Date(expires).toISOString(), validForMs: ttlMs, snapshotId: s.id, reviewMode: 'project', repositoryRoot: s.root, vcs: s.vcs,
@@ -128,6 +132,7 @@ export function createProjectReviewService(llm, { executionStrategy = 'staged',
           inventoryComplete: s.inventoryComplete, inventoryScope: s.inventoryScope, inventoryNodes: s.inventoryNodes, batches: s.batches.length,
           privateArtifacts: { enabled: typeof exec.onModelArtifact === 'function', sourceBearing: true, maxArtifactBytes: 1048576, maxJobBytes: 8388608, maxArtifacts: 4096, notice: 'Bounded private untrusted model outputs; raw access requires explicit consent and is not review evidence.' },
           execution: { nativeOutputTools, enableGroupPrimary, batchConcurrency: projectConcurrency, maxRetrievalRounds },
+          reviewEffort: {mode:effortMode,status:"planned-per-batch",counterVerification:enableCounterVerification},
           files: s.batches.flatMap(b => b.files.map(f => ({ path: f.path, eligibility: f.eligibility, reason: f.reason }))),
           notice: s.notice + PREVIEW_NOTICE_SUFFIX + ' Each stage allows at most ' + maxRetrievalRounds + ' retrieval rounds; exhaustion requires a final-only response and explicit unfinished coverage.',
         };
@@ -157,7 +162,7 @@ export function createProjectReviewService(llm, { executionStrategy = 'staged',
           files: s.batches.flatMap(b => b.files.map(f => ({ fileId: f.id, path: f.path, status: f.eligibility === 'reviewable' ? 'pending' : f.eligibility }))),
         });
 
-        const identity = resumeIdentity(p.args, p.route);
+        const identity = resumeIdentity({...p.args,reviewEffort:p.effortMode,enableCounterVerification}, p.route);
         const states = new Map();
         for (const [id, saved] of p.resumeStates ?? []) {
           const batch = s.batches.find(batch => batch.id === id);
@@ -182,7 +187,7 @@ export function createProjectReviewService(llm, { executionStrategy = 'staged',
         };
 
         const results = await reviewProjectBatches(s.batches, model, {
-          concurrency: projectConcurrency, maxRetrievalRounds, enableGroupPrimary, nativeOutputTools, signal, remainingCalls: () => projectMaxCalls - calls,
+          concurrency: projectConcurrency, reviewEffortMode:p.effortMode, enableCounterVerification, maxRetrievalRounds, enableGroupPrimary, nativeOutputTools, signal, remainingCalls: () => projectMaxCalls - calls,
           onProgress: exec.reviewCheckpoint, resumeStates: states, onResumeCheckpoint: persist, onModelArtifact: exec.onModelArtifact,
         });
 
@@ -208,6 +213,7 @@ export function createProjectReviewService(llm, { executionStrategy = 'staged',
           coverage, files, findings, scopeNotices: results.flatMap(result => result.scopeNotices ?? []), artifacts: results.flatMap(result => result.artifacts ?? []), batches: results, resume: { reusedFiles: files.filter(file => file.reused).length },
           privateArtifacts: { enabled: typeof exec.onModelArtifact === 'function', sourceBearing: true, maxArtifactBytes: 1048576, maxJobBytes: 8388608, maxArtifacts: 4096, notice: 'Bounded private untrusted model outputs; raw access requires explicit consent and is not review evidence.' },
           execution: { nativeOutputTools, enableGroupPrimary, batchConcurrency: projectConcurrency, maxRetrievalRounds },
+          reviewEffort: {mode:p.effortMode,status:"planned-per-batch",counterVerification:enableCounterVerification},
           notice: s.notice + REPORT_NOTICE_SUFFIX,
         };
 

package/src/report-findings.mjs

@@ -42,6 +42,8 @@ export function findingsMarkdown(report) {
   for (const [label, items] of sections) {
     if (!items.length) continue;
     output.push('', '### ' + label);
+    const levels = {critical:0,high:1,medium:2,low:3};
+    items.sort((a,b)=>(levels[a.f.severity]??4)-(levels[b.f.severity]??4)||a.i-b.i);
     for (const {f,i} of items) {
       const severity = ({critical:'严重',high:'高',medium:'中',low:'低'})[f.severity] ?? safe(f.severity ?? '未分级');
       const hypothesis = label === '复核后不确定' || label === '复核未完成' || label === '已反驳';
@@ -58,6 +60,9 @@ export function findingsMarkdown(report) {
       else 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('；') + '。正文合并展示，原始候选仍保留。');
+      const ledgerItem = report.reviewHistory?.ledger?.findings?.find(row => row.findingIndices?.includes(i));
+      if (ledgerItem?.observation === 'repeated') output.push('- 历史台账：本轮再次观察到相同定位与缺陷主张；不重复创建新问题，当前证据仍须独立核对。');
+      if (ledgerItem?.humanDecisions?.length) output.push('- 人工处置记录：' + ledgerItem.humanDecisions.map(row => safe(row.decision) + '：' + safe(row.reason)).join('；') + '；这是历史决定，不是修复或缺陷证明。');
       if (f.reused || f.priorRun) output.push('- 来源：包含既往审核结果，不表示本轮重新取证。');
       output.push('- 完整证据与判定过程：见技术附录中的候选 ' + (i+1) + '。');
     }

package/src/report-summary.mjs

@@ -30,6 +30,20 @@ export function verificationPresentation(finding, report = {}) {
   return 'uncertain';
 }
 
+// Candidate numbers refer to the unchanged original finding/appendix order.
+// Only evidence-qualified support is prioritized; severity never promotes a hypothesis.
+export function supportedFindingPriorities(report = {}) {
+  const severity = { critical: 0, high: 1, medium: 2, low: 3 };
+  const category = { introduced: 0, current: 1, preexisting: 2 };
+  return rows(report.findings).flatMap((finding, index) => {
+    const state = verificationPresentation(finding, report);
+    if (!Object.hasOwn(category, state)) return [];
+    const level = Object.hasOwn(severity, finding.severity) ? finding.severity : 'unknown';
+    return [{ candidate: index + 1, state, severity: level }];
+  }).sort((a, b) => category[a.state] - category[b.state] ||
+    (severity[a.severity] ?? 4) - (severity[b.severity] ?? 4) || a.candidate - b.candidate);
+}
+
 /**
  * Pure presentation data for Markdown/Lead renderers. Counts are candidate records,
  * not proven defects. coverage counts main-review entries (directories included in
@@ -82,6 +96,12 @@ export function reportSummaryData(report = {}) {
     counts: { total: findings.length, ...counts },
     coverage: { total, loaded: files.length, detailsComplete, unit: project ? 'files' : 'change-entries', ...coverage },
     unfinished, crossFile, stages, unverifiedCandidates,
+    verification: {
+      supported: counts.introduced + counts.preexisting + counts.current,
+      uncertain: findings.filter(finding => verificationPresentation(finding, report) === 'uncertain').length,
+      incomplete: findings.filter(finding => verificationPresentation(finding, report) === 'incomplete').length,
+    },
+    priorities: supportedFindingPriorities(report),
     limitations: rows(report.limitations).length,
     scopeNotices: rows(report.scopeNotices).length,
     reused: findings.some(finding => finding?.reused || finding?.priorRun),
@@ -93,16 +113,35 @@ 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 ? '；报告已过期' : '') + '；' +
+  const firstCounts = counts.total ? [
+    counts.introduced ? '复核支持本次新增 ' + counts.introduced : '',
+    counts.current ? '当前源码复核支持 ' + counts.current : '',
+    counts.preexisting ? '复核支持原有 ' + counts.preexisting : '',
+    !data.verification.supported ? '尚无复核支持的问题' : '',
+  ].filter(Boolean).join('；') + '；' : '';
+  const headline = firstCounts + state + (data.outdated ? '；报告已过期' : '') + '；' +
     (counts.total ? '记录 ' + counts.total + ' 个候选问题' : '未记录候选问题') + '；不得据此放行。';
   const output = ['', '## 结论摘要', '- ' + headline];
+  if (counts.total || !data.complete || data.outdated) {
+    output.push('- 下一步：' + (data.outdated ? '先基于当前批准快照重新审核；' : '') +
+      (data.verification.supported ? '按下列候选编号核对触发条件与修复必要性；' : '无复核支持的问题不等于审核通过；') +
+      '已复核不确定 ' + data.verification.uncertain + '、复核未完成 ' + data.verification.incomplete +
+      '，先核实而非直接修复；已加载未完成条目 ' + data.unfinished.length +
+      (coverage.detailsComplete ? '' : '，明细尚未加载齐') +
+      (data.complete ? '；处理已结束，不代表所有疑点已排除。' : '；须补齐未完成范围和阶段，不能视为无问题。'));
+  }
+  if (data.priorities.length) {
+    const labels = { introduced: '本次新增', current: '当前源码', preexisting: '原有' };
+    const levels = { critical: '严重', high: '高', medium: '中', low: '低', unknown: '未分级' };
+    output.push('- 优先核对（仅复核支持，类别内按严重程度）：' + data.priorities.slice(0, 5)
+      .map(item => '候选 ' + item.candidate + '（' + labels[item.state] + '／' + levels[item.severity] + '）').join('；') +
+      (data.priorities.length > 5 ? '；其余 ' + (data.priorities.length - 5) + ' 项见审查发现与技术附录' : '') + '。');
+  }
   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('；') + '。');
   }
-  const states = rows(report.findings).map(finding => verificationPresentation(finding, report));
-  const uncertain = states.filter(state => state === 'uncertain').length;
-  const incomplete = states.filter(state => state === 'incomplete').length;
+  const { uncertain, incomplete } = data.verification;
   output.push('- 复核状态分列：复核支持 ' + (counts.introduced + counts.preexisting + counts.current) + '；已复核不确定 ' + uncertain + '；复核未完成（未复核或未完成有效复核） ' + incomplete + (counts.refuted ? '；已反驳 ' + counts.refuted : '') + '。');
   if (counts.unresolved) output.push('- “待核实”为合计：已复核不确定与复核未完成分开列示，前者不表示复核未执行；均不能直接视为缺陷或必改项。');
   const unit = coverage.unit === 'files' ? '个文件' : '个变更条目（含目录）';

package/src/review-effort.mjs

@@ -0,0 +1,104 @@
+import { createHash } from 'node:crypto';
+import { lineDiff } from './line-diff.mjs';
+
+// Planning only: these lexical signals are neither findings nor approval evidence.
+const LIMITS = Object.freeze({ files: 200, sourceChars: 262144, totalSourceChars: 2097152, metadataChars: 4096 });
+const BASELINE = Object.freeze([
+  'Require exact changed-code evidence, a concrete trigger and impact before reporting a defect.',
+  'Compare before/after behavior and captured callers; missing context remains uncertainty.',
+  'Retain strict evidence verification in every effort tier; no policy result proves completion or approval.',
+]);
+const CATEGORIES = Object.freeze({
+  lifecycle: { pattern: /\b(?:dispose|destroy|shutdown|close|release|free|cancel|abort|unsubscribe|removeEventListener)\b/i,
+    guidance: 'Seek cleanup guards, ownership transfers and completion before teardown on success, failure and cancellation paths.' },
+  concurrency: { pattern: /\b(?:await|async|mutex|lock|atomic|thread|worker|synchronized|volatile|Promise|goroutine)\b/i,
+    guidance: 'Seek actual synchronization, queue/actor isolation and cancellation ordering; source order alone is not a happens-before proof.' },
+  persistence: { pattern: /\b(?:transaction|commit|rollback|writeFile|rename|fsync|INSERT|UPDATE|DELETE|migration|serialize|deserialize)\b/i,
+    guidance: 'Seek rollback, atomic publication, schema/version guards and recovery behavior against captured storage consumers.' },
+  compatibility: { pattern: /\b(?:export|public|interface|ABI|API|schema|protocol|deprecated|version|override)\b/i,
+    guidance: 'Seek caller contracts, compatibility adapters and supported runtime/version evidence; do not invent a public contract.' },
+  sensitive: { pattern: /\b(?:auth|authorize|authorization|authenticate|authentication|permissions?|privilege|chmod|sudo|install|update|release|CI|postinstall|preinstall|pull_request_target|workflow_dispatch|publish|deploy|installer|autoUpdate)\b/i,
+    guidance: 'Seek trust-boundary validation and explicit authorization in captured code; installation, update, CI and release actions require separate human handling, never automatic approval.' },
+});
+const PATH_HINT = /(?:^|[\\/_.-])(?:auth|permissions?|install|update|release|deploy)(?:[\\/_.-]|$)|(?:^|[\\/])\.github[\\/]workflows[\\/]|(?:^|[\\/])\.gitlab-ci\.yml$/i;
+const digest = value => createHash('sha256').update(value).digest('hex');
+
+export function reviewEffortMode(value = 'auto') {
+  if (!['auto', 'quick', 'standard', 'deep'].includes(value)) throw new TypeError('Invalid review effort mode');
+  return value;
+}
+
+// Unknown severities are never silently promoted or treated as verified severe findings.
+export function counterVerificationEligible(policy, candidate) {
+  return policy?.version === 1 && policy.tier === 'deep' && policy.counterVerification?.eligible === true &&
+    ['high', 'critical'].includes(candidate?.severity);
+}
+
+/** Pure bounded planning over captured snapshot.files[].left/right.text.
+ * Identity is a source/selected-metadata binding, not a receipt or reusable coverage.
+ * A null sourceFingerprint explicitly means the complete binding is unavailable.
+ * Requirements and other free-text instructions are not interpreted or returned.
+ */
+export function reviewEffortPolicy(snapshot, { mode = 'auto' } = {}) {
+  mode = reviewEffortMode(mode);
+  if (!snapshot || !Array.isArray(snapshot.files)) throw new TypeError('Invalid effort snapshot');
+  const reasons = new Set(), categories = new Set();
+  let complete = true, used = 0, filesScanned = 0, exactChanges = true;
+  const hash = createHash('sha256');
+  const field = value => {
+    if (value === undefined) return null;
+    if (typeof value === 'boolean' || (typeof value === 'number' && Number.isFinite(value))) return value;
+    if (typeof value === 'string' && value.length <= LIMITS.metadataChars) return value;
+    complete = false; reasons.add('metadata-unavailable'); return null;
+  };
+  const bind = values => hash.update(JSON.stringify(values) + '\n');
+  bind(['review-effort-v1', ...['id', 'root', 'vcs', 'reviewMode', 'baseRevision', 'targetRevision', 'changeScope'].map(k => field(snapshot[k])), snapshot.files.length]);
+  if (typeof snapshot.id !== 'string' || !snapshot.id || typeof snapshot.root !== 'string' || !snapshot.root) {
+    complete = false; reasons.add('identity-unavailable');
+  }
+  if (snapshot.files.length > LIMITS.files) { complete = false; reasons.add('file-limit'); }
+  for (let i = 0; i < Math.min(snapshot.files.length, LIMITS.files); i++) {
+    const file = snapshot.files[i]; filesScanned++;
+    if (!file || typeof file !== 'object') { complete = false; exactChanges = false; reasons.add('source-unavailable'); continue; }
+    const path = field(file.path);
+    bind([field(file.id), path, field(file.oldPath), field(file.status), field(file.eligibility), field(file.reviewMode)]);
+    if (typeof path !== 'string' || !path) { complete = false; reasons.add('identity-unavailable'); }
+    if (typeof path === 'string' && PATH_HINT.test(path)) reasons.add('sensitive-path-hint');
+    const texts = [];
+    for (const side of ['left', 'right']) {
+      const source = file[side];
+      bind([side, field(source?.exists), field(source?.hash), field(source?.encoding)]);
+      const text = source?.text;
+      if (typeof text !== 'string' || text.length > LIMITS.sourceChars || used + text.length > LIMITS.totalSourceChars) {
+        complete = false; exactChanges = false; reasons.add(typeof text === 'string' ? 'source-limit' : 'source-unavailable');
+        texts.push(null); continue;
+      }
+      used += text.length; bind([text]); texts.push(text);
+    }
+    if (texts.includes(null)) continue;
+    const diff = lineDiff(texts[0], texts[1], { maxCells: 10000 });
+    if (diff.status === 'unchanged') continue;
+    if (diff.status !== 'changed' || diff.precision !== 'exact') { exactChanges = false; reasons.add('change-scope-unavailable'); continue; }
+    // Only exact added/removed lines drive escalation, never an unchanged keyword elsewhere.
+    for (const edit of diff.edits) for (const text of [edit.removed, edit.added]) {
+      for (const [category, rule] of Object.entries(CATEGORIES)) if (rule.pattern.test(text)) categories.add(category);
+    }
+  }
+  for (const category of categories) reasons.add('changed-' + category);
+  if (!reasons.size) reasons.add('standard-baseline');
+  const tier = mode === 'auto' ? (categories.size || !complete || !exactChanges ? 'deep' : 'standard') : mode;
+  const sensitive = categories.has('sensitive') || reasons.has('sensitive-path-hint');
+  return {
+    version: 1, status: 'planned', mode, tier, reasons: [...reasons].sort(),
+    checks: [...BASELINE, ...[...categories].sort().map(category => CATEGORIES[category].guidance)],
+    counterVerification: {
+      eligible: tier === 'deep', severities: ['high', 'critical'], requiresFreshEvidence: true,
+      categories: [...categories].sort(), guidance: [...categories].sort().map(category => CATEGORIES[category].guidance),
+      instructions: 'Attach these counterevidence questions to the primary review without another planning call. For high/critical candidates only, use a separate fresh verifier against exact captured evidence; do not downgrade or clear evidence merely because a counterexample was suggested.',
+    },
+    humanReview: { required: sensitive, advisoryOnly: true, approvalGranted: false },
+    identity: { snapshotIdHash: typeof snapshot.id === 'string' && snapshot.id.length <= LIMITS.metadataChars ? digest(snapshot.id) : null,
+      sourceFingerprint: complete ? hash.digest('hex') : null, complete, scope: 'captured-file-sources-and-selected-metadata', reusableCoverage: false },
+    scan: { filesScanned, totalFiles: snapshot.files.length, complete: complete && exactChanges, limits: { ...LIMITS } },
+  };
+}

package/src/review-history.mjs

@@ -0,0 +1,29 @@
+import { hash } from './content.mjs';
+import { buildFindingLedger } from './finding-ledger.mjs';
+import { buildIncrementalSelection, incrementalFileHash } from './incremental-review.mjs';
+const canonical = value => Array.isArray(value) ? value.map(canonical) : value && typeof value === 'object' ? Object.fromEntries(Object.keys(value).sort().filter(k=>value[k]!==undefined).map(k=>[k,canonical(value[k])])) : value;
+const digest = value => hash(JSON.stringify(canonical(value)));
+export function reviewHistoryIdentity(snapshot,route,capturePolicy={}) {
+  return {repository:digest({root:snapshot.root,vcs:snapshot.vcs,repositoryUuid:snapshot.repositoryUuid ?? snapshot.history?.repositoryUuid,url:snapshot.repositoryUrl ?? snapshot.history?.url}),route:digest(route),rulesHash:digest(snapshot.rules??[]),requirementPolicyHash:digest({requirement:snapshot.businessRequirement,capturePolicy})};
+}
+export function reviewSourceManifest(snapshot,identity) {
+  // No inferred complete dependency graph: conservatively bind every captured source.
+  const files=snapshot.files.map(file=>({path:file.path,hash:incrementalFileHash(file)}));
+  // Dependency completeness is unknown. Do not invent an all-files graph or skip
+  // unchanged files merely because this snapshot happened to capture no callers.
+  return {identity,snapshotId:snapshot.id,files};
+}
+export function prepareReviewHistory(snapshot,route,capturePolicy,{previous,outcomes,explicitDiffOnly=false}={}) {
+  const identity=reviewHistoryIdentity(snapshot,route,capturePolicy);
+  const manifest=reviewSourceManifest(snapshot,identity);
+  if (!previous) {if(outcomes?.length)throw new Error('Finding outcomes require an owned prior review');return {identity,manifest};}
+  if(!previous.ledger||!previous.manifest||previous.ledger.cycle>=3)throw new Error('Review-fix cycle cap reached or prior history unavailable; step back and reconsider');
+  // Validate exact ledger identity and decisions without borrowing any conclusions.
+  buildFindingLedger({snapshotId:snapshot.id,findings:[],files:[]},identity,{previous:previous.ledger,outcomes});
+  const selection=buildIncrementalSelection(snapshot,{previousManifest:previous.manifest,currentManifest:manifest,explicitDiffOnly});
+  return {identity,manifest,previous:previous.ledger,outcomes,incremental:selection.plan,selection};
+}
+export function finishReviewHistory(report,prepared) {
+  const ledger=buildFindingLedger(report,prepared.identity,{...(prepared.previous?{previous:prepared.previous}:{}),...(prepared.outcomes?{outcomes:prepared.outcomes}:{})});
+  return {ledger,manifest:prepared.manifest,...(prepared.incremental?{incremental:prepared.incremental}:{})};
+}

package/src/review-jobs.mjs

@@ -77,6 +77,7 @@ export function createReviewJobs({directory}={}){
    return {jobId:id,status:job.record.status,waitRevision:job.savedRevision,progress:jobProgress(job.record),nextAction:'Call code_review_wait with waitFor=terminal until terminal status; reuse the returned waitRevision as after without guessing increments. No code_review_status call is needed after each event. Do not finish the user request at start.',notice:'Background job accepted; start is not a completed review. Explicit cancel or plugin disposal stops it.'};
   },
   async resume(id,exec){const r=await owned(id,exec);if(jobs.get(id)&&!jobs.get(id).settled||['queued','running'].includes(r.status)||!r.resumeState)throw new Error('No terminal completed-chain resume state available');return structuredClone(r.resumeState);},
+  async priorReview(id,exec){const r=await owned(id,exec);if(jobs.get(id)&&!jobs.get(id).settled||r.status!=='completed'||!r.result?.report?.reviewHistory||r.result.report.outdated)throw new Error('Owned terminal current review history unavailable');return structuredClone(r.result.report.reviewHistory);},
   async artifacts(id,exec,page){const r=await owned(id,exec);return artifacts.read(id,r.owner,page);},
   async status(id,exec,page){const r=structuredClone(await owned(id,exec));delete r.resumeState;const active=jobs.get(id);if(active&&!active.settled&&!['queued','running'].includes(r.status)){r.status='running';r.stage='finalizing';delete r.result;delete r.finishedAt;}r.recovery=recoveryCoverage(r);r.progress=jobProgress(r);r.waitRevision=jobs.get(id)?.savedRevision??r.checkpoints.length;r.nextAction=['queued','running'].includes(r.status)?'Call code_review_wait with waitFor=terminal; reuse the exact returned waitRevision as after, never guess increments. No code_review_status call is needed after each event. Do not end the user request while task runs.':r.result?.previewId?'Inspect preview against current explicit user authorization. For a matching explicit review request, execute with confirmed=true without asking again. Do not execute preview-only or explicit wait-for-confirmation requests; ask for authorization if scope/model/destination exceeds authorization or is unclear. Preserve host permissions and snapshot/identity checks.':'Collect final report and unfinished scope, then provide one final answer.';if(!page)return r;const {offset=0,limit=20,checkpointIndex}=page;if(!Number.isSafeInteger(offset)||offset<0||!Number.isSafeInteger(limit)||limit<1||limit>100)throw new Error('Invalid result page');if(checkpointIndex!==undefined){if(!Number.isSafeInteger(checkpointIndex)||checkpointIndex<0||checkpointIndex>=r.checkpoints.length)throw new Error('Invalid checkpoint index');return {jobId:r.jobId,status:r.status,waitRevision:r.waitRevision,progress:r.progress,nextAction:r.nextAction,checkpointIndex,checkpoint:pageCheckpoint(r.checkpoints[checkpointIndex],offset,limit),page:{offset,limit}};}const result=r.result;const report=result?.report;return {...r,result:undefined,recovery:{...r.recovery,unfinishedStages:r.recovery.unfinishedStages.slice(offset,offset+limit),files:r.recovery.files.slice(offset,offset+limit),windows:r.recovery.windows.slice(offset,offset+limit),suggestedPaths:r.recovery.suggestedPaths.slice(offset,offset+limit),totalObservedFiles:r.recovery.files.length},checkpoints:r.checkpoints.slice(offset,offset+limit).map(c=>pageCheckpoint(c,0,limit)),checkpointPage:{offset,limit,total:r.checkpoints.length},...(result?{resultSummary:report?{status:report.status,coverage:report.coverage,model:report.model,snapshotId:report.snapshotId,diagnostics:report.diagnostics,execution:report.execution,modelCalls:report.modelCalls,totalFiles:report.files?.length,totalFindings:report.findings?.length,totalLimitations:report.limitations?.length,totalScopeNotices:report.scopeNotices?.length??0}:({...result,files:result.files?.slice(offset,offset+limit),filePage:result.files?{offset,limit,total:result.files.length}:undefined}),resultPage:report?{files:report.files?.slice(offset,offset+limit),findings:report.findings?.slice(offset,offset+limit),totalFiles:report.files?.length,totalFindings:report.findings?.length}:undefined}: {})};},
   async wait(id,exec,{after,waitFor='progress',timeoutMs=60000,signal}={}){

package/src/review.mjs

@@ -1,3 +1,4 @@
+import { approvedRetrievalSnapshot } from './approved-retrieval.mjs';
 import { REVIEW_INSTRUCTIONS, PROJECT_REVIEW_INSTRUCTIONS } from './prompts.mjs';
 import { reviewWholeScope } from './whole-scope-review.mjs';
 import { reviewRounds } from './review-rounds.mjs';
@@ -16,6 +17,7 @@ import { validateSynthesisReads } from './synthesis-evidence.mjs';
 import { hash } from './content.mjs';
 import { coverageFollowup } from './coverage-followup.mjs';
 import { verificationLoop } from './verification-loop.mjs';
+import { runCounterVerification } from './counter-verification.mjs';
 import { inferFileRelations } from './file-relations.mjs';
 import { buildReviewGroups } from './review-groups.mjs';
 import { changeMap } from './change-map.mjs';
@@ -47,7 +49,7 @@ import { buildMigrationContracts } from './migration-contracts.mjs';
 
 export { REVIEW_INSTRUCTIONS };
 export function createReviewReader(snapshot, options = {}) {
-  return configureWireBudget(createRetrievalScope(snapshot, { ...reviewReaderBudget(snapshot, options.readerBudgetPolicy ?? 'fixed'), signal: options.signal, ...(options.optimizeReviewCalls ? { reuseResults: true } : {}) }), { nativeOutputTools: options.nativeOutputTools === true });
+  return configureWireBudget(createRetrievalScope(approvedRetrievalSnapshot(snapshot, options.approvedRetrievalSnapshot), { ...reviewReaderBudget(snapshot, options.readerBudgetPolicy ?? 'fixed'), signal: options.signal, ...(options.optimizeReviewCalls ? { reuseResults: true } : {}) }), { nativeOutputTools: options.nativeOutputTools === true });
 }
 export { PROJECT_REVIEW_INSTRUCTIONS };
 const nonempty = value => typeof value === 'string' && value.trim().length > 0 && value.length <= 8000;
@@ -107,7 +109,7 @@ async function invoke(model, request, timeoutMs, parentSignal) {
 }
 
 export async function reviewSnapshot(snapshot, model, options = {}) {
-  if (options.executionStrategy === 'whole-scope') return reviewWholeScope(snapshot, model, { ...options, instructions: REVIEW_INSTRUCTIONS, validateFindingResponse: validateResponse });
+  if (options.executionStrategy === 'whole-scope') return reviewWholeScope(snapshot, model, { ...options, instructions: options.instructions ?? REVIEW_INSTRUCTIONS, validateFindingResponse: validateResponse });
   if (options.executionStrategy !== undefined && options.executionStrategy !== 'staged') throw new Error('Invalid review execution strategy');
   const startedAt = performance.now();
   const rounds = reviewRounds(options.reviewRounds);
@@ -131,7 +133,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
   if(!Number.isSafeInteger(timeoutMs)||timeoutMs<0)throw new Error('Invalid review limit');
   // Clone once: callers cannot change the input while a model call is pending.
   const input = structuredClone(snapshot);
-  const instructions=input.projectScope?PROJECT_REVIEW_INSTRUCTIONS:REVIEW_INSTRUCTIONS;
+  const instructions=options.instructions ?? (input.projectScope?PROJECT_REVIEW_INSTRUCTIONS:REVIEW_INSTRUCTIONS);
   if (!input || !nonempty(input.id) || !['git', 'svn'].includes(input.vcs) || !Array.isArray(input.files) || input.files.length > 200) throw new Error('Invalid review snapshot');
   const identities = new Set(), paths = new Set();
   for (const file of input.files) {
@@ -144,7 +146,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
   for (const key of ['enableEvidenceContext', 'inlineInteractionRisks', 'enableMigrationContracts', 'enableMigrationRegression', 'enableGroupInteractions', 'enableStageContinuation']) if (options[key] !== undefined && typeof options[key] !== 'boolean') throw new Error('Invalid review optimization option');
   const evidenceContext = options.enableEvidenceContext === true ? createEvidenceContext(input.id) : null;
   const readerLimits = reviewReaderBudget(input, options.readerBudgetPolicy ?? 'fixed');
-  const scope = options.enableRetrieval === true ? createRetrievalScope({ ...input, context: input.context ?? [] }, { ...readerLimits, signal, ...(options.optimizeReviewCalls === true ? { reuseResults: true } : {}) }) : null;
+  const scope = options.enableRetrieval === true ? createRetrievalScope({ ...approvedRetrievalSnapshot(input, options.approvedRetrievalSnapshot), context: input.context ?? [] }, { ...readerLimits, signal, ...(options.optimizeReviewCalls === true ? { reuseResults: true } : {}) }) : null;
   const report = { schemaVersion: 1, snapshotId: input.id, vcs: input.vcs, status: 'completed', files: [], findings: [], limitations: [], modelCalls: 0 };
   validateBusinessRequirement(input.businessRequirement);
   if(input.businessRequirement!==undefined)report.businessRequirement={hash:hash(input.businessRequirement),bytes:Buffer.byteLength(input.businessRequirement),status:'untrusted-constraint'};
@@ -612,7 +614,7 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
           for (const finding of generated.findings) finding.verification = { status: 'pending', causality: 'unverified' };
           try {
             activeStage = 'verification';
-            const verdicts = await verificationLoop(trackedModel, { ...request, onProtocolEvent, reviewPhase: 'verification' }, generated.findings, stageScope('verification:' + file.id), {
+            let verdicts = await verificationLoop(trackedModel, { ...request, onProtocolEvent, reviewPhase: 'verification' }, generated.findings, stageScope('verification:' + file.id), {
               correctProtocol:options.correctProtocol===true,maxRounds:maxRetrievalRounds,maxInputBytes, beforeCall, onBudgetLimited, yieldOnBudget: options.enableStageContinuation === true,
               enableMigrationRegression: options.enableMigrationRegression === true, migrationContracts: report.migrationContracts?.contracts ?? [], migrationSnapshot: input,
               onMigrationSeeds: event => {
@@ -626,7 +628,9 @@ export async function reviewSnapshot(snapshot, model, options = {}) {
               onTruncated: () => { result.limitations.push({ fileId: file.id, text: '复核检索结果达到数量上限' }); },
             });
             request.signal.throwIfAborted();
-            generated.findings.forEach((finding, i) => { finding.verification = { status: 'completed', ...verdicts[i] }; });
+            verdicts = await runCounterVerification(trackedModel, { ...request, onProtocolEvent, reviewPhase:'verification' }, generated.findings, verdicts, stageScope('verification:' + file.id), { enabled:options.enableCounterVerification === true, maxRounds:maxRetrievalRounds,maxInputBytes,beforeCall,onBudgetLimited, isFatalError:error=>checkpointFailed||error?.code==='MODEL_ARTIFACT_FAILED' });
+            request.signal.throwIfAborted();
+            generated.findings.forEach((finding, i) => { finding.verification = { status: verdicts[i].counterVerification?.status === 'incomplete' ? 'incomplete' : 'completed', ...verdicts[i] }; });
             if (verdicts.some(v => v.verdict === 'supported' && v.regression?.classification === 'uncertain')) result.limitations.push({ fileId: file.id, text: '部分模型支持候选缺少充分前后对照，不能确认由本次变更引入' });
             if (verdicts.some(v => v.verdict === 'uncertain')) result.limitations.push({ fileId: file.id, text: '部分候选复核仍不确定，不能视为已确认或已排除' });
           } catch (error) {

package/src/service.mjs

@@ -1,4 +1,6 @@
 import { previewValidity } from './preview-validity.mjs';
+import { reviewEffortPolicy } from './review-effort.mjs';
+import { prepareReviewHistory, finishReviewHistory } from './review-history.mjs';
 import { configureWireBudget } from './model-wire-budget.mjs';
 import {REVIEW_RUNTIME} from './runtime-identity.mjs';
 import { buildResumeState, validateResumeState, resumePreview } from './review-resume.mjs';
@@ -56,10 +58,11 @@ function buildPreviewNotice(snapshot, options, enableRiskPlanning, changesConcur
   return scopeNotice + (snapshot.history?.vcs==='svn'&&options.autoContext===true?'SVN历史autoContext为精确依赖定位读取固定版本父目录有界清单，包含同目录非匹配名字元数据；仅匹配捕获正文发送模型，不扫描全仓，不用工作树替代历史版本。':'') + (options.oldContextPaths !== undefined ? 'oldContextPaths仅为baseline旧侧正文，无目标侧替代；选中变更复用原old身份，旧侧不能证明新侧行为。' : '') + (snapshot.callerDiscovery ? 'callerScopePaths已授权预览读取限定目录内tracked候选正文，包括不匹配文件；非匹配正文不发送模型，匹配捕获上下文会发送。仅字面引用导航，不是函数调用或完整调用覆盖。' : '') + (enableRiskPlanning ? '执行按plan阈值决定风险假设规划，小变更可跳过独立规划但仍主审并复核；计划不是证据，所有阶段共享原预算。' : '') + `执行会向上述模型提供方发送可审查文件两侧内容、预览列出的显式/自动上下文、所选项目规则全文及预览业务需求文本。模型可在该快照范围内多轮只读检索，不读取范围外文件；候选生成后会进行证据与反证复核，两阶段各最多${maxRetrievalRounds}轮检索；独立文件审查链最多${changesConcurrency}条并发，不设插件内部默认时间或总模型调用次数截止，遵循宿主/用户取消；输入字节和检索轮次保护仍保留；复核不能证明缺陷成立。plan.reviewRounds为独立审查工作量，非模型reasoning effort；后续轮不带首轮风险计划，所有轮共享原超时与预算。plan仅预检初始输入，ready不代表已审查；minimumCalls不含后续检索/复核/动态业务综合；多文件可先进行业务分组，分组失败保留原组并记录限制，动态综合数执行前未知，实际预算可能不足。请先内部核对预览与当前人类授权。用户已明确要求审核且范围、模型和发送目的地一致时直接执行，不重复询问确认；只要求预览或明确要求等待确认时不得执行，超出授权或边界不明确时才询问。宿主权限和快照／身份校验仍须通过。`;
 }
 
-function createSessionReviewService(llm, { capture = captureSnapshot, hostChildren, wholeScopeConcurrency = 2, executionStrategy = 'staged', maxInputBytes = 96 * 1024, now = Date.now, ttlMs = 300000, maxPreviews = 8, allowModelSending = false, enableRiskPlanning = false, skipSmallRiskPlans = true, reviewRounds = 1, enableBusinessGrouping = false, enableAnchorCorrection = false, changesConcurrency = 2, maxRetrievalRounds = 3, riskPlanningMode = 'separate', readerBudgetPolicy = 'fixed', optimizeReviewCalls = false, enablePrimarySeeds = false, focusPrimaryContext = false, enableSearchSeeds = false, nativeOutputTools = false, enableGroupPrimary = false, enableEvidenceContext = false, inlineInteractionRisks = false, enableMigrationContracts = false, enableMigrationRegression = false, enableGroupInteractions = false, enableStageContinuation = false, authorize = async () => false } = {}) {
+function createSessionReviewService(llm, { capture = captureSnapshot, reviewEffort = 'auto', enableCounterVerification = false, hostChildren, wholeScopeConcurrency = 2, executionStrategy = 'staged', maxInputBytes = 96 * 1024, now = Date.now, ttlMs = 300000, maxPreviews = 8, allowModelSending = false, enableRiskPlanning = false, skipSmallRiskPlans = true, reviewRounds = 1, enableBusinessGrouping = false, enableAnchorCorrection = false, changesConcurrency = 2, maxRetrievalRounds = 3, riskPlanningMode = 'separate', readerBudgetPolicy = 'fixed', optimizeReviewCalls = false, enablePrimarySeeds = false, focusPrimaryContext = false, enableSearchSeeds = false, nativeOutputTools = false, enableGroupPrimary = false, enableEvidenceContext = false, inlineInteractionRisks = false, enableMigrationContracts = false, enableMigrationRegression = false, enableGroupInteractions = false, enableStageContinuation = false, authorize = async () => false } = {}) {
   for (const value of [ttlMs, maxPreviews]) if (!Number.isSafeInteger(value) || value < 1) throw new Error('Invalid preview limit');
   if (!Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1 || maxInputBytes > 4 * 1024 * 1024) throw new Error('Invalid configured input capacity');
   if (!['staged', 'whole-scope'].includes(executionStrategy)) throw new Error('Invalid review execution strategy');
+  if (!['auto','quick','standard','deep'].includes(reviewEffort) || typeof enableCounterVerification !== 'boolean') throw new Error('Invalid review effort policy');
   wholeScopeConcurrency = reviewConcurrency(wholeScopeConcurrency);
   changesConcurrency = reviewConcurrency(changesConcurrency);
   maxRetrievalRounds = reviewRetrievalRounds(maxRetrievalRounds);
@@ -68,7 +71,7 @@ function createSessionReviewService(llm, { capture = captureSnapshot, hostChildr
   for (const value of [optimizeReviewCalls, enablePrimarySeeds, focusPrimaryContext, enableSearchSeeds, nativeOutputTools, enableGroupPrimary, enableEvidenceContext, inlineInteractionRisks, enableMigrationContracts, enableMigrationRegression, enableGroupInteractions, enableStageContinuation]) if (typeof value !== 'boolean') throw new Error('Invalid review optimization option');
   const lifetime = new AbortController();
   const bind = exec => ({ ...exec, signal: exec.signal ? AbortSignal.any([exec.signal, lifetime.signal]) : lifetime.signal });
-  const resumeOptions = (options, route, rounds) => ({ captureOptions: options, route, runtime: REVIEW_RUNTIME, instructionsHash: hash(REVIEW_INSTRUCTIONS), execution: { executionStrategy, maxInputBytes, wholeScopeConcurrency, rounds, enableRiskPlanning, skipSmallRiskPlans, enableBusinessGrouping, enableAnchorCorrection, changesConcurrency, maxRetrievalRounds, riskPlanningMode, readerBudgetPolicy, optimizeReviewCalls, enablePrimarySeeds, focusPrimaryContext, enableSearchSeeds, nativeOutputTools, enableGroupPrimary, enableEvidenceContext, inlineInteractionRisks, enableMigrationContracts, enableMigrationRegression, enableGroupInteractions, enableStageContinuation } });
+  const resumeOptions = (options, route, rounds, effortMode, instructions) => ({ captureOptions: options, route, runtime: REVIEW_RUNTIME, instructionsHash: hash(instructions), execution: { reviewEffort:effortMode, enableCounterVerification, executionStrategy, maxInputBytes, wholeScopeConcurrency, rounds, enableRiskPlanning, skipSmallRiskPlans, enableBusinessGrouping, enableAnchorCorrection, changesConcurrency, maxRetrievalRounds, riskPlanningMode, readerBudgetPolicy, optimizeReviewCalls, enablePrimarySeeds, focusPrimaryContext, enableSearchSeeds, nativeOutputTools, enableGroupPrimary, enableEvidenceContext, inlineInteractionRisks, enableMigrationContracts, enableMigrationRegression, enableGroupInteractions, enableStageContinuation } });
   const previews = new Map();
   let busy = false;
   function prune() { for (const [id, p] of previews) if (p.expires <= now()) previews.delete(id); }
@@ -77,7 +80,7 @@ function createSessionReviewService(llm, { capture = captureSnapshot, hostChildr
       exec = bind(exec);
       exec.signal.throwIfAborted();
       if (busy) throw new Error('Review service busy');
-      if (!args || Object.keys(args).some(k => !['repositoryPath', 'selectedPaths', 'contextPaths', 'rulePaths', 'autoContext', 'commit', 'baseRevision', 'targetRevision','businessRequirement','callerScopePaths','oldContextPaths','reviewRounds','svnRevision','svnBaseRevision','svnTargetRevision','svnAllowNetwork','svnEffectiveMergeinfo','svnBasePath','svnTargetPath','svnReplacementBaseRevision','svnReplacementAllowNetwork','changeScope','resumeFromJobId'].includes(k))) throw new Error('Unknown preview argument');
+      if (!args || Object.keys(args).some(k => !['repositoryPath', 'selectedPaths', 'contextPaths', 'rulePaths', 'autoContext', 'commit', 'baseRevision', 'targetRevision','businessRequirement','callerScopePaths','oldContextPaths','reviewRounds','svnRevision','svnBaseRevision','svnTargetRevision','svnAllowNetwork','svnEffectiveMergeinfo','svnBasePath','svnTargetPath','svnReplacementBaseRevision','svnReplacementAllowNetwork','changeScope','resumeFromJobId','rereviewFromJobId','findingOutcomes','reviewEffort','rereviewScope'].includes(k))) throw new Error('Unknown preview argument');
       if (args.resumeFromJobId !== undefined && (typeof args.resumeFromJobId !== 'string' || !/^[a-f0-9-]{36}$/.test(args.resumeFromJobId))) throw new Error('Invalid resume job id');
       if (args.autoContext !== undefined && typeof args.autoContext !== 'boolean') throw new Error('Invalid autoContext option');
       for (const key of ['selectedPaths', 'contextPaths', 'rulePaths', 'oldContextPaths']) if (args[key] !== undefined && (!Array.isArray(args[key]) || args[key].length > (key === 'rulePaths' ? 4 : key === 'oldContextPaths' ? 20 : 200) || args[key].some(p => typeof p !== 'string'))) throw new Error('Invalid path list');
@@ -85,10 +88,22 @@ function createSessionReviewService(llm, { capture = captureSnapshot, hostChildr
       if (executionStrategy === 'whole-scope' && (rounds !== 1 || args.resumeFromJobId !== undefined)) throw new Error('Whole-scope requires fresh single-round changes review');
       validateBusinessRequirement(args.businessRequirement);
       if (args.callerScopePaths !== undefined) validateCallerScopes(args.callerScopePaths);
+      const effortMode = args.reviewEffort ?? reviewEffort;
+      if (!['auto','quick','standard','deep'].includes(effortMode)) throw new Error('Invalid review effort mode');
+      if (args.rereviewFromJobId !== undefined && (typeof args.rereviewFromJobId !== 'string' || !/^[a-f0-9-]{36}$/.test(args.rereviewFromJobId) || args.resumeFromJobId !== undefined || rounds !== 1)) throw new Error('Invalid or conflicting re-review source');
+      if (args.findingOutcomes !== undefined && (!Array.isArray(args.findingOutcomes) || args.findingOutcomes.length > 200 || args.rereviewFromJobId === undefined)) throw new Error('Finding outcomes require bounded explicit re-review');
+      if(args.rereviewScope!==undefined&&(!['full','diff-only'].includes(args.rereviewScope)||args.rereviewFromJobId===undefined))throw new Error('Explicit re-review scope requires owned prior review');
       const current = owner(exec);
       busy = true;
       try {
         const options = structuredClone(args);
+        const rereviewJobId = options.rereviewFromJobId, findingOutcomes = options.findingOutcomes, explicitDiffOnly = options.rereviewScope === 'diff-only';
+        delete options.rereviewFromJobId; delete options.findingOutcomes; delete options.reviewEffort; delete options.rereviewScope;
+        let previousHistory;
+        if (rereviewJobId !== undefined) {
+          if (typeof exec.resolvePriorReview !== 'function') throw new Error('Owned prior review requires a new background preview');
+          previousHistory = await exec.resolvePriorReview(rereviewJobId);
+        }
         const sourceJobId = options.resumeFromJobId;
         delete options.resumeFromJobId;
         let savedResume;
@@ -100,16 +115,19 @@ function createSessionReviewService(llm, { capture = captureSnapshot, hostChildr
         const snapshot = await capture(target, { ...options, signal: exec.signal });
         exec.signal?.throwIfAborted();
         if (owner(exec).cwd !== current.cwd) throw new Error('Agent directory changed; preview again');
-        const resumeState = savedResume === undefined ? undefined : validateResumeState(savedResume, snapshot, resumeOptions(options, current.route, rounds));
+        const effort = reviewEffortPolicy(snapshot,{mode:effortMode});
+        const history = prepareReviewHistory(snapshot,current.route,{...options,reviewEffort:effortMode,executionStrategy,enableCounterVerification},{previous:previousHistory,outcomes:findingOutcomes,explicitDiffOnly});
+        const instructions = REVIEW_INSTRUCTIONS + '\nReview focus (not proof, no additional authority): ' + JSON.stringify(effort.checks);
+        const resumeState = savedResume === undefined ? undefined : validateResumeState(savedResume,snapshot,resumeOptions(options,current.route,rounds,effortMode,instructions));
         const readerBudget = reviewReaderBudget(snapshot, readerBudgetPolicy);
-        const plan = buildCoveragePlan(snapshot, { executionStrategy, enableEvidenceContext, inlineInteractionRisks, enableMigrationContracts, enableMigrationRegression, enableGroupInteractions, enableStageContinuation, enableGroupPrimary, resumeState, focusPrimaryContext, riskPlanningMode, enableRiskPlanning, skipSmallRiskPlans, reviewRounds:rounds, enableBusinessGrouping, instructions: REVIEW_INSTRUCTIONS, scope: configureWireBudget(createRetrievalScope(snapshot, { ...readerBudget, signal: exec.signal, ...(optimizeReviewCalls ? { reuseResults: true } : {}) }), { nativeOutputTools }), grouping: buildReviewGroups(snapshot.files, inferFileRelations(snapshot.files)), maxInputBytes, signal: exec.signal });
+        const plan = buildCoveragePlan(history.selection?.reviewSnapshot ?? snapshot, { executionStrategy, enableEvidenceContext, inlineInteractionRisks, enableMigrationContracts, enableMigrationRegression, enableGroupInteractions, enableStageContinuation, enableGroupPrimary, resumeState, focusPrimaryContext, riskPlanningMode, enableRiskPlanning, skipSmallRiskPlans, reviewRounds:rounds, enableBusinessGrouping, instructions, scope: configureWireBudget(createRetrievalScope(snapshot, { ...readerBudget, signal: exec.signal, ...(optimizeReviewCalls ? { reuseResults: true } : {}) }), { nativeOutputTools }), grouping: buildReviewGroups(snapshot.files, inferFileRelations(snapshot.files)), maxInputBytes, signal: exec.signal });
         const useHostChildren = executionStrategy === 'whole-scope' && plan.primaryGroups.length > 1 && !!hostChildren;
         if (useHostChildren) await hostChildren.prepare();
         prune();
         while (previews.size >= maxPreviews) previews.delete(previews.keys().next().value);
         const previewId = randomUUID();
         const expires = now() + ttlMs;
-        previews.set(previewId, { ...current, target, options, rounds, snapshotId: snapshot.id, resumeState, sourceJobId, useHostChildren, expires });
+        previews.set(previewId, { ...current, target, options, rounds, snapshotId: snapshot.id, resumeState, sourceJobId, useHostChildren, effort, instructions, history, rereviewJobId, expires });
         return {
   ...(options.businessRequirement !== undefined
     ? { businessRequirement: { text: options.businessRequirement, hash: hash(options.businessRequirement), bytes: Buffer.byteLength(options.businessRequirement) } }
@@ -119,9 +137,11 @@ function createSessionReviewService(llm, { capture = captureSnapshot, hostChildr
   validForMs: ttlMs,
   ...(resumeState ? { resume: resumePreview(resumeState, sourceJobId) } : {}),
   plan,
+  reviewEffort: effort,
+  ...(rereviewJobId ? { rereview: { sourceJobId:rereviewJobId,cycle:history.previous.cycle+1,maxCycles:3,incremental:history.incremental,notice:'Historical metadata only; no prior approval, conclusions or receipts are reused. Navigation paths are not coverage.' } } : {}),
   snapshotId: snapshot.id,
   privateArtifacts: { enabled: typeof exec.onModelArtifact === 'function', sourceBearing: true, maxArtifactBytes: 1048576, maxJobBytes: 8388608, maxArtifacts: 4096, notice: 'Background jobs retain bounded untrusted model output outside the reviewed workspace; omissions/truncation explicit. Never included in ordinary status or reused as evidence; explicit consent required to read.' },
-  execution: { executionStrategy, ...(executionStrategy === 'whole-scope' ? { resumeSupported: false, maxInputBytes, batchExecution: useHostChildren ? 'host-subagents' : 'direct', batchConcurrency: useHostChildren ? Math.min(wholeScopeConcurrency, plan.primaryGroups.length) : 1 } : {}), nativeOutputTools, enableGroupPrimary, enableEvidenceContext, inlineInteractionRisks, enableMigrationContracts, enableMigrationRegression, enableGroupInteractions, enableStageContinuation, fileConcurrency: changesConcurrency, maxRetrievalRounds, ...(optimizeReviewCalls ? { riskPlanningMode, readerBudget: { policy: readerBudgetPolicy, ...readerBudget }, missingContextSeeds: enablePrimarySeeds, focusPrimaryContext, searchContextSeeds: enableSearchSeeds } : {}) },
+  execution: { executionStrategy, counterVerification: enableCounterVerification && effort.counterVerification.eligible, ...(executionStrategy === 'whole-scope' ? { resumeSupported: false, maxInputBytes, batchExecution: useHostChildren ? 'host-subagents' : 'direct', batchConcurrency: useHostChildren ? Math.min(wholeScopeConcurrency, plan.primaryGroups.length) : 1 } : {}), nativeOutputTools, enableGroupPrimary, enableEvidenceContext, inlineInteractionRisks, enableMigrationContracts, enableMigrationRegression, enableGroupInteractions, enableStageContinuation, fileConcurrency: changesConcurrency, maxRetrievalRounds, ...(optimizeReviewCalls ? { riskPlanningMode, readerBudget: { policy: readerBudgetPolicy, ...readerBudget }, missingContextSeeds: enablePrimarySeeds, focusPrimaryContext, searchContextSeeds: enableSearchSeeds } : {}) },
   repositoryRoot: snapshot.root,
   vcs: snapshot.vcs,
   ...(snapshot.changeScope ? { changeScope: snapshot.changeScope } : options.changeScope !== undefined ? { changeScope: options.changeScope } : {}),
@@ -174,14 +194,17 @@ function createSessionReviewService(llm, { capture = captureSnapshot, hostChildr
         exec.signal?.throwIfAborted();
         if (snapshot.id !== preview.snapshotId || owner(exec).cwd !== current.cwd) throw new Error('Files changed since preview; preview again');
         if (preview.useHostChildren && !hostChildren?.capability()) throw new Error('Approved child execution capability changed; preview again');
-        const resumeIdentity = resumeOptions(preview.options, preview.route, preview.rounds);
+        const resumeIdentity = resumeOptions(preview.options, preview.route, preview.rounds, preview.effort.mode, preview.instructions);
         const resumeState = preview.resumeState ? validateResumeState(preview.resumeState, snapshot, resumeIdentity) : undefined;
         if (await authorize({ snapshot, route: preview.route, exec }) !== true) throw new Error('Model sending approval denied or unavailable');
         exec.signal?.throwIfAborted();
         if (owner(exec).cwd !== current.cwd || JSON.stringify(owner(exec).route) !== JSON.stringify(preview.route)) throw new Error('Agent changed during approval');
         await exec.reviewCheckpoint?.({stage:'approved-manifest',snapshotId:snapshot.id,files:snapshot.files.map(f=>({fileId:f.id,path:f.path,status:f.eligibility==='reviewable'?'pending':f.eligibility}))});
-        const report = await reviewSnapshot(snapshot, createDshModel(llm, preview.route,{correctJson:true,useNativeTools:nativeOutputTools}), { executionStrategy, maxInputBytes, wholeScopeConcurrency, childExecution: preview.useHostChildren ? 'host-subagents' : undefined, createBatchModel: preview.useHostChildren ? args => hostChildren.create({ ...args, parent: exec.agent, route: preview.route, cwd: target }) : undefined, signal: exec.signal, enableRetrieval: true, enableGrouping: true, enableGroupPrimary, enableEvidenceContext, inlineInteractionRisks, enableMigrationContracts, enableMigrationRegression, enableGroupInteractions, enableStageContinuation, nativeOutputTools, enableVerification: true, riskPlanningMode, readerBudgetPolicy, optimizeReviewCalls, enablePrimarySeeds, focusPrimaryContext, enableSearchSeeds, enableRiskPlanning, skipSmallRiskPlans, reviewRounds:preview.rounds, enableBusinessGrouping, enableAnchorCorrection,changesConcurrency,maxRetrievalRounds,correctProtocol:true, onProgress:exec.reviewCheckpoint, resumeState, onModelArtifact: exec.onModelArtifact, onResumeCheckpoint: exec.reviewResumeCheckpoint ? async checkpoint => { await exec.reviewResumeCheckpoint(buildResumeState(snapshot, resumeIdentity, checkpoint)); } : undefined });
+        const report = await reviewSnapshot(preview.history.selection?.reviewSnapshot ?? snapshot, createDshModel(llm, preview.route,{correctJson:true,useNativeTools:nativeOutputTools}), { approvedRetrievalSnapshot: snapshot, instructions: preview.instructions, reviewEffort: preview.effort, enableCounterVerification: enableCounterVerification && preview.effort.counterVerification.eligible, executionStrategy, maxInputBytes, wholeScopeConcurrency, childExecution: preview.useHostChildren ? 'host-subagents' : undefined, createBatchModel: preview.useHostChildren ? args => hostChildren.create({ ...args, parent: exec.agent, route: preview.route, cwd: target }) : undefined, signal: exec.signal, enableRetrieval: true, enableGrouping: true, enableGroupPrimary, enableEvidenceContext, inlineInteractionRisks, enableMigrationContracts, enableMigrationRegression, enableGroupInteractions, enableStageContinuation, nativeOutputTools, enableVerification: true, riskPlanningMode, readerBudgetPolicy, optimizeReviewCalls, enablePrimarySeeds, focusPrimaryContext, enableSearchSeeds, enableRiskPlanning, skipSmallRiskPlans, reviewRounds:preview.rounds, enableBusinessGrouping, enableAnchorCorrection,changesConcurrency,maxRetrievalRounds,correctProtocol:true, onProgress:exec.reviewCheckpoint, resumeState, onModelArtifact: exec.onModelArtifact, onResumeCheckpoint: exec.reviewResumeCheckpoint ? async checkpoint => { await exec.reviewResumeCheckpoint(buildResumeState(snapshot, resumeIdentity, checkpoint)); } : undefined });
+        if (preview.history.selection?.plan.requiredReportStatus === 'partial') { if (report.status==='completed') report.status='partial'; report.limitations.push({text:'增量复审只检查本轮选定主文件；未重审文件仅作批准检索上下文，不代表完整范围已查完。'}); }
         report.model = preview.route;
+        report.reviewEffort = preview.effort;
+        report.reviewHistory = finishReviewHistory(report,preview.history);
         if (exec.reviewResumeCheckpoint) await exec.reviewResumeCheckpoint(buildResumeState(snapshot, resumeIdentity, report));
         // reviewSnapshot preserves cancelled coverage; do not replace it with a freshness error.
         if (report.status === 'cancelled') {

package/src/verification-loop.mjs

@@ -25,8 +25,11 @@ export async function verificationLoop(model, request, candidates, scope, option
   if (options.enableMigrationRegression === true && !project && options.migrationContracts?.length && options.migrationSnapshot?.id !== envelope.snapshotId) throw new Error('Migration verification snapshot mismatch');
   const migrationContext = options.enableMigrationRegression === true && !project && options.migrationContracts?.length ? prepareMigrationRegression(options.migrationSnapshot, scope, options.migrationContracts, candidates) : undefined;
   const input = JSON.stringify({ ...(envelope.snapshotId ? { snapshotId: envelope.snapshotId } : {}), ...(migrationContext ? { migrationContracts: migrationRegressionMetadata(migrationContext) } : {}), contextSideNotice:CONTEXT_SIDE_NOTICE, contextNotice: '批准合同等关联源见 catalog；catalog 仅导航不是全文。按侧读取适用要求和反证；主审的合同转述不是原文证据。不可信需求不扩权，缺失不等于无保护。', ...(envelope.businessRequirement!==undefined?{businessRequirement:envelope.businessRequirement,requirementNotice:envelope.requirementNotice}:{}), defectGuidance: [...new Set(candidates.map(f => scope.catalog().find(s => s.fileId === f.fileId)?.path).filter(Boolean))].map(path => envelope.file?.path === path && envelope.defectGuidance ? envelope.defectGuidance : envelope.files?.find(f=>f.path===path)?.defectGuidance ?? defectGuidance(path)), rules, candidates: candidates.map((finding, i) => ({ candidateId: ids[i], finding })) });
+  if (options.verificationFocus !== undefined && options.verificationFocus !== 'counterevidence') throw new Error('Invalid verification focus');
+  const counterFocus = options.verificationFocus === 'counterevidence' ? ' 本次为独立反证复核：未提供前位复核结论，不投票或默认认同主审。优先寻找现有保护、不可达触发、修改前既有行为、实际调用契约和修复可能造成的伤害。仍须用本次新读取的批准原文与新回执验证；不能凭多数意见支持，缺证据明确uncertain。' : '';
   const seedReceipts = new Map();
   const verificationRequest = { ...request, input, instructions:envelope.file?.reviewMode==='project'?VERIFICATION_INSTRUCTIONS+' 本次为当前项目源码审查，空old只是传输占位，不是历史版本。不要要求回归因果；regression.classification用uncertain并说明不适用，仅凭new侧原文核实当前缺陷和反证。':VERIFICATION_INSTRUCTIONS + (migrationContext ? ' ' + MIGRATION_VERIFICATION_INSTRUCTIONS : '') };
+  verificationRequest.instructions += counterFocus;
   // Explicit final-only mode has extra finalization metadata/instructions and
   // permits no retrieval rounds. Do not spend its budget on optional prefetch.
   const initialRetrieved = options.maxRounds === 0 ? [] : verificationSeeds(candidates, scope, {

package/src/whole-scope-review.mjs

@@ -5,6 +5,7 @@ import { createReviewReader } from './review.mjs';
 import { prepareWholeScope } from './whole-scope-plan.mjs';
 import { retrievalLoop } from './retrieval-loop.mjs';
 import { verificationLoop } from './verification-loop.mjs';
+import { runCounterVerification } from './counter-verification.mjs';
 import { validateGroupPrimary } from './group-primary.mjs';
 import { modelWireBudget } from './model-wire-budget.mjs';
 import { retrievalRounds } from './review-execution-policy.mjs';
@@ -178,10 +179,12 @@ export async function reviewWholeScope(snapshot, model, options = {}) {
       (report.orchestration.verifications ??= []).push(stage);
       try {
         gate(); // Do not prefetch receipt evidence for a vetoed model call.
-        const verdicts = await verificationLoop(trackedModel, { ...requestFor(generatedBatches[0]), reviewPhase: 'verification' }, candidates, reader, loopOptions(stage));
+        let verdicts = await verificationLoop(trackedModel, { ...requestFor(generatedBatches[0]), reviewPhase: 'verification' }, candidates, reader, loopOptions(stage));
         signal.throwIfAborted();
-        candidates.forEach((finding, i) => { finding.verification = { status: 'completed', ...verdicts[i] }; });
-        stage.status = stage.retrievalLimited ? 'pending' : 'completed';
+        verdicts = await runCounterVerification(trackedModel, { ...requestFor(generatedBatches[0]),reviewPhase:'verification' }, candidates, verdicts, reader, { ...loopOptions(stage),enabled:options.enableCounterVerification===true,isFatalError:error=>checkpointFailed||error?.code==='MODEL_ARTIFACT_FAILED' });
+        signal.throwIfAborted();
+        candidates.forEach((finding, i) => { finding.verification = { status: verdicts[i].counterVerification?.status === 'incomplete' ? 'incomplete' : 'completed', ...verdicts[i] }; });
+        stage.status = stage.retrievalLimited || verdicts.some(v => v.counterVerification?.status === 'incomplete') ? 'pending' : 'completed';
         if (verdicts.some(v => v.verdict === 'uncertain' || v.verdict === 'supported' && !['introduced', 'preexisting'].includes(v.regression?.classification))) report.limitations.push({ text: '部分候选缺少充分复核证据或前后对照，保留不确定，不强行确认支持或本次引入。' });
       } catch (error) {
         signal.throwIfAborted();