@feng0531/dsh-code-review 0.88.0 → 0.90.0

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-child-broker.mjs

@@ -0,0 +1,65 @@
+// Process-local ownership broker. Fixtures exercise this contract, not host integration.
+const bindings = new Map();
+const revoked = new Set();
+const attachments = new WeakMap();
+const allowedTools = new Set(['review_snapshot', 'structured_output']);
+const failure = (message) => Object.assign(new Error(message), { code: 'REVIEW_CHILD_IDENTITY' });
+
+export function registerReviewChild(childId, binding) {
+  if (typeof childId !== 'string' || !childId || bindings.has(childId) || revoked.has(childId)) throw failure('Child id is invalid, already reserved, or revoked');
+  if (!binding || typeof binding.parentId !== 'string' || !binding.parentId || typeof binding.presetId !== 'string' || !binding.presetId || typeof binding.assertAgent !== 'function' || typeof binding.executeRequests !== 'function' || typeof binding.beforeModelCall !== 'function') throw failure('Incomplete restricted child binding');
+  const entry = { binding };
+  bindings.set(childId, entry);
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    bindings.delete(childId);
+    // Do not allow a late stream event to become an unrelated, unguarded call.
+    revoked.add(childId);
+  };
+}
+
+export function getReviewChildBinding(childId) {
+  if (revoked.has(childId)) throw failure('Review child binding was revoked');
+  return bindings.get(childId)?.binding;
+}
+export const getBinding = getReviewChildBinding;
+
+export function assertReviewChildAgent(childId, agent) {
+  const binding = getReviewChildBinding(childId);
+  const header = agent?.session?.header;
+  if (!binding || agent?.id !== childId || header?.id !== childId || header.parentSession !== binding.parentId || header.agentPreset !== binding.presetId) throw failure('Review child session, parent, or preset does not match its reservation');
+  binding.assertAgent(agent);
+  return binding;
+}
+
+export function executeReviewChildRequests(args, exec) {
+  const childId = exec?.agent?.id;
+  const binding = assertReviewChildAgent(childId, exec?.agent);
+  return binding.executeRequests(args, exec);
+}
+
+export function attachReviewChildMiddleware(ctx) {
+  if (attachments.has(ctx)) return attachments.get(ctx);
+  const dispose = ctx.on('llm/stream', function (options, next) {
+    const childId = options?.sessionId;
+    const binding = getReviewChildBinding(childId);
+    if (!binding) return next();
+    try {
+      const agent = ctx.get?.('agents')?.get?.(childId);
+      assertReviewChildAgent(childId, agent);
+      if (!Array.isArray(options.tools) || !options.tools.some(tool => tool?.name === 'structured_output') || options.tools.some(tool => !allowedTools.has(tool?.name)) || new Set(options.tools.map(tool => tool.name)).size !== options.tools.length) throw failure('Restricted child model tools changed');
+      // Reservation/route/budget guard executes synchronously, before next dispatch.
+      const result = binding.beforeModelCall(options);
+      if (result && typeof result.then === 'function') throw failure('Child model-call guard must be synchronous');
+    } catch (error) {
+      // Poison the owner's activation even when failure precedes its budget guard.
+      binding.onFatal?.(error);
+      throw error;
+    }
+    return next();
+  });
+  attachments.set(ctx, dispose);
+  return dispose;
+}

package/src/review-child-plugin.mjs

@@ -0,0 +1,32 @@
+import { assertReviewChildAgent, executeReviewChildRequests } from './review-child-broker.mjs';
+
+export const name = 'dsh-code-review-restricted-child';
+export const inject = ['tools'];
+
+export function registerSnapshotTool(ctx) {
+  // Presets are shared generations: never capture a particular child here.
+  // Restrict inherited tools before resolution; host-owned structured_output remains.
+  ctx.tools.register({
+    name: 'review_snapshot',
+    description: 'Internal tool for registered review children only; ordinary parent/other agents cannot call it. Read only the approved review snapshot using catalog retrieval requests. No filesystem, shell, network, or additional agents.',
+    parameters: { type: 'object', additionalProperties: false, properties: { requests: { type: 'array', items: { type: 'object' } } }, required: ['requests'] },
+    output: {
+      schema: { type: 'object', additionalProperties: false, properties: { json: { type: 'string' } }, required: ['json'] },
+      render: (_args, value) => [{ type: 'text', text: value.json }],
+    },
+    async execute(args, exec) {
+      const result = await executeReviewChildRequests(args, exec);
+      // Recheck after asynchronous business logic: revoked work cannot leak a result.
+      assertReviewChildAgent(exec?.agent?.id, exec?.agent);
+      return { json: JSON.stringify(result) };
+    },
+  });
+}
+export function apply(ctx) {
+  ctx.tools.restrict({ allow: ['review_snapshot'] });
+  // Identity only: installation above must precede the host's tool assembly.
+  ctx.on('agent/pre-step', ({ agent }, next) => {
+    assertReviewChildAgent(agent?.id, agent);
+    return next();
+  });
+}

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}={}){