@wuyanbin/ai-code-review-cli-remote 1.0.28 → 1.0.30

package/dist/core/incremental.d.ts

@@ -1,4 +1,28 @@
-import type { AIComment, KnownFinding, ReconciledFinding } from "../types";
+import type { AIComment, KnownFinding, ReconciledFinding, RevalidationCandidate, RevalidationVerdict } from "../types";
+export interface ChangedLineRange {
+    start: number;
+    end: number;
+}
+export interface IncrementalChangeScope {
+    changedFiles: Set<string>;
+    /** `git diff --unified=3` 在新文件一侧的 hunk 行区间。 */
+    hunks: Map<string, ChangedLineRange[]>;
+}
+/**
+ * 解析 lastReviewedSha..当前评审 head 的 unified diff。hunk header 的新文件范围已经
+ * 包含 `--unified=3` 上下文，可直接用作“历史 finding 附近发生修改”的边界。
+ */
+export declare function parseIncrementalChangeScope(diff: string): IncrementalChangeScope;
+export declare function isLineInChangedHunk(scope: IncrementalChangeScope, file: string, line: number): boolean;
+/**
+ * 加载 sinceSha..HEAD 的文件集合与带上下文 hunk。sha 不存在、force-push、
+ * 浅克隆等任何失败均返回 null，由对账层执行保守降级。
+ */
+export declare function loadIncrementalChangeScope(sinceSha: string, options?: {
+    cwd?: string;
+    headSha?: string;
+    contextLines?: number;
+}): Promise<IncrementalChangeScope | null>;
 export interface ReconcileInput {
     /** 平台已知 findings（OPEN / WONT_FIX） */
     known: KnownFinding[];
@@ -11,6 +35,11 @@ export interface ReconcileInput {
      * null 表示无法计算（force-push / 浅克隆），新 finding 一律 blocking（安全优先）。
      */
     changedFiles: Set<string> | null;
+    /**
+     * 自上次评审以来的新侧 hunk 范围；undefined 兼容旧调用，null 表示范围不可用。
+     * 历史 finding 只在可靠锚点落入 hunk 时进行修复重验证。
+     */
+    changeScope?: IncrementalChangeScope | null;
     /** 首轮评审（无 lastReviewedSha）：所有新 finding 均为 baseline，blocking */
     baseline: boolean;
     /** GitLab 上被人工 resolve 的 fingerprint 集合 */
@@ -23,12 +52,33 @@ export interface ReconcileResult {
     activeComments: AIComment[];
     /** OPEN 且 blocking，作为准入判定输入 */
     blockingComments: AIComment[];
+    /**
+     * 以「未触碰区域漏报」理由保活的 finding：几何判定无法收口，
+     * 交由模型复核裁决（判定 FIXED 时通过 applyRevalidationVerdicts 收口）。
+     */
+    revalidationCandidates: RevalidationCandidate[];
+    /**
+     * 本轮真正新建的 finding（仅 newComments 产物，不含 severity 迁移记录）：
+     * 语义判重的新报侧候选（见 applySemanticMatches）。
+     */
+    newFindings: ReconciledFinding[];
     stats: {
         new: number;
         kept: number;
         fixed: number;
         wontFix: number;
         dropped: number;
+        keptReported: number;
+        keptUntouched: number;
+        fixedRevalidated: number;
+        fixedMissingAnchor: number;
+        severityMigrated: number;
+        ambiguousAnchor: number;
+        revalidatedFixed: number;
+        revalidatedPresent: number;
+        revalidatedUnsure: number;
+        semanticWontFix: number;
+        semanticDuplicate: number;
     };
 }
 /**
@@ -40,11 +90,28 @@ export interface ReconcileResult {
  * 不参与准入），以保证同 commit 重跑幂等、避免模型非确定性补报造成"打地鼠"。
  */
 export declare function reconcileFindings(input: ReconcileInput): ReconcileResult;
+/**
+ * 将模型复核判定应用到对账结果：仅对复核候选且判定为 FIXED 的 finding 收口，
+ * PRESENT / UNSURE / 判定缺失一律保活，使复核失败时行为与未引入复核完全一致。
+ */
+export declare function applyRevalidationVerdicts(result: ReconcileResult, verdicts: Map<string, RevalidationVerdict>): ReconcileResult;
+export interface SemanticMatch {
+    newFingerprint: string;
+    knownFingerprint: string;
+}
+/**
+ * 将语义判重命中应用到对账结果：命中 WONT_FIX 的新报以新指纹落库为终态
+ * （终态跨指纹粘性），命中仍存活 OPEN 的新报按重复整体移除；命中方本轮已
+ * 收口（FIXED）时不压制（问题迁移按新 finding 处理）。每条新报至多处置一次，
+ * WONT_FIX 优先。
+ */
+export declare function applySemanticMatches(result: ReconcileResult, matches: SemanticMatch[]): ReconcileResult;
 /**
  * 计算 sinceSha..HEAD 改动的文件集合（normalize 后路径）。
  * sha 不存在（force-push / 浅克隆）等任何失败都返回 null，由调用方按全量 blocking 处理。
  */
 export declare function listChangedFiles(sinceSha: string, options?: {
     cwd?: string;
+    headSha?: string;
 }): Promise<Set<string> | null>;
 //# sourceMappingURL=incremental.d.ts.map

package/dist/core/incremental.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"incremental.d.ts","sourceRoot":"","sources":["../../src/core/incremental.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAMlB,MAAM,WAAW,cAAc;IAC7B,qCAAqC;IACrC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,sBAAsB;IACtB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IACjC,+DAA+D;IAC/D,QAAQ,EAAE,OAAO,CAAC;IAClB,2CAA2C;IAC3C,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,kBAAkB;IAClB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,8BAA8B;IAC9B,cAAc,EAAE,SAAS,EAAE,CAAC;IAC5B,+BAA+B;IAC/B,gBAAgB,EAAE,SAAS,EAAE,CAAC;IAC9B,KAAK,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAqBD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,eAAe,CAoIxE;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAqB7B"}
+{"version":3,"file":"incremental.d.ts","sourceRoot":"","sources":["../../src/core/incremental.ts"],"names":[],"mappings":"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"}

package/dist/core/incremental.js

@@ -1,12 +1,135 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIncrementalChangeScope = parseIncrementalChangeScope;
+exports.isLineInChangedHunk = isLineInChangedHunk;
+exports.loadIncrementalChangeScope = loadIncrementalChangeScope;
 exports.reconcileFindings = reconcileFindings;
+exports.applyRevalidationVerdicts = applyRevalidationVerdicts;
+exports.applySemanticMatches = applySemanticMatches;
 exports.listChangedFiles = listChangedFiles;
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
 const diff_1 = require("./diff");
 const identity_1 = require("../shared/identity");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/**
+ * 解析 lastReviewedSha..当前评审 head 的 unified diff。hunk header 的新文件范围已经
+ * 包含 `--unified=3` 上下文，可直接用作“历史 finding 附近发生修改”的边界。
+ */
+function parseIncrementalChangeScope(diff) {
+    const changedFiles = new Set((0, diff_1.getChangedFiles)(diff).map(diff_1.normalizePath));
+    const hunks = new Map();
+    let currentFile = null;
+    for (const raw of diff.split("\n")) {
+        if (raw.startsWith("diff --git ")) {
+            currentFile = null;
+            const match = /^diff --git a\/(.+?) b\/(.+)$/.exec(raw);
+            if (match)
+                currentFile = (0, diff_1.normalizePath)(match[2]);
+            continue;
+        }
+        if (raw.startsWith("+++ b/")) {
+            currentFile = (0, diff_1.normalizePath)(raw.slice("+++ b/".length));
+            changedFiles.add(currentFile);
+            continue;
+        }
+        if (!currentFile || !raw.startsWith("@@"))
+            continue;
+        const match = /^@@\s+\-\d+(?:,\d+)?\s+\+(\d+)(?:,(\d+))?\s+@@/.exec(raw);
+        if (!match)
+            continue;
+        const start = Number(match[1]);
+        const count = match[2] === undefined ? 1 : Number(match[2]);
+        if (!Number.isFinite(start) || !Number.isFinite(count) || count < 0) {
+            continue;
+        }
+        const ranges = hunks.get(currentFile) ?? [];
+        if (count === 0) {
+            // 纯删除：新侧无行，删除点位于 start 与 start+1 之间，
+            // 取该邻域，使"用删除代码修复"同样算作附近已修改。
+            ranges.push({ start: Math.max(1, start), end: start + 1 });
+        }
+        else {
+            ranges.push({ start, end: start + count - 1 });
+        }
+        hunks.set(currentFile, ranges);
+    }
+    return { changedFiles, hunks };
+}
+function isLineInChangedHunk(scope, file, line) {
+    const ranges = scope.hunks.get((0, diff_1.normalizePath)(file));
+    return (ranges?.some((range) => line >= range.start && line <= range.end) ?? false);
+}
+/**
+ * 「附近」的上下文半径。几何判定只作为快路径：半径之外的语义修复由模型复核
+ * （revalidation）裁决，因此无需再按项目调参。
+ */
+const DEFAULT_INCREMENTAL_CONTEXT = 3;
+const GIT_EXEC_OPTIONS = { maxBuffer: 10 * 1024 * 1024 };
+async function hasCommit(sha, cwd) {
+    try {
+        await execFileAsync("git", ["cat-file", "-e", `${sha}^{commit}`], {
+            ...GIT_EXEC_OPTIONS,
+            cwd,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 浅克隆（GIT_DEPTH）或 force-push 后 lastReviewedSha 可能不在本地历史中，
+ * 此时增量范围会退化为不可用并让已修复 finding 一直保活。先探测，缺失时
+ * 逐级加深，仍取不到才放弃。
+ */
+async function ensureCommitAvailable(sha, cwd) {
+    if (await hasCommit(sha, cwd))
+        return true;
+    const attempts = [
+        ["fetch", "--deepen=200", "--quiet"],
+        ["fetch", "--unshallow", "--quiet"],
+    ];
+    for (const args of attempts) {
+        try {
+            await execFileAsync("git", args, { ...GIT_EXEC_OPTIONS, cwd });
+        }
+        catch {
+            // 非浅克隆、无远端或无权限时该次加深无意义，继续尝试下一种
+        }
+        if (await hasCommit(sha, cwd)) {
+            console.error(`[findings] deepened local history to reach lastReviewedSha via "git ${args.join(" ")}"`);
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 加载 sinceSha..HEAD 的文件集合与带上下文 hunk。sha 不存在、force-push、
+ * 浅克隆等任何失败均返回 null，由对账层执行保守降级。
+ */
+async function loadIncrementalChangeScope(sinceSha, options = {}) {
+    if (!(await ensureCommitAvailable(sinceSha, options.cwd))) {
+        console.error(`[findings] incremental diff unavailable: lastReviewedSha ${sinceSha} not reachable locally (shallow clone or force-push), keeping reliable known findings OPEN`);
+        return null;
+    }
+    const contextLines = options.contextLines ?? DEFAULT_INCREMENTAL_CONTEXT;
+    try {
+        const headSha = options.headSha?.trim() || "HEAD";
+        const { stdout } = await execFileAsync("git", [
+            "diff",
+            `--unified=${contextLines}`,
+            `${sinceSha}..${headSha}`,
+            "--",
+        ], { ...GIT_EXEC_OPTIONS, cwd: options.cwd });
+        return parseIncrementalChangeScope(stdout);
+    }
+    catch (error) {
+        console.error(`[findings] incremental diff unavailable (${error instanceof Error ? error.message.split("\n")[0] : error}), treating all new findings as blocking`);
+        return null;
+    }
+}
+const SEVERITY_RANK = { P0: 2, P1: 1, P2: 0 };
 function codeKey(file, code) {
     const trimmed = code?.trim();
     if (!trimmed)
@@ -25,6 +148,42 @@ function toComment(finding) {
             : {}),
     };
 }
+function resolveHistoricalAnchor(added, finding) {
+    const code = finding.code?.trim();
+    if (!code)
+        return { kind: "missing" };
+    const lines = added.get((0, diff_1.normalizePath)(finding.file));
+    if (!lines?.length)
+        return { kind: "missing" };
+    const exact = lines.find((item) => item.line === finding.line);
+    if (exact?.content.trim() === code) {
+        return { kind: "exact", line: exact.line, code: exact.content };
+    }
+    const matches = lines.filter((item) => item.content.trim() === code);
+    if (matches.length === 1) {
+        return {
+            kind: "unique",
+            line: matches[0].line,
+            code: matches[0].content,
+        };
+    }
+    return { kind: matches.length > 1 ? "ambiguous" : "missing" };
+}
+function findingFromComment(comment) {
+    return {
+        fingerprint: (0, identity_1.buildCommentFingerprint)(comment),
+        file: (0, diff_1.normalizePath)(comment.file),
+        line: comment.line,
+        severity: comment.severity,
+        message: comment.message,
+        status: "OPEN",
+        blocking: true,
+        ...(comment.code !== undefined ? { code: comment.code } : {}),
+        ...(comment.suggestion !== undefined
+            ? { suggestion: comment.suggestion }
+            : {}),
+    };
+}
 /**
  * 将本次模型输出与已知 finding 集合对账，得到收敛后的状态全集。
  *
@@ -35,56 +194,89 @@ function toComment(finding) {
  */
 function reconcileFindings(input) {
     const added = (0, diff_1.collectAddedLines)(input.diff);
-    /** 在 diff 新增行中按内容定位代码行，用于漏报保活与行号重对齐 */
-    const findAddedLine = (file, code) => {
-        const trimmed = code?.trim();
-        if (!trimmed)
-            return null;
-        const lines = added.get((0, diff_1.normalizePath)(file));
-        if (!lines)
-            return null;
-        return lines.find((item) => item.content.trim() === trimmed)?.line ?? null;
-    };
-    // 模型未返回 code 时从 diff 新增行回填，保证 fingerprint 稳定、下次可比对
-    const current = input.current.map((comment) => {
-        if (comment.code?.trim())
-            return comment;
-        const lines = added.get((0, diff_1.normalizePath)(comment.file));
-        const hit = lines?.find((item) => item.line === comment.line);
-        return hit ? { ...comment, code: hit.content } : comment;
-    });
-    // 双级索引：fingerprint 精确匹配优先，file+code 兜底（容忍 severity 翻动）
+    // 不按行号回填 code：对齐层已保证 accepted 评论携带 diff 真实行内容，
+    // 仅凭行号补 code 等于重新引入无证据锚点。
+    const current = input.current;
+    const anchors = new Map(input.known.map((finding) => [
+        finding.fingerprint,
+        resolveHistoricalAnchor(added, finding),
+    ]));
+    // 双级索引：fingerprint 精确匹配优先，file+code 只在历史 finding 可唯一
+    // 配对时兜底。current 已经过严格新增行对齐，可作为显式复报证据。
     const byFingerprint = new Map();
     const byCode = new Map();
     for (const finding of input.known) {
         byFingerprint.set(finding.fingerprint, finding);
         const key = codeKey(finding.file, finding.code);
-        if (key && !byCode.has(key))
-            byCode.set(key, finding);
+        if (key) {
+            const candidates = byCode.get(key) ?? [];
+            candidates.push(finding);
+            byCode.set(key, candidates);
+        }
     }
     const matchedFingerprints = new Set();
     const matchedCurrent = new Map();
-    const newComments = [];
-    for (const comment of current) {
+    const consumed = new Set();
+    // 同一 known 只能被一条 current 占位，因此先让高 severity 参与配对：
+    // 否则谁占位取决于模型输出顺序，可能静默丢弃更严重的评论。
+    const matchOrder = [...current].sort((a, b) => SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity]);
+    for (const comment of matchOrder) {
         const fingerprint = (0, identity_1.buildCommentFingerprint)(comment);
-        const match = byFingerprint.get(fingerprint) ??
-            byCode.get(codeKey(comment.file, comment.code) ?? "\0") ??
-            null;
+        const exactFingerprint = byFingerprint.get(fingerprint);
+        const candidates = exactFingerprint
+            ? [exactFingerprint]
+            : byCode.get(codeKey(comment.file, comment.code) ?? "\0") ?? [];
+        const available = candidates.filter((candidate) => !matchedFingerprints.has(candidate.fingerprint));
+        const sameLine = available.filter((candidate) => {
+            const anchor = anchors.get(candidate.fingerprint);
+            return (anchor &&
+                (anchor.kind === "exact" || anchor.kind === "unique") &&
+                anchor.line === comment.line);
+        });
+        const match = (exactFingerprint &&
+            !matchedFingerprints.has(exactFingerprint.fingerprint)
+            ? exactFingerprint
+            : null) ??
+            (sameLine.length === 1 ? sameLine[0] : null) ??
+            (available.length === 1 ? available[0] : null);
         if (match) {
             // 同一 known 被多条 current 命中时首条生效，重复项丢弃
-            if (!matchedFingerprints.has(match.fingerprint)) {
-                matchedFingerprints.add(match.fingerprint);
-                matchedCurrent.set(match.fingerprint, comment);
-            }
+            matchedFingerprints.add(match.fingerprint);
+            matchedCurrent.set(match.fingerprint, comment);
+            consumed.add(comment);
         }
-        else {
-            newComments.push(comment);
+        else if (candidates.length > 0 && available.length === 0) {
+            // 同一 known 的重复 current 已被更高 severity 的评论消费。
+            consumed.add(comment);
         }
     }
+    // 保持模型输出顺序，使同 commit 重跑的 finding 序列稳定
+    const newComments = current.filter((comment) => !consumed.has(comment));
     const findings = [];
-    const stats = { new: 0, kept: 0, fixed: 0, wontFix: 0, dropped: 0 };
+    const revalidationCandidates = [];
+    const stats = {
+        new: 0,
+        kept: 0,
+        fixed: 0,
+        wontFix: 0,
+        dropped: 0,
+        keptReported: 0,
+        keptUntouched: 0,
+        fixedRevalidated: 0,
+        fixedMissingAnchor: 0,
+        severityMigrated: 0,
+        ambiguousAnchor: 0,
+        revalidatedFixed: 0,
+        revalidatedPresent: 0,
+        revalidatedUnsure: 0,
+        semanticWontFix: 0,
+        semanticDuplicate: 0,
+    };
     for (const known of input.known) {
         const base = { ...known };
+        const anchor = anchors.get(known.fingerprint) ?? { kind: "missing" };
+        if (anchor.kind === "ambiguous")
+            stats.ambiguousAnchor += 1;
         if (known.status === "WONT_FIX" || input.humanResolved.has(known.fingerprint)) {
             // 人工 dismiss 终态：即使模型再次报告也不复活
             findings.push({ ...base, status: "WONT_FIX" });
@@ -93,30 +285,87 @@ function reconcileFindings(input) {
         }
         const reported = matchedCurrent.get(known.fingerprint);
         if (reported) {
-            // 再次报告：行号/描述取最新，severity 保留已存值避免翻动
+            const touched = input.changeScope !== null &&
+                input.changeScope !== undefined &&
+                isLineInChangedHunk(input.changeScope, reported.file, reported.line);
+            if (reported.severity !== known.severity && touched) {
+                // severity 属于 fingerprint；迁移必须收口旧记录并创建新记录，
+                // 不能在旧 fingerprint 下原地改变 severity。
+                findings.push({ ...base, status: "FIXED" });
+                findings.push(findingFromComment(reported));
+                stats.fixed += 1;
+                stats.severityMigrated += 1;
+                continue;
+            }
+            if (reported.severity !== known.severity) {
+                // 未修改区域的 severity 抖动不覆盖历史状态或文案。
+                findings.push({
+                    ...base,
+                    status: "OPEN",
+                    file: (0, diff_1.normalizePath)(reported.file),
+                    line: reported.line,
+                    ...(reported.code !== undefined ? { code: reported.code } : {}),
+                });
+                stats.kept += 1;
+                stats.keptUntouched += 1;
+                continue;
+            }
+            // 同 severity 明确复报：行号、真实 code 与文案取本次可靠结果。
             findings.push({
                 ...base,
                 status: "OPEN",
+                file: (0, diff_1.normalizePath)(reported.file),
                 line: reported.line,
+                ...(reported.code !== undefined ? { code: reported.code } : {}),
                 message: reported.message,
                 ...(reported.suggestion !== undefined
                     ? { suggestion: reported.suggestion }
                     : {}),
             });
             stats.kept += 1;
+            stats.keptReported += 1;
             continue;
         }
-        const aliveLine = findAddedLine(known.file, known.code);
-        if (aliveLine !== null) {
-            // 模型漏报但代码未变：保持 OPEN（收敛契约核心），行号重对齐
-            findings.push({ ...base, status: "OPEN", line: aliveLine });
-            stats.kept += 1;
+        if (anchor.kind === "ambiguous" || anchor.kind === "missing") {
+            // 无法可靠定位时不允许任取第一行保活。
+            findings.push({ ...base, status: "FIXED" });
+            stats.fixed += 1;
+            stats.fixedMissingAnchor += 1;
             continue;
         }
-        // 代码行已从 diff 消失（或无 code 可比对）：判定已修复
-        findings.push({ ...base, status: "FIXED" });
-        stats.fixed += 1;
+        const touched = input.changeScope !== null &&
+            input.changeScope !== undefined &&
+            isLineInChangedHunk(input.changeScope, known.file, anchor.line);
+        if (touched) {
+            // 用户修改了锚点附近且模型未复报：按复核结果收口。
+            findings.push({ ...base, status: "FIXED" });
+            stats.fixed += 1;
+            stats.fixedRevalidated += 1;
+            continue;
+        }
+        // 未触碰区域或增量范围未知：保守视为模型漏报并保活，
+        // 同时进入模型复核候选，由复核裁决是否收口（见 applyRevalidationVerdicts）。
+        findings.push({
+            ...base,
+            status: "OPEN",
+            line: anchor.line,
+            code: anchor.code,
+        });
+        revalidationCandidates.push({
+            fingerprint: known.fingerprint,
+            file: (0, diff_1.normalizePath)(known.file),
+            line: anchor.line,
+            code: anchor.code,
+            severity: known.severity,
+            message: known.message,
+            ...(known.suggestion !== undefined
+                ? { suggestion: known.suggestion }
+                : {}),
+        });
+        stats.kept += 1;
+        stats.keptUntouched += 1;
     }
+    const newFindings = [];
     for (const comment of newComments) {
         const file = (0, diff_1.normalizePath)(comment.file);
         const inScope = input.baseline ||
@@ -127,28 +376,117 @@ function reconcileFindings(input) {
             stats.dropped += 1;
             continue;
         }
-        findings.push({
-            fingerprint: (0, identity_1.buildCommentFingerprint)(comment),
-            file,
-            line: comment.line,
-            severity: comment.severity,
-            message: comment.message,
-            status: "OPEN",
-            blocking: true,
-            ...(comment.code !== undefined ? { code: comment.code } : {}),
-            ...(comment.suggestion !== undefined
-                ? { suggestion: comment.suggestion }
-                : {}),
-        });
+        const created = findingFromComment({ ...comment, file });
+        findings.push(created);
+        newFindings.push(created);
         stats.new += 1;
     }
+    return {
+        findings,
+        ...buildCommentSets(findings),
+        revalidationCandidates,
+        newFindings,
+        stats,
+    };
+}
+function buildCommentSets(findings) {
     const open = findings
         .filter((f) => f.status === "OPEN")
         .sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
     return {
-        findings,
         activeComments: open.map(toComment),
         blockingComments: open.filter((f) => f.blocking).map(toComment),
+    };
+}
+/**
+ * 将模型复核判定应用到对账结果：仅对复核候选且判定为 FIXED 的 finding 收口，
+ * PRESENT / UNSURE / 判定缺失一律保活，使复核失败时行为与未引入复核完全一致。
+ */
+function applyRevalidationVerdicts(result, verdicts) {
+    if (verdicts.size === 0)
+        return result;
+    const candidates = new Set(result.revalidationCandidates.map((c) => c.fingerprint));
+    const stats = { ...result.stats };
+    const findings = result.findings.map((finding) => {
+        if (finding.status !== "OPEN" || !candidates.has(finding.fingerprint)) {
+            return finding;
+        }
+        const verdict = verdicts.get(finding.fingerprint);
+        if (verdict === "FIXED") {
+            stats.revalidatedFixed += 1;
+            stats.fixed += 1;
+            stats.kept -= 1;
+            stats.keptUntouched -= 1;
+            return { ...finding, status: "FIXED" };
+        }
+        if (verdict === "PRESENT")
+            stats.revalidatedPresent += 1;
+        else if (verdict === "UNSURE")
+            stats.revalidatedUnsure += 1;
+        return finding;
+    });
+    return {
+        findings,
+        ...buildCommentSets(findings),
+        revalidationCandidates: result.revalidationCandidates,
+        newFindings: result.newFindings,
+        stats,
+    };
+}
+/**
+ * 将语义判重命中应用到对账结果：命中 WONT_FIX 的新报以新指纹落库为终态
+ * （终态跨指纹粘性），命中仍存活 OPEN 的新报按重复整体移除；命中方本轮已
+ * 收口（FIXED）时不压制（问题迁移按新 finding 处理）。每条新报至多处置一次，
+ * WONT_FIX 优先。
+ */
+function applySemanticMatches(result, matches) {
+    if (matches.length === 0)
+        return result;
+    const byFingerprint = new Map(result.findings.map((finding) => [finding.fingerprint, finding]));
+    const newFingerprints = new Set(result.newFindings.map((finding) => finding.fingerprint));
+    const statusRank = (match) => byFingerprint.get(match.knownFingerprint)?.status === "WONT_FIX" ? 0 : 1;
+    const ordered = [...matches].sort((a, b) => statusRank(a) - statusRank(b));
+    const handled = new Set();
+    const toWontFix = new Set();
+    const toDrop = new Set();
+    const stats = { ...result.stats };
+    for (const match of ordered) {
+        if (handled.has(match.newFingerprint))
+            continue;
+        if (!newFingerprints.has(match.newFingerprint))
+            continue;
+        const target = byFingerprint.get(match.newFingerprint);
+        const known = byFingerprint.get(match.knownFingerprint);
+        if (!target || target.status !== "OPEN" || !known)
+            continue;
+        if (known.status === "WONT_FIX") {
+            toWontFix.add(match.newFingerprint);
+            handled.add(match.newFingerprint);
+            stats.new -= 1;
+            stats.wontFix += 1;
+            stats.semanticWontFix += 1;
+        }
+        else if (known.status === "OPEN") {
+            toDrop.add(match.newFingerprint);
+            handled.add(match.newFingerprint);
+            stats.new -= 1;
+            stats.semanticDuplicate += 1;
+        }
+        // known 已 FIXED（本轮复核收口）：问题迁移，新报放行
+    }
+    if (handled.size === 0)
+        return result;
+    const findings = result.findings
+        .filter((finding) => !toDrop.has(finding.fingerprint))
+        .map((finding) => toWontFix.has(finding.fingerprint)
+        ? { ...finding, status: "WONT_FIX" }
+        : finding);
+    const newFindings = result.newFindings.filter((finding) => !handled.has(finding.fingerprint));
+    return {
+        findings,
+        ...buildCommentSets(findings),
+        revalidationCandidates: result.revalidationCandidates,
+        newFindings,
         stats,
     };
 }
@@ -157,18 +495,7 @@ function reconcileFindings(input) {
  * sha 不存在（force-push / 浅克隆）等任何失败都返回 null，由调用方按全量 blocking 处理。
  */
 async function listChangedFiles(sinceSha, options = {}) {
-    try {
-        const { stdout } = await execFileAsync("git", ["diff", "--name-only", `${sinceSha}..HEAD`], { cwd: options.cwd, maxBuffer: 10 * 1024 * 1024 });
-        const files = stdout
-            .split("\n")
-            .map((line) => line.trim())
-            .filter(Boolean)
-            .map(diff_1.normalizePath);
-        return new Set(files);
-    }
-    catch (error) {
-        console.error(`[findings] incremental diff unavailable (${error instanceof Error ? error.message.split("\n")[0] : error}), treating all new findings as blocking`);
-        return null;
-    }
+    const scope = await loadIncrementalChangeScope(sinceSha, options);
+    return scope?.changedFiles ?? null;
 }
 //# sourceMappingURL=incremental.js.map