@gitkraken/conflict-tools 0.2.4-beta.9 → 0.4.0

package/dist/git/port-dispatch.d.ts

@@ -1,9 +1,21 @@
-import { BlameOptions, ConflictDiffOptions, ConflictGitPort, GrepOptions, LogOptions, OpOptions, ShowFileOptions, ShowOptions, UnmergedEntry } from "../ports/git.js";
+import { BlameOptions, ConflictDiffOptions, ConflictGitPort, GrepOptions, LogOptions, OpOptions, ShowFileOptions, ShowOptions, UnmergedEntry, UnmergedStages } from "../ports/git.js";
 
 //#region src/git/port-dispatch.d.ts
 declare function readFile(git: ConflictGitPort, path: string, opts?: OpOptions): Promise<string>;
 declare function showFile(git: ConflictGitPort, ref: string, path: string, opts?: ShowFileOptions): Promise<string>;
 declare function unmergedEntries(git: ConflictGitPort, opts?: OpOptions): Promise<UnmergedEntry[]>;
+/**
+ * Reads the index-stage signature of every unmerged path in one `git ls-files -u` call. Used when a
+ * host-supplied `unmergedEntries` op reports no signature of its own. Returns an empty map when the
+ * port has no `exec` fallback.
+ */
+declare function unmergedStages(git: ConflictGitPort, opts?: OpOptions): Promise<Map<string, UnmergedStages>>;
+/**
+ * Reads the effective `merge` gitattribute of every given path in one `git check-attr` call. Values are
+ * git's own: `set`, `unset`, `binary`, `unspecified`, or the name of a merge driver. Returns an empty map
+ * when the port has no `exec` fallback.
+ */
+declare function mergeAttributes(git: ConflictGitPort, paths: string[], opts?: OpOptions): Promise<Map<string, string>>;
 declare function mergeBase(git: ConflictGitPort, a: string, b: string, opts?: OpOptions): Promise<string>;
 declare function blame(git: ConflictGitPort, path: string, opts?: BlameOptions): Promise<string>;
 declare function grep(git: ConflictGitPort, pattern: string, opts?: GrepOptions): Promise<string>;
@@ -16,4 +28,4 @@ declare function stageFiles(git: ConflictGitPort, paths: string[], opts?: OpOpti
 declare function checkoutFile(git: ConflictGitPort, path: string, side: 'ours' | 'theirs', opts?: OpOptions): Promise<void>;
 declare function removeFile(git: ConflictGitPort, path: string, opts?: OpOptions): Promise<void>;
 //#endregion
-export { blame, changedFiles, checkoutFile, diff, grep, log, mergeBase, readFile, removeFile, show, showFile, stageFiles, unmergedEntries, writeFile };
+export { blame, changedFiles, checkoutFile, diff, grep, log, mergeAttributes, mergeBase, readFile, removeFile, show, showFile, stageFiles, unmergedEntries, unmergedStages, writeFile };

package/dist/git/port-dispatch.js

@@ -1,3 +1 @@
-import{ConflictGitPortMissingOpError as e}from"../ports/git.js";import{sliceLines as t,truncateLines as n,truncateMatches as r}from"./truncation.js";const i={DD:`both-deleted`,AU:`added-by-us`,UD:`deleted-by-them`,UA:`added-by-them`,DU:`deleted-by-us`,AA:`both-added`,UU:`both-modified`};function a(e){return i[e]??e}function o(e){return`Search capped at ${e} matches. There may be more — narrow with a more specific pattern or path.`}function s(t,n){throw new e(t,n)}function c(e,t){return e!=null&&t!=null?`startLine=${e}, endLine=${t}`:e==null?`endLine=${t}`:`startLine=${e}`}async function l(e,t,n){return e.readFile?e.readFile(t,n):s(`readFile`)}async function u(e,r,i,a){let o;if(e.showFile)o=await e.showFile(r,i,a);else if(e.exec){let n=t(await e.exec([`show`,`${r}:${i}`],{signal:a?.signal}),a?.startLine,a?.endLine);if(!n.ok)return n.reason===`invalid-range`?`[Invalid range: ${c(n.startLine,n.endLine)} (startLine must be <= endLine).]`:`[Range out of bounds: file has ${n.total} lines, requested ${c(n.startLine,n.endLine)}.]`;o=n.content}else return s(`showFile`);return n(o,1e3,`Output capped at 1000 lines. Use startLine/endLine to read other regions of the file.`)}async function d(e,t){if(e.unmergedEntries)return e.unmergedEntries(t);if(e.exec){let n=await e.exec([`status`,`--porcelain=v2`],{signal:t?.signal}),r=[];for(let e of n.split(`
-`)){if(!e.startsWith(`u `))continue;let t=e.split(` `),n=t[1]??``,i=t.slice(10).join(` `);r.push({path:i,reason:a(n)})}return r}return s(`unmergedEntries`)}async function f(e,t,n,r){return e.mergeBase?e.mergeBase(t,n,r):e.exec?(await e.exec([`merge-base`,`--`,t,n],{signal:r?.signal})).trim():s(`mergeBase`)}async function p(e,t,r){let i=r?.startLine,a=r?.endLine,o=Number.isFinite(i),l=Number.isFinite(a);if(o&&l&&i>a)return`[Invalid range: ${c(i,a)} (startLine must be <= endLine).]`;let u;if(e.blame)u=await e.blame(t,r);else if(e.exec){let n=[`blame`,`--porcelain`],s=o?Math.max(1,i):void 0,c=l?Math.max(1,a):void 0;s!=null&&c!=null?n.push(`-L`,`${s},${c}`):s==null?c!=null&&n.push(`-L`,`1,${c}`):n.push(`-L`,`${s},`),r?.ref&&n.push(r.ref),n.push(`--`,t),u=await e.exec(n,{signal:r?.signal})}else return s(`blame`);return n(u,1e3,`Output capped at 1000 lines. Use startLine/endLine to inspect other regions.`)}async function m(e,t,n){let i=n?.maxResults,a=i!=null&&Number.isFinite(i)?Math.min(Math.max(1,i),100):100,c;if(e.grep)c=await e.grep(t,n);else if(e.exec){let r=[`grep`,`-n`,`--`,t];n?.ref&&r.push(n.ref),c=await e.exec(r,{signal:n?.signal})}else return s(`grep`);return r(c,a,o(a))}async function h(e,t,n,r){if(e.diff)return e.diff(t,n,r);if(e.exec){let i=[`diff`,t,n];return r?.path&&i.push(`--`,r.path),e.exec(i,{signal:r?.signal})}return s(`diff`)}async function g(e,t,n,r){return e.changedFiles?e.changedFiles(t,n,r):e.exec?(await e.exec([`diff`,`--name-only`,t,n],{signal:r?.signal})).split(`
-`).map(e=>e.trim()).filter(e=>e.length>0):s(`changedFiles`)}async function _(e,t){let r=t?.maxCount,i=r!=null&&Number.isFinite(r)?Math.min(Math.max(1,r),100):100,a;if(e.log)a=await e.log({...t,maxCount:i});else if(e.exec){let n=[`log`,`--oneline`,`-n`,String(i)];t?.ref&&n.push(t.ref),t?.path&&n.push(`--`,t.path),a=await e.exec(n,{signal:t?.signal})}else return s(`log`);return n(a,100,`Output capped at 100 commits. Use path to scope to a file or refine the ref range.`)}async function v(e,t,r){let i;if(e.show)i=await e.show(t,r);else if(e.exec){let n=[`show`,t];r?.path&&n.push(`--`,r.path),i=await e.exec(n,{signal:r?.signal})}else return s(`show`);return n(i,500,`Output capped at 500 lines. Use show_file_at_ref with startLine/endLine to read specific regions.`)}async function y(e,t,n,r){return e.writeFile?e.writeFile(t,n,r):s(`writeFile`)}async function b(e,t,n){if(e.stageFiles)return e.stageFiles(t,n);if(e.exec){await e.exec([`add`,`--`,...t],{signal:n?.signal});return}return s(`stageFiles`)}async function x(e,t,n,r){if(e.checkoutFile)return e.checkoutFile(t,n,r);if(e.exec){await e.exec([`checkout`,`--${n}`,`--`,t],{signal:r?.signal});return}return s(`checkoutFile`)}async function S(e,t,n){if(e.removeFile)return e.removeFile(t,n);if(e.exec){await e.exec([`rm`,`--`,t],{signal:n?.signal});return}return s(`removeFile`)}export{p as blame,g as changedFiles,x as checkoutFile,h as diff,m as grep,_ as log,f as mergeBase,l as readFile,S as removeFile,v as show,u as showFile,b as stageFiles,d as unmergedEntries,y as writeFile};
+import{ConflictGitPortMissingOpError as e}from"../ports/git.js";import{sliceLines as t,truncateLines as n,truncateMatches as r}from"./truncation.js";const i={DD:`both-deleted`,AU:`added-by-us`,UD:`deleted-by-them`,UA:`added-by-them`,DU:`deleted-by-us`,AA:`both-added`,UU:`both-modified`};function a(e){return i[e]??e}function o(e){return`Search capped at ${e} matches. There may be more — narrow with a more specific pattern or path.`}function s(t,n){throw new e(t,n)}function c(e,t){return e!=null&&t!=null?`startLine=${e}, endLine=${t}`:e==null?`endLine=${t}`:`startLine=${e}`}async function l(e,t,n){return e.readFile?e.readFile(t,n):s(`readFile`)}async function u(e,r,i,a){let o;if(e.showFile)o=await e.showFile(r,i,a);else if(e.exec){let n=t(await e.exec([`show`,`${r}:${i}`],{signal:a?.signal}),a?.startLine,a?.endLine);if(!n.ok)return n.reason===`invalid-range`?`[Invalid range: ${c(n.startLine,n.endLine)} (startLine must be <= endLine).]`:`[Range out of bounds: file has ${n.total} lines, requested ${c(n.startLine,n.endLine)}.]`;o=n.content}else return s(`showFile`);return a?.fullContent?o:n(o,1e3,`Output capped at 1000 lines. Use startLine/endLine to read other regions of the file.`)}async function d(e,t){if(e.unmergedEntries)return e.unmergedEntries(t);if(e.exec){let n=await e.exec([`-c`,`core.quotepath=false`,`status`,`--porcelain=v2`,`-z`],{signal:t?.signal}),r=[];for(let e of n.split(`\0`)){if(!e.startsWith(`u `))continue;let t=e.split(` `),n=t[1]??``,i=t.slice(10).join(` `);r.push({path:i,reason:a(n),stages:{stage1:f(t[3]),stage2:f(t[4]),stage3:f(t[5])}})}return r}return s(`unmergedEntries`)}function f(e){return e===void 0||e===`000000`?null:e}async function p(e,t){let n=new Map;if(!e.exec)return n;let r=await e.exec([`ls-files`,`-u`,`-z`],{signal:t?.signal});for(let e of r.split(`\0`)){let t=e.indexOf(`	`);if(t===-1)continue;let[r,,i]=e.slice(0,t).split(` `),a=e.slice(t+1);if(r===void 0||a.length===0)continue;let o=n.get(a)??{stage1:null,stage2:null,stage3:null};i===`1`?o.stage1=r:i===`2`?o.stage2=r:i===`3`&&(o.stage3=r),n.set(a,o)}return n}async function m(e,t,n){let r=new Map;if(!e.exec)return r;let i=(await e.exec([`check-attr`,`-z`,`--stdin`,`merge`],{stdin:t.join(`\0`),signal:n?.signal})).split(`\0`);for(let e=0;e+2<i.length;e+=3)r.set(i[e],i[e+2]);return r}async function h(e,t,n,r){return e.mergeBase?e.mergeBase(t,n,r):e.exec?(await e.exec([`merge-base`,`--`,t,n],{signal:r?.signal})).trim():s(`mergeBase`)}async function g(e,t,r){let i=r?.startLine,a=r?.endLine,o=Number.isFinite(i),l=Number.isFinite(a);if(o&&l&&i>a)return`[Invalid range: ${c(i,a)} (startLine must be <= endLine).]`;let u;if(e.blame)u=await e.blame(t,r);else if(e.exec){let n=[`blame`,`--porcelain`],s=o?Math.max(1,i):void 0,c=l?Math.max(1,a):void 0;s!=null&&c!=null?n.push(`-L`,`${s},${c}`):s==null?c!=null&&n.push(`-L`,`1,${c}`):n.push(`-L`,`${s},`),r?.ref&&n.push(r.ref),n.push(`--`,t),u=await e.exec(n,{signal:r?.signal})}else return s(`blame`);return n(u,1e3,`Output capped at 1000 lines. Use startLine/endLine to inspect other regions.`)}async function _(e,t,n){let i=n?.maxResults,a=i!=null&&Number.isFinite(i)?Math.min(Math.max(1,i),100):100,c;if(e.grep)c=await e.grep(t,n);else if(e.exec){let r=[`grep`,`-n`,`--`,t];n?.ref&&r.push(n.ref),c=await e.exec(r,{signal:n?.signal})}else return s(`grep`);return r(c,a,o(a))}async function v(e,t,n,r){if(e.diff)return e.diff(t,n,r);if(e.exec){let i=[`diff`,t,n];return r?.path&&i.push(`--`,r.path),e.exec(i,{signal:r?.signal})}return s(`diff`)}async function y(e,t,n,r){return e.changedFiles?e.changedFiles(t,n,r):e.exec?(await e.exec([`-c`,`core.quotepath=false`,`diff`,`--name-only`,`-z`,`--end-of-options`,t,n],{signal:r?.signal})).split(`\0`).filter(e=>e.length>0):s(`changedFiles`)}async function b(e,t){let r=t?.maxCount,i=r!=null&&Number.isFinite(r)?Math.min(Math.max(1,r),100):100,a;if(e.log)a=await e.log({...t,maxCount:i});else if(e.exec){let n=[`log`,`--oneline`,`-n`,String(i)];t?.ref&&n.push(t.ref),t?.path&&n.push(`--`,t.path),a=await e.exec(n,{signal:t?.signal})}else return s(`log`);return n(a,100,`Output capped at 100 commits. Use path to scope to a file or refine the ref range.`)}async function x(e,t,r){let i;if(e.show)i=await e.show(t,r);else if(e.exec){let n=[`show`,t];r?.path&&n.push(`--`,r.path),i=await e.exec(n,{signal:r?.signal})}else return s(`show`);return n(i,500,`Output capped at 500 lines. Use show_file_at_ref with startLine/endLine to read specific regions.`)}async function S(e,t,n,r){return e.writeFile?e.writeFile(t,n,r):s(`writeFile`)}async function C(e,t,n){if(e.stageFiles)return e.stageFiles(t,n);if(e.exec){await e.exec([`add`,`--`,...t],{signal:n?.signal});return}return s(`stageFiles`)}async function w(e,t,n,r){if(e.checkoutFile)return e.checkoutFile(t,n,r);if(e.exec){await e.exec([`checkout`,`--${n}`,`--`,t],{signal:r?.signal});return}return s(`checkoutFile`)}async function T(e,t,n){if(e.removeFile)return e.removeFile(t,n);if(e.exec){await e.exec([`rm`,`--`,t],{signal:n?.signal});return}return s(`removeFile`)}export{g as blame,y as changedFiles,w as checkoutFile,v as diff,_ as grep,b as log,m as mergeAttributes,h as mergeBase,l as readFile,T as removeFile,x as show,u as showFile,C as stageFiles,d as unmergedEntries,p as unmergedStages,S as writeFile};

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { AIError, AIErrorCode } from "./errors/ai.js";
 import { ConflictError, ConflictErrorCode } from "./errors/conflict.js";
-import { BlameOptions, ConflictDiffOptions, ConflictGitOps, ConflictGitPort, ConflictGitPortMissingOpError, GrepOptions, LogOptions, OpOptions, ShowFileOptions, ShowOptions, UnmergedEntry, UnmergedReason } from "./ports/git.js";
+import { BlameOptions, ConflictDiffOptions, ConflictGitOps, ConflictGitPort, ConflictGitPortMissingOpError, GrepOptions, LogOptions, OpOptions, ShowFileOptions, ShowOptions, UnmergedEntry, UnmergedReason, UnmergedStages } from "./ports/git.js";
 import { CheckStatus, DetectionReport, Finding, FindingCategory, FindingTier } from "./types/findings.js";
 import { IntraFileEditOp } from "./types/hints.js";
 import { DiffStats, Resolution, ResolutionContext, ResolutionMetrics, ResolutionRawSignals, ResolutionRefs, ResolutionStrategy, ResolvedChunk, ThreeWayDiff } from "./types/resolution.js";
@@ -9,17 +9,17 @@ import { extractConflict } from "./extraction/extract.js";
 import { checkoutFile, removeFile, show } from "./git/port-dispatch.js";
 import { ToolCall, ToolDefinition, ToolResult } from "./types/tool.js";
 import { ConflictModelMessage, ConflictModelParams, ConflictModelPort, ConflictModelResult, ResolverConfig } from "./ports/model.js";
-import { ParsedFile, ParserPort, SourceOverlay, SymbolDefinition, SymbolReference, SyntaxIssue } from "./ports/parser.js";
-import { Issue } from "./types/issue.js";
-import { Validator, ValidatorFinding } from "./ports/verify.js";
+import { ParsedFile, ParserCapabilities, ParserPort, SourceOverlay, SymbolDefinition, SymbolReference, SyntaxIssue } from "./ports/parser.js";
+import { Validator, ValidatorFinding } from "./ports/validator.js";
 import { DetectDeps, detect } from "./reference-integrity/detect.js";
 import { createResolution } from "./resolution/create-resolution.js";
+import { CodeLossDetection, detectFallbackCodeLoss } from "./resolution/detect-code-loss.js";
 import { takeOurs, takeTheirs } from "./resolution/take-strategy.js";
 import { applyResolutions } from "./resolver/apply-resolutions.js";
 import { ConflictProgressEvent } from "./types/events.js";
 import { resolveConflict } from "./resolver/resolve-conflict.js";
-import { FileRule, StepConfig, StepResult } from "./types/step.js";
+import { FileRule, SkippedEntry, StepConfig, StepResult } from "./types/step.js";
 import { resolveConflicts } from "./resolver/resolve-conflicts.js";
 import { OperationDigest, OperationSummary, OperationVerdict, ReviewItem } from "./types/summary.js";
 import { SummarizeOperationOptions, buildOperationDigest, summarizeOperation } from "./resolver/summarize-operation.js";
-export { AIError, type AIErrorCode, type BlameOptions, type CheckStatus, type Conflict, type ConflictDiffOptions, ConflictError, type ConflictErrorCode, type ConflictGitOps, type ConflictGitPort, ConflictGitPortMissingOpError, type ConflictMarker, type ConflictMarkerUserInput, type ConflictModelMessage, type ConflictModelParams, type ConflictModelPort, type ConflictModelResult, type ConflictProgressEvent, type ConflictType, type DetectDeps, type DetectionReport, type DiffStats, type FileRule, type Finding, type FindingCategory, type FindingTier, type GrepOptions, type IntraFileEditOp, type Issue, type LogOptions, type OpOptions, type OperationDigest, type OperationSummary, type OperationVerdict, type ParsedFile, type ParserPort, type Resolution, type ResolutionContext, type ResolutionMetrics, type ResolutionRawSignals, type ResolutionRefs, type ResolutionStrategy, type ResolvedChunk, type ResolverConfig, type ReviewItem, type ShowFileOptions, type ShowOptions, type SourceOverlay, type StepConfig, type StepResult, type SummarizeOperationOptions, type SymbolDefinition, type SymbolReference, type SyntaxIssue, type ThreeWayDiff, type ToolCall, type ToolDefinition, type ToolResult, type UnmergedEntry, type UnmergedReason, type Validator, type ValidatorFinding, applyResolutions, buildOperationDigest, checkoutFile, createResolution, detect, extractConflict, removeFile, resolveConflict, resolveConflicts, show, summarizeOperation, takeOurs, takeTheirs };
+export { AIError, type AIErrorCode, type BlameOptions, type CheckStatus, type CodeLossDetection, type Conflict, type ConflictDiffOptions, ConflictError, type ConflictErrorCode, type ConflictGitOps, type ConflictGitPort, ConflictGitPortMissingOpError, type ConflictMarker, type ConflictMarkerUserInput, type ConflictModelMessage, type ConflictModelParams, type ConflictModelPort, type ConflictModelResult, type ConflictProgressEvent, type ConflictType, type DetectDeps, type DetectionReport, type DiffStats, type FileRule, type Finding, type FindingCategory, type FindingTier, type GrepOptions, type IntraFileEditOp, type LogOptions, type OpOptions, type OperationDigest, type OperationSummary, type OperationVerdict, type ParsedFile, type ParserCapabilities, type ParserPort, type Resolution, type ResolutionContext, type ResolutionMetrics, type ResolutionRawSignals, type ResolutionRefs, type ResolutionStrategy, type ResolvedChunk, type ResolverConfig, type ReviewItem, type ShowFileOptions, type ShowOptions, type SkippedEntry, type SourceOverlay, type StepConfig, type StepResult, type SummarizeOperationOptions, type SymbolDefinition, type SymbolReference, type SyntaxIssue, type ThreeWayDiff, type ToolCall, type ToolDefinition, type ToolResult, type UnmergedEntry, type UnmergedReason, type UnmergedStages, type Validator, type ValidatorFinding, applyResolutions, buildOperationDigest, checkoutFile, createResolution, detect, detectFallbackCodeLoss, extractConflict, removeFile, resolveConflict, resolveConflicts, show, summarizeOperation, takeOurs, takeTheirs };

package/dist/index.js

@@ -1 +1 @@
-import{AIError as e}from"./errors/ai.js";import{ConflictError as t}from"./errors/conflict.js";import{ConflictGitPortMissingOpError as n}from"./ports/git.js";import{checkoutFile as r,removeFile as i,show as a}from"./git/port-dispatch.js";import{extractConflict as o}from"./extraction/extract.js";import{detect as s}from"./reference-integrity/detect.js";import{createResolution as c}from"./resolution/create-resolution.js";import{takeOurs as l,takeTheirs as u}from"./resolution/take-strategy.js";import{applyResolutions as d}from"./resolver/apply-resolutions.js";import{resolveConflict as f}from"./resolver/resolve-conflict.js";import{resolveConflicts as p}from"./resolver/resolve-conflicts.js";import{buildOperationDigest as m,summarizeOperation as h}from"./resolver/summarize-operation.js";export{e as AIError,t as ConflictError,n as ConflictGitPortMissingOpError,d as applyResolutions,m as buildOperationDigest,r as checkoutFile,c as createResolution,s as detect,o as extractConflict,i as removeFile,f as resolveConflict,p as resolveConflicts,a as show,h as summarizeOperation,l as takeOurs,u as takeTheirs};
+import{AIError as e}from"./errors/ai.js";import{ConflictError as t}from"./errors/conflict.js";import{ConflictGitPortMissingOpError as n}from"./ports/git.js";import{checkoutFile as r,removeFile as i,show as a}from"./git/port-dispatch.js";import{extractConflict as o}from"./extraction/extract.js";import{detect as s}from"./reference-integrity/detect.js";import{createResolution as c}from"./resolution/create-resolution.js";import{detectFallbackCodeLoss as l}from"./resolution/detect-code-loss.js";import{takeOurs as u,takeTheirs as d}from"./resolution/take-strategy.js";import{applyResolutions as f}from"./resolver/apply-resolutions.js";import{resolveConflict as p}from"./resolver/resolve-conflict.js";import{resolveConflicts as m}from"./resolver/resolve-conflicts.js";import{buildOperationDigest as h,summarizeOperation as g}from"./resolver/summarize-operation.js";export{e as AIError,t as ConflictError,n as ConflictGitPortMissingOpError,f as applyResolutions,h as buildOperationDigest,r as checkoutFile,c as createResolution,s as detect,l as detectFallbackCodeLoss,o as extractConflict,i as removeFile,p as resolveConflict,m as resolveConflicts,a as show,g as summarizeOperation,u as takeOurs,d as takeTheirs};

package/dist/ports/git.d.ts

@@ -11,6 +11,10 @@ interface ConflictDiffOptions extends OpOptions {
 interface ShowFileOptions extends OpOptions {
   startLine?: number;
   endLine?: number;
+  /** Skip the line cap the dispatcher applies by default. The cap keeps file content read for model
+   *  prompts small; a caller feeding the content to a parser (not a prompt) needs the whole file, since
+   *  a definition past the cap would silently drop out of the before/after comparison. */
+  fullContent?: boolean;
 }
 interface BlameOptions extends OpOptions {
   ref?: string;
@@ -29,10 +33,20 @@ interface LogOptions extends OpOptions {
 interface ShowOptions extends OpOptions {
   path?: string;
 }
+/** Index modes of a path's unmerged stages: 1 = merge base, 2 = ours, 3 = theirs. Each value is the
+ *  six-digit mode git records for that stage, or `null` when the stage is absent. */
+interface UnmergedStages {
+  stage1: string | null;
+  stage2: string | null;
+  stage3: string | null;
+}
 interface UnmergedEntry {
   path: string;
   /** Canonical reason parsed from the XY status code. See {@link UnmergedReason}. */
   reason: UnmergedReason;
+  /** Which index stages hold this path, and at what mode. Absent when the host's own
+   *  `unmergedEntries` op does not report it. */
+  stages?: UnmergedStages;
 }
 interface ConflictGitOps {
   readFile?: (path: string, opts?: OpOptions) => Promise<string>;
@@ -74,6 +88,11 @@ interface ConflictGitOps {
   writeFile?: (path: string, content: string, opts?: OpOptions) => Promise<void>;
   stageFiles?: (paths: string[], opts?: OpOptions) => Promise<void>;
   checkoutFile?: (path: string, side: 'ours' | 'theirs', opts?: OpOptions) => Promise<void>;
+  /**
+   * Removes `path` from the index and working tree. Must tolerate a path with no working-tree file to
+   * remove — a stage-1-only rename/rename base path is unmerged with nothing checked out — so a host
+   * that unlinks the file before untracking it must not fail on `ENOENT`.
+   */
   removeFile?: (path: string, opts?: OpOptions) => Promise<void>;
 }
 type ConflictGitPort = ConflictGitOps & {
@@ -85,4 +104,4 @@ declare class ConflictGitPortMissingOpError extends Error {
   constructor(op: string, hint?: string);
 }
 //#endregion
-export { BlameOptions, ConflictDiffOptions, ConflictGitOps, ConflictGitPort, ConflictGitPortMissingOpError, GrepOptions, LogOptions, OpOptions, ShowFileOptions, ShowOptions, UnmergedEntry, UnmergedReason };
+export { BlameOptions, ConflictDiffOptions, ConflictGitOps, ConflictGitPort, ConflictGitPortMissingOpError, GrepOptions, LogOptions, OpOptions, ShowFileOptions, ShowOptions, UnmergedEntry, UnmergedReason, UnmergedStages };

package/dist/ports/parser.d.ts

@@ -26,9 +26,15 @@ interface SyntaxIssue {
   line: number;
   message: string;
 }
-/** Per-file parse result. `language` is `'unsupported'` when the backend cannot parse the file — the
- *  detector then skips it rather than emitting false findings. */
+/** Per-file parse result. */
 interface ParsedFile {
+  /** `false` when the backend has no grammar for this file type at all (a lockfile, an image, a
+   *  language it does not implement). The detector skips the file and reports reduced coverage rather
+   *  than emitting false findings. A file the backend *does* handle but whose content failed to parse
+   *  is `supported: true` with the failure in `syntaxErrors` — that is a finding, not a coverage gap,
+   *  and conflating the two lets a broken merge result read as clean. */
+  supported: boolean;
+  /** Backend's language id. Free-form; only meaningful when `supported`. */
   language: string;
   definitions: SymbolDefinition[];
   references: SymbolReference[];
@@ -40,18 +46,33 @@ interface ParsedFile {
   bindings?: SymbolDefinition[];
   syntaxErrors: SyntaxIssue[];
 }
+/** What a backend can actually do, so the detector reports the coverage it really achieved. */
+interface ParserCapabilities {
+  /** Whether the backend resolves references across files (imports and their targets). A backend that
+   *  cannot — a plain tree-sitter parser, which sees one file at a time — reports every cross-file use
+   *  as unresolved on both parents *and* the result, so no before/after transition exists and no
+   *  cross-file break can ever be found. Declaring `false` makes that limit visible in the report
+   *  instead of letting an empty findings list read as a clean cross-file check. */
+  crossFileResolution: boolean;
+}
 /**
  * Parsing / symbol-resolution capability supplied per surface — merge-mate via tree-sitter,
  * GitLens/GKD via a language server. The detector stays free of any parser dependency; the port
- * abstracts the precision difference between backends.
+ * abstracts the precision difference between backends and asks them to declare it.
  */
 interface ParserPort {
+  /** What this backend can resolve. Omitted means the conservative reading: no cross-file resolution. */
+  capabilities?: ParserCapabilities;
   /**
    * Parse and resolve every file in `sources`, treating those contents as authoritative for their
    * paths. Returns one {@link ParsedFile} per input path. Works only from the provided content — it
-   * never reads the filesystem itself.
+   * never reads the filesystem itself. `signal`, when provided, should abort an in-flight analysis.
+   *
+   * Calls are never overlapped: the package awaits each `analyze` before issuing the next, so a
+   * single-instance backend (a language server holding one document per path) is not asked to hold
+   * two versions of the same path at once. Implementations need no internal locking.
    */
-  analyze(sources: SourceOverlay): Promise<ReadonlyMap<string, ParsedFile>>;
+  analyze(sources: SourceOverlay, signal?: AbortSignal): Promise<ReadonlyMap<string, ParsedFile>>;
 }
 //#endregion
-export { ParsedFile, ParserPort, SourceOverlay, SymbolDefinition, SymbolReference, SyntaxIssue };
+export { ParsedFile, ParserCapabilities, ParserPort, SourceOverlay, SymbolDefinition, SymbolReference, SyntaxIssue };

package/dist/ports/validator.d.ts

@@ -0,0 +1,29 @@
+import { FindingCategory } from "../types/findings.js";
+import { SourceOverlay } from "./parser.js";
+
+//#region src/ports/validator.d.ts
+interface ValidatorFinding {
+  /** Consumer's own category (e.g. `'type-error'`, `'lint:no-console'`). The package's own
+   *  {@link FindingCategory} values are accepted too, and kept discoverable, but nothing requires them. */
+  category: FindingCategory | (string & {});
+  severity: 'error' | 'warning';
+  file: string;
+  /** 1-indexed. */
+  line?: number;
+  message: string;
+}
+/**
+ * The consumer's validation port. Plug in any checks — syntax, real import resolution, types, lint,
+ * project rules. **Non-blocking**: it runs post-refine and its findings are advisory (folded into the
+ * operation's findings and verdict), never a re-resolve. The only blocking gate is residual conflict
+ * markers, which the resolver checks built-in and language-agnostic — that is not this port's job.
+ *
+ * `sources` is currently always a single-file overlay: the package validates one file at a time, after
+ * that file's refine. The parameter is an overlay so a whole-set call can be added without a breaking
+ * change, but no such call site exists yet — do not write a validator that only works across files.
+ */
+interface Validator {
+  validate(sources: SourceOverlay, signal?: AbortSignal): Promise<ValidatorFinding[]>;
+}
+//#endregion
+export { Validator, ValidatorFinding };

package/dist/ports/validator.js

@@ -0,0 +1 @@
+export{};

package/dist/reference-integrity/detect.d.ts

@@ -1,7 +1,8 @@
 import { ConflictGitPort } from "../ports/git.js";
-import { DetectionReport } from "../types/findings.js";
+import { DetectionReport, Finding } from "../types/findings.js";
 import { Resolution, ResolutionContext } from "../types/resolution.js";
 import { ParserPort } from "../ports/parser.js";
+import { Validator } from "../ports/validator.js";
 
 //#region src/reference-integrity/detect.d.ts
 interface DetectDeps {
@@ -9,13 +10,47 @@ interface DetectDeps {
   /** Parsing/symbol-resolution capability. When absent, detection is skipped and reported as such. */
   parser?: ParserPort;
   signal?: AbortSignal;
+  /** Paths to keep out of scope — the caller's skipped and failed files, which still carry conflict
+   *  markers on disk. See {@link import('./snapshot.js').SnapshotDeps.excludePaths}. */
+  excludePaths?: ReadonlySet<string>;
+  /** Override the per-operation scope cap. See {@link import('./snapshot.js').SnapshotDeps.maxScopeFiles}. */
+  maxScopeFiles?: number;
+}
+/** Parent contents for one file, named so the two sides cannot be transposed at a call site. */
+interface ParentContents {
+  ours?: string;
+  theirs?: string;
 }
 /**
  * Deterministic post-resolution detection: flags references that resolved in a pre-merge parent
  * (ours/theirs) but no longer resolve in the merged result, plus duplicate definitions and syntax
- * errors in the resolved files. Report-only — it never mutates state or fails the operation. When no
- * parser is supplied, or refs are missing, the report says so instead of implying a clean result.
+ * errors across the analyzed scope (the resolved files and the merge's auto-merged/incoming set).
+ * Report-only — it never mutates state or fails the operation. When no parser is supplied, or refs are
+ * missing, the report says so instead of implying a clean result.
  */
 declare function detect(resolutions: Resolution[], context: ResolutionContext, deps: DetectDeps): Promise<DetectionReport>;
+interface FileFindingsDeps {
+  parser: ParserPort;
+  validator?: Validator;
+  signal?: AbortSignal;
+}
+/** Per-file findings split by who produced them. They are kept apart because only the validator half is
+ *  the file's own to keep: parser findings computed over a *single-file* overlay are provisional — a
+ *  symbol defined in another file is unresolved there by construction — so the authoritative version is
+ *  whatever `detect()` says over the whole set. The fix loop uses both to converge and persists only
+ *  `validator`. */
+interface FileFindings {
+  parser: Finding[];
+  validator: Finding[];
+}
+/**
+ * Per-file findings for one file's current content, compared against its pre-merge parents: structural
+ * (syntax/duplicate) + intra-file broken references (a local definition/binding the merge dropped while
+ * a use of it remains in the same file) + the consumer validator's per-file issues. All `tier: 'file'`.
+ * Cross-file references need the full set and are not computed here — `detect()` remains the
+ * authoritative whole-set report. This is the lightweight unit the per-file fix loop re-runs after each
+ * edit, over already-loaded parent snapshots (no git reads, no incoming-set discovery).
+ */
+declare function collectFileFindings(file: string, parents: ParentContents, resultContent: string, deps: FileFindingsDeps): Promise<FileFindings>;
 //#endregion
-export { DetectDeps, detect };
+export { DetectDeps, FileFindings, FileFindingsDeps, ParentContents, collectFileFindings, detect };

package/dist/reference-integrity/detect.js

@@ -1,3 +1,3 @@
-import{buildSnapshots as e}from"./snapshot.js";async function t(t,r,o){let c=o.parser;if(!c)return{findings:[],checks:{referenceIntegrity:`skipped-no-parser`,structural:`skipped-no-parser`}};try{let l=r.detectionRefs??r.refs?await e(t,r,o):null;if(l){let[e,r,o]=await Promise.all([c.analyze(l.ours),c.analyze(l.theirs),c.analyze(l.result)]),u=l.analyzed>0&&l.readable===0?`skipped-unreadable-source`:s([e,r,o])?`partial-unsupported-language`:`ran`;return{findings:[...n(e,r,o),...i(o),...a(t,l)],checks:{referenceIntegrity:u,structural:s([o])?`partial-unsupported-language`:`ran`},scope:{analyzed:l.analyzed,readable:l.readable,truncated:l.truncated}}}let u=new Map(t.map(e=>[e.filePath,e.content])),d=await c.analyze(u);return{findings:i(d),checks:{referenceIntegrity:`skipped-no-refs`,structural:s([d])?`partial-unsupported-language`:`ran`}}}catch{return{findings:[],checks:{referenceIntegrity:`errored`,structural:`errored`}}}}function n(e,t,n){let i=new Map;r(e,`ours`,i),r(t,`theirs`,i);let a=[];for(let[e,t]of n)for(let n of t.references){if(n.resolved)continue;let t=i.get(c(e,n.name));t&&a.push({category:`broken-reference`,severity:`error`,tier:t.crossFile?`project`:`file`,location:{file:e,line:n.line,symbol:n.name},provenance:{side:t.side,line:t.line},message:`Reference "${n.name}" resolved before the merge (on ${t.side}) but no longer resolves.`})}return a}function r(e,t,n){let r=(e,r,i,a)=>{let o=c(e,r);n.has(o)||n.set(o,{side:t,line:i,crossFile:a})};for(let[t,n]of e){for(let e of n.definitions)r(t,e.name,e.line,!1);for(let e of n.bindings??[])r(t,e.name,e.line,!1)}for(let[t,n]of e)for(let e of n.references)e.resolved&&r(t,e.name,e.line,e.target?e.target.file!==t:!0)}function i(e){let t=[];for(let[n,r]of e){let e=new Map;for(let i of r.definitions){let r=e.get(i.name);r==null?e.set(i.name,i.line):t.push({category:`duplicate-definition`,severity:`error`,tier:`file`,location:{file:n,line:i.line,symbol:i.name},message:`Duplicate definition of "${i.name}" (also defined at line ${r}).`})}for(let e of r.syntaxErrors)t.push({category:`syntax-error`,severity:`error`,tier:`file`,location:{file:n,line:e.line},message:e.message})}return t}function a(e,t){let n=[];for(let r of e){let e=r.strategy===`take-ours`?`theirs`:r.strategy===`take-theirs`?`ours`:null;if(!e)continue;let i=(e===`ours`?t.ours:t.theirs).get(r.filePath);if(i==null)continue;let a=o(i,r.content);a<20||n.push({category:`dropped-side`,severity:`error`,tier:`file`,location:{file:r.filePath,line:1},message:`Resolution took "${r.strategy}" wholesale, discarding ~${a} line(s) of the ${e} side.`})}return n}function o(e,t){let n=new Set(t.split(`
+import{toFileFinding as e}from"../validation/findings.js";import{buildSnapshots as t,carriesNoOwnContent as n,safeReadFile as r}from"./snapshot.js";async function i(e,i,o){let s=o.parser;if(!s)return{findings:[],checks:{referenceIntegrity:`skipped-no-parser`,structural:`skipped-no-parser`}};try{let l=i.detectionRefs??i.refs?await t(e,i,o):null;if(l){let t=await s.analyze(l.ours,o.signal),n=await s.analyze(l.theirs,o.signal),r=await s.analyze(l.result,o.signal);return{findings:[...c(t,n,r),...u(r,[t,n]),...f(e,l)],checks:{referenceIntegrity:a(l,s,[t,n,r]),structural:m(r)?`partial-unsupported-language`:`ran`},scope:{inScope:l.inScope,readable:l.readable,truncated:l.truncated,incomingDiscovered:l.incomingDiscovered}}}let d=new Map;for(let t of e){let e=n(t)?await r(o.git,t.filePath,{signal:o.signal}):t.content;e!=null&&d.set(t.filePath,e)}let p=await s.analyze(d,o.signal);return{findings:u(p,[]),checks:{referenceIntegrity:`skipped-no-refs`,structural:m(p)?`partial-unsupported-language`:`ran`}}}catch(e){if(o.signal?.aborted)throw e;return{findings:[],checks:{referenceIntegrity:`errored`,structural:`errored`}}}}function a(e,t,n){return e.inScope>0&&e.readable===0?`skipped-unreadable-source`:t.capabilities?.crossFileResolution?n.some(m)?`partial-unsupported-language`:`ran`:`partial-no-cross-file-resolution`}async function o(t,n,r,i){let a=async e=>e==null?new Map:i.parser.analyze(new Map([[t,e]]),i.signal),o=await a(n.ours),s=await a(n.theirs),l=await i.parser.analyze(new Map([[t,r]]),i.signal),d=[...c(o,s,l).filter(e=>e.tier===`file`),...u(l,[o,s])],f=[];if(i.validator){let n=await i.validator.validate(new Map([[t,r]]),i.signal);for(let t of n)f.push(e(t))}return{parser:d,validator:f}}function s(e){let t=new Set;for(let n of e.definitions)t.add(n.name);for(let n of e.bindings??[])t.add(n.name);return t}function c(e,t,n){let r=l(e,t),i=[];for(let[e,t]of n){let n=s(t);for(let a of t.references){if(a.resolved||n.has(a.name))continue;let t=r.get(h(e,a.name));t&&i.push({category:`broken-reference`,severity:`error`,tier:t.crossFile?`project`:`file`,location:{file:e,line:a.line,symbol:a.name},provenance:{side:t.side,line:t.line},...t.crossFile&&t.targetFile?{definitionFile:t.targetFile}:{},message:`Reference "${a.name}" resolved before the merge (on ${t.side}) but no longer resolves.`})}}return i}function l(e,t){let n=new Map,r=(e,t,r,i,a,o)=>{let s=h(t,r);n.has(s)||n.set(s,{side:e,line:i,crossFile:a,targetFile:o})},i=[[`ours`,e],[`theirs`,t]];for(let[e,t]of i)for(let[n,i]of t){for(let t of i.definitions)r(e,n,t.name,t.line,!1);for(let t of i.bindings??[])r(e,n,t.name,t.line,!1)}for(let[e,t]of i)for(let[n,i]of t)for(let t of i.references)t.resolved&&r(e,n,t.name,t.line,t.target?t.target.file!==n:!0,t.target?.file);return n}function u(e,t){let n=d(t),r=new Set;for(let e of t)for(let t of e.keys())r.add(t);let i=[];for(let[t,a]of e){let e=r.has(t),o=new Map;for(let r of a.definitions){let a=o.get(r.name);if(a==null){o.set(r.name,r.line);continue}!e||n.has(h(t,r.name))||i.push({category:`duplicate-definition`,severity:`warning`,tier:`file`,location:{file:t,line:r.line,symbol:r.name},message:`Duplicate definition of "${r.name}" (also defined at line ${a}).`})}for(let e of a.syntaxErrors)i.push({category:`syntax-error`,severity:`error`,tier:`file`,location:{file:t,line:e.line},message:e.message})}return i}function d(e){let t=new Set;for(let n of e)for(let[e,r]of n){let n=new Set;for(let i of r.definitions){let r=h(e,i.name);n.has(r)&&t.add(r),n.add(r)}}return t}function f(e,t){let n=[];for(let r of e){if(!r.fallback||r.strategy!==`take-ours`&&r.strategy!==`take-theirs`)continue;let e=r.strategy===`take-ours`?`theirs`:`ours`,i=(e===`ours`?t.ours:t.theirs).get(r.filePath);if(i==null)continue;let a=p(i,r.content);a<20||n.push({category:`dropped-side`,severity:`error`,tier:`file`,location:{file:r.filePath,line:1},message:`Resolution took "${r.strategy}" wholesale, discarding ~${a} line(s) of the ${e} side.`})}return n}function p(e,t){let n=new Set(t.split(`
 `)),r=0;for(let t of e.split(`
-`))t.trim()!==``&&!n.has(t)&&r++;return r}function s(e){return e.some(e=>{for(let t of e.values())if(t.language===`unsupported`)return!0;return!1})}function c(e,t){return JSON.stringify([e,t])}export{t as detect};
+`))t.trim()!==``&&!n.has(t)&&r++;return r}function m(e){for(let t of e.values())if(!t.supported)return!0;return!1}function h(e,t){return`${e}\u0000${t}`}export{o as collectFileFindings,i as detect};

package/dist/reference-integrity/snapshot.d.ts

@@ -1,32 +1,54 @@
-import { ConflictGitPort } from "../ports/git.js";
+import { ConflictGitPort, OpOptions } from "../ports/git.js";
 import { Resolution, ResolutionContext } from "../types/resolution.js";
 import { SourceOverlay } from "../ports/parser.js";
 
 //#region src/reference-integrity/snapshot.d.ts
+/** Default backstop on how many files the detector will parse in one operation, overridable via
+ *  `SnapshotDeps.maxScopeFiles`. The scope is ordered resolved-first, so a cap drops the least-important
+ *  tail; truncation is reported, never silent. */
+declare const DEFAULT_MAX_SCOPE_FILES = 400;
 interface DetectionSnapshots {
   ours: SourceOverlay;
   theirs: SourceOverlay;
   result: SourceOverlay;
-  /** Number of files in scope (after the cap). */
-  analyzed: number;
+  /** Number of files taken into scope (after the cap). */
+  inScope: number;
   /** How many scope files had loadable parent content on `ours` or `theirs`. When this is 0 the
    *  before/after comparison had nothing to read — a total read failure, not a clean result. */
   readable: number;
   /** Whether the scope exceeded the cap and was truncated. */
   truncated: boolean;
+  /** Whether the incoming/auto-merged set could be discovered (or was supplied by the consumer). */
+  incomingDiscovered: boolean;
 }
 interface SnapshotDeps {
   git: ConflictGitPort;
   signal?: AbortSignal;
+  /** Paths to keep out of scope entirely. The caller passes the files it skipped or failed on: those
+   *  still carry conflict markers in the working tree, so parsing them would report the marker text as
+   *  syntax errors and blame the merge for a file nobody resolved. */
+  excludePaths?: ReadonlySet<string>;
+  /** Cap on files parsed per operation. Default {@link DEFAULT_MAX_SCOPE_FILES}. Exceeding it sets
+   *  `truncated`, which keeps the verdict off `clean`; raise it so a large merge can still auto-apply. */
+  maxScopeFiles?: number;
 }
 /**
  * Builds the file-content overlays the detector compares: both pre-merge parents (read from git
  * objects — no working tree needed) and the resolved result (in-memory resolutions overlaid on the
  * surrounding files). Scope is the resolved files plus the merge's incoming/auto-merged set, which
  * the detector discovers itself via the git port (`changedFiles(base, theirs)`), unless the consumer
- * supplies `context.touchedFiles` as an override. Returns `null` when `context.refs` is absent — the
- * before/after comparison is impossible without the parent refs.
+ * supplies `context.touchedFiles` as an override. Returns `null` when neither `context.detectionRefs`
+ * nor `context.refs` is present — the before/after comparison is impossible without the parent refs.
  */
 declare function buildSnapshots(resolutions: Resolution[], context: ResolutionContext, deps: SnapshotDeps): Promise<DetectionSnapshots | null>;
+/** True for a resolution whose `content` is empty by contract because its result lives outside the
+ *  resolution: `mechanical` (git merged the path into the working tree itself) or a whole-side take on
+ *  a marker-free entry. Such a path is kept out of the result overlay; overlaying the empty string would
+ *  show the parser an emptied file and report every symbol in it as dropped. `detect()`'s no-refs branch
+ *  has no parent snapshots to prefer, so there it always falls back to the working tree. */
+declare function carriesNoOwnContent(resolution: Resolution): boolean;
+/** Working-tree read that reports an unreadable file as `null` rather than throwing. Shared with
+ *  `detect()`, whose no-refs branch needs the same fallback for a resolution that carries no content. */
+declare function safeReadFile(git: ConflictGitPort, path: string, opts: OpOptions | undefined): Promise<string | null>;
 //#endregion
-export { DetectionSnapshots, SnapshotDeps, buildSnapshots };
+export { DEFAULT_MAX_SCOPE_FILES, DetectionSnapshots, SnapshotDeps, buildSnapshots, carriesNoOwnContent, safeReadFile };

package/dist/reference-integrity/snapshot.js

@@ -1 +1 @@
-import{changedFiles as e,mergeBase as t,readFile as n,showFile as r}from"../git/port-dispatch.js";async function i(e,t,n){let r=t.detectionRefs??t.refs;if(!r)return null;let i=n.signal?{signal:n.signal}:void 0,c=new Map(e.map(e=>[e.filePath,e.content])),l=t.touchedFiles??await a(n.git,r,i),u=[],d=new Set;for(let e of[...c.keys(),...l,...t.fileNeighbors??[]])d.has(e)||(d.add(e),u.push(e));let f=u.length>400,p=f?u.slice(0,400):u,m=new Map,h=new Map,g=new Map,_=0;for(let e of p){let t=await o(n.git,r.ours,e,i);t&&m.set(e,t);let a=await o(n.git,r.theirs,e,i);a&&h.set(e,a),(t||a)&&_++;let l=c.get(e);if(l!=null)g.set(e,l);else{let t=await s(n.git,e,i);t!=null&&g.set(e,t)}}return{ours:m,theirs:h,result:g,analyzed:p.length,readable:_,truncated:f}}async function a(n,r,i){try{return await e(n,r.base??await t(n,r.ours,r.theirs,i),r.theirs,i)}catch{return[]}}async function o(e,t,n,i){try{return await r(e,t,n,i)}catch{return null}}async function s(e,t,r){try{return await n(e,t,r)}catch{return null}}export{i as buildSnapshots};
+import{changedFiles as e,mergeBase as t,readFile as n,showFile as r}from"../git/port-dispatch.js";const i=400;async function a(e,t,n){let r=t.detectionRefs??t.refs;if(!r)return null;let i=n.signal?{signal:n.signal}:void 0,a={...i,fullContent:!0},d=new Map(e.filter(e=>!c(e)).map(e=>[e.filePath,e.content])),f=t.touchedFiles?{files:t.touchedFiles,discovered:!0}:await o(n.git,r,i),p=new Map(e.flatMap(e=>{let t=l(e);return t?[[e.filePath,t]]:[]})),m=n.excludePaths,h=[...new Set([...e.map(e=>e.filePath),...f.files,...t.fileNeighbors??[]])].filter(e=>!m?.has(e)),g=n.maxScopeFiles??400,_=h.length>g,v=_?h.slice(0,g):h,y=new Map,b=new Map,x=new Map,S={ours:y,theirs:b},C=0;for(let e of v){let t=await s(n.git,r.ours,e,a);t&&y.set(e,t);let o=await s(n.git,r.theirs,e,a);o&&b.set(e,o),(t||o)&&C++;let c=p.get(e),l=c?S[c].get(e):void 0,f=d.get(e)??l??await u(n.git,e,i);f!=null&&x.set(e,f)}return{ours:y,theirs:b,result:x,inScope:v.length,readable:C,truncated:_,incomingDiscovered:f.discovered}}async function o(n,r,i){try{return{files:await e(n,r.base??await t(n,r.ours,r.theirs,i),r.theirs,i),discovered:!0}}catch(e){return d(e,i),{files:[],discovered:!1}}}async function s(e,t,n,i){try{return await r(e,t,n,i)}catch(e){return d(e,i),null}}function c(e){return e.strategy===`mechanical`||l(e)!==null}function l(e){return e.content!==``||e.chunks!=null?null:e.strategy===`take-ours`?`ours`:e.strategy===`take-theirs`?`theirs`:null}async function u(e,t,r){try{return await n(e,t,r)}catch(e){return d(e,r),null}}function d(e,t){if(t?.signal?.aborted)throw e}export{i as DEFAULT_MAX_SCOPE_FILES,a as buildSnapshots,c as carriesNoOwnContent,u as safeReadFile};

package/dist/resolution/detect-code-loss.d.ts

@@ -0,0 +1,23 @@
+import { Conflict } from "../types/conflict.js";
+
+//#region src/resolution/detect-code-loss.d.ts
+interface CodeLossDetection {
+  /** The side thrown away by the wholesale fallback. */
+  discardedSide: 'ours' | 'theirs';
+}
+/**
+ * Reports whether a wholesale `take-ours`/`take-theirs` fallback would discard already-integrated
+ * work. On rebase "ours" is everything resolved so far, so taking the other side wholesale can wipe
+ * it (AGP-430).
+ *
+ * Any text conflict counts as loss. The fallback is applied with `git checkout --ours/--theirs`,
+ * which swaps the whole file for one stage, so whatever git auto-merged outside the conflict markers
+ * is discarded with it. Comparing marker regions cannot rule that out: it answers a narrower question
+ * than the write asks.
+ *
+ * Returns `null` only for the delete-modify direction that keeps content, the one case where the
+ * fallback is safe by construction.
+ */
+declare function detectFallbackCodeLoss(conflict: Conflict, strategy: 'take-ours' | 'take-theirs'): CodeLossDetection | null;
+//#endregion
+export { CodeLossDetection, detectFallbackCodeLoss };

package/dist/resolution/detect-code-loss.js

@@ -0,0 +1 @@
+function e(e,t){let n=t===`take-theirs`?`ours`:`theirs`;return e.type===`delete-modify`?t===`take-theirs`&&e.deletedBy===`theirs`||t===`take-ours`&&e.deletedBy===`ours`?{discardedSide:n}:null:e.markers.length>0?{discardedSide:n}:null}export{e as detectFallbackCodeLoss};

package/dist/resolver/apply-resolutions.js

@@ -1 +1 @@
-import{checkoutFile as e,removeFile as t,stageFiles as n,writeFile as r}from"../git/port-dispatch.js";async function i(i,a){let o=i.filter(e=>e.strategy!==`skipped`);if(o.length===0)return;let s=new Set;for(let n of o)switch(n.strategy){case`deleted`:await t(a.git,n.filePath),s.add(n.filePath);break;case`take-ours`:await e(a.git,n.filePath,`ours`);break;case`take-theirs`:await e(a.git,n.filePath,`theirs`);break;default:await r(a.git,n.filePath,n.content)}let c=o.filter(e=>!s.has(e.filePath)).map(e=>e.filePath);c.length>0&&await n(a.git,c)}export{i as applyResolutions};
+import{checkoutFile as e,removeFile as t,stageFiles as n,writeFile as r}from"../git/port-dispatch.js";async function i(i,a){let o=i.filter(e=>e.strategy!==`skipped`);if(o.length===0)return;let s=new Set;for(let n of o){switch(n.strategy){case`deleted`:await t(a.git,n.filePath),s.add(n.filePath);break;case`take-ours`:await e(a.git,n.filePath,`ours`);break;case`take-theirs`:await e(a.git,n.filePath,`theirs`);break;case`mechanical`:break;default:await r(a.git,n.filePath,n.content)}for(let e of n.retiredPaths??[])await t(a.git,e),s.add(e)}let c=o.filter(e=>!s.has(e.filePath)).map(e=>e.filePath);c.length>0&&await n(a.git,c)}export{i as applyResolutions};

package/dist/resolver/deps.d.ts

@@ -1,7 +1,7 @@
 import { ConflictGitPort } from "../ports/git.js";
 import { ConflictModelPort, ResolverConfig } from "../ports/model.js";
 import { ParserPort } from "../ports/parser.js";
-import { Validator } from "../ports/verify.js";
+import { Validator } from "../ports/validator.js";
 import { ConflictProgressEvent } from "../types/events.js";
 
 //#region src/resolver/deps.d.ts

package/dist/resolver/fix-loop.d.ts

@@ -0,0 +1,67 @@
+import { ConflictGitPort } from "../ports/git.js";
+import { DetectionReport } from "../types/findings.js";
+import { Resolution, ResolutionContext } from "../types/resolution.js";
+import { ConflictModelPort } from "../ports/model.js";
+import { ParserPort } from "../ports/parser.js";
+import { Validator } from "../ports/validator.js";
+import { ParentContents } from "../reference-integrity/detect.js";
+import { ConflictProgressEvent } from "../types/events.js";
+import { StepConfig } from "../types/step.js";
+import { ModelBudget } from "./model-budget.js";
+
+//#region src/resolver/fix-loop.d.ts
+interface FixLoopDeps {
+  model: ConflictModelPort;
+  parser: ParserPort;
+  validator?: Validator;
+  config?: StepConfig;
+  onProgress?: (event: ConflictProgressEvent) => void;
+  signal?: AbortSignal;
+  /** Global model-call budget for the operation. When exhausted, the loop stops before any further
+   *  model call and leaves the remaining findings unfixed. Absent = unlimited. */
+  budget?: ModelBudget;
+  /** Invoked when the budget stops work. Deduped by {@link ModelBudget}, so a caller may wire this
+   *  straight to a progress emit. */
+  onBudgetExhausted?: () => void;
+}
+/**
+ * Per-file convergence loop (opt-in `config.fix`). Re-detects the file's per-file findings, feeds the
+ * error-severity ones back through refine as fix instructions, and repeats until the file is clean, a
+ * round makes no progress or makes things worse, or the iteration budget runs out. What it cannot fix
+ * stays in the report — the verdict is computed from that remainder, never from a stale pre-fix set.
+ *
+ * Only intra-file findings are addressed here (from {@link collectFileFindings}); cross-file references
+ * are a separate set-level stage. `dropped-side` is not produced per-file and so is never routed. The
+ * caller should invoke this only for fixable text files (see {@link isFixable}): AI resolutions and
+ * non-deliberate whole-side takes, whose edited content the apply step can write.
+ */
+declare function runFixLoop(resolution: Resolution, parents: ParentContents, deps: FixLoopDeps): Promise<Resolution>;
+interface FixPhaseDeps {
+  model: ConflictModelPort;
+  git: ConflictGitPort;
+  parser: ParserPort;
+  validator?: Validator;
+  config?: StepConfig;
+  onProgress?: (event: ConflictProgressEvent) => void;
+  signal?: AbortSignal;
+  /** Global model-call budget for the operation. When exhausted, both fix stages stop before any
+   *  further model call, leaving the remainder in the report. Absent = unlimited. */
+  budget?: ModelBudget;
+  /** Paths kept out of the detection scope — the caller's skipped and failed files. */
+  excludePaths?: ReadonlySet<string>;
+}
+/**
+ * The fix phase (opt-in). Stage 2: per-file convergence over each AI resolution ({@link runFixLoop}).
+ * Stage 3: route cross-file (`tier: 'project'`) broken references back to the refine of their use-site
+ * file and re-detect over the whole set, up to `crossFileMaxIterations` rounds. Mutates `resolutions`
+ * in place and returns the final whole-set {@link DetectionReport} — which, being whole-set, also
+ * re-checks per-file for files touched by cross-file fixes.
+ *
+ * Cross-file findings on files with no fixable resolution (e.g. auto-merged, or a deliberate/fallback
+ * take) are not routed: they have no carrier for an edit yet (needs a patches channel), so they remain
+ * in the report unchanged. When routing a break, the defining file's current definitions are shown to
+ * the refining model so a renamed/moved symbol is fixable from the use site (see {@link buildRelatedDefinitions}).
+ */
+declare function runFixPhase(resolutions: Resolution[], context: ResolutionContext, deps: FixPhaseDeps): Promise<DetectionReport>;
+//#endregion
+export { FixLoopDeps, FixPhaseDeps, runFixLoop, runFixPhase };

package/dist/resolver/fix-loop.js

@@ -0,0 +1,2 @@
+import{buildSnapshots as e}from"../reference-integrity/snapshot.js";import{collectFileFindings as t,detect as n}from"../reference-integrity/detect.js";import{checkResidualMarkers as r}from"../validation/markers.js";import{runRefinePass as i}from"./refine-pass.js";import{CONFIDENCE_CAPS as a}from"./resolve-conflict.js";async function o(e,n,o){let d=o.config?.fixLoopMaxIterations??3,f={parser:o.parser,validator:o.validator,signal:o.signal},p={content:e.content,findings:await(r=>t(e.filePath,n,r,f))(e.content)},g=s(p.findings);if(g.length===0)return l(o,e.filePath,0,0),c(e,p.findings.validator);if(o.budget?.exhausted())return o.onBudgetExhausted?.(),l(o,e.filePath,0,g.length),c(e,p.findings.validator);o.onProgress?.({type:`fix:started`,filePath:e.filePath,findingCount:g.length});let _=[],v=0,y=m(g);for(;v<d&&g.length>0;){if(o.budget?.exhausted()){o.onBudgetExhausted?.();break}v++;let a=await i(p.content,e.description,u(g),{model:o.model,signal:o.signal,temperature:o.config?.temperature,refineMaxSteps:o.config?.refineMaxSteps,onProgress:o.onProgress,filePath:e.filePath,budget:o.budget});if(a.edits.length===0)break;if(!r(e.filePath,a.content).valid){o.onProgress?.({type:`refine:discarded`,filePath:e.filePath,reason:`Fix edits introduced conflict markers.`});break}let c=await t(e.filePath,n,a.content,f),l=s(c);if(h(g,l)){o.onProgress?.({type:`refine:discarded`,filePath:e.filePath,reason:`Fix edits regressed the file (was ${g.length} error(s), now ${l.length}).`});break}p={content:a.content,findings:c},_.push(...a.edits),g=l;let d=m(g);if(d===y)break;y=d}l(o,e.filePath,v,g.length);let b=c({...e,content:p.content},p.findings.validator);return _.length===0?b:{...b,strategy:`ai`,edits:[...e.edits??[],..._],confidence:Math.min(b.confidence,a.refineApplied)}}function s(e){return[...e.parser,...e.validator].filter(e=>e.severity===`error`)}function c(e,t){if(t.length===0){if(!e.findings)return e;let{findings:t,...n}=e;return n}return{...e,findings:t}}function l(e,t,n,r){e.onProgress?.({type:`fix:completed`,filePath:t,iterations:n,remainingFindings:r})}function u(e){return e.slice(0,20).map(d)}function d(e){let t=e.location.symbol?f(e.location.symbol):void 0,n=t?`"${t}" (line ${e.location.line})`:`line ${e.location.line}`;return`${f(e.category)} at ${n}: ${f(e.message)}`}function f(e){return e.replace(/[\p{Cc}\p{Cf}]/gu,` `).replace(/\s+/g,` `).trim().slice(0,300)}function p(e){return JSON.stringify([e.category,e.location.file,e.location.symbol??``])}function m(e){return e.map(p).sort().join(`
+`)}function h(e,t){if(t.length>e.length)return!0;let n=new Set(e.map(p));return t.some(e=>!n.has(p(e)))}async function g(t,r,i){let a=i.config?.maxDetectionScopeFiles,o={git:i.git,parser:i.parser,signal:i.signal,excludePaths:i.excludePaths,maxScopeFiles:a},s=await e(t,r,{git:i.git,signal:i.signal,excludePaths:i.excludePaths,maxScopeFiles:a}),c=()=>i.onProgress?.({type:`fix:budget-exhausted`,spent:i.budget?.spent()??0,limit:i.budget?.limit()??0}),l={model:i.model,parser:i.parser,validator:i.validator,config:i.config,onProgress:i.onProgress,signal:i.signal,budget:i.budget,onBudgetExhausted:()=>i.budget?.notifyExhaustedOnce(c)};return await v(t,s,l),s?y(t,r,s,o,l,i):n(t,r,o)}function _(e){return e.strategy===`ai`?!0:e.strategy===`take-ours`||e.strategy===`take-theirs`?!e.fallback&&!e.deliberateTake:!1}async function v(e,t,n){for(let r=0;r<e.length;r++){let i=e[r];if(_(i)){if(n.signal?.aborted)return;try{e[r]=await o(i,b(t,i.filePath),n)}catch(e){if(n.signal?.aborted)throw e;n.onProgress?.({type:`fix:failed`,filePath:i.filePath,reason:e instanceof Error?e.message:String(e)})}}}}async function y(e,t,r,i,a,o){let s=o.config?.crossFileMaxIterations??2,c=await n(e,t,i);for(let l=0;l<s&&!o.signal?.aborted;l++){if(o.budget?.exhausted()){a.onBudgetExhausted?.();break}let s=S(c.findings,e);if(s.size===0)break;let l=!1;for(let[t,n]of s){if(o.budget?.exhausted()){a.onBudgetExhausted?.();break}let i=e.findIndex(e=>e.filePath===t);if(i<0)continue;let s=e[i],c=s.content;try{let o=await x(s,n,b(r,t),r.result,a);e[i]=o,o.content!==c&&(l=!0)}catch(e){if(o.signal?.aborted)throw e;o.onProgress?.({type:`fix:failed`,filePath:t,reason:e instanceof Error?e.message:String(e)})}}if(!l)break;c=await n(e,t,i)}return c}function b(e,t){return{ours:e?.ours.get(t),theirs:e?.theirs.get(t)}}async function x(e,n,o,l,d){let f={parser:d.parser,validator:d.validator,signal:d.signal},p=s(await t(e.filePath,o,e.content,f)),m=await C(n,l,d.parser,d.signal),g=await i(e.content,e.description,u(n),{model:d.model,signal:d.signal,temperature:d.config?.temperature,refineMaxSteps:d.config?.refineMaxSteps,onProgress:d.onProgress,filePath:e.filePath,budget:d.budget,relatedDefinitions:m});if(g.edits.length===0)return e;if(!r(e.filePath,g.content).valid)return d.onProgress?.({type:`refine:discarded`,filePath:e.filePath,reason:`Cross-file fix introduced conflict markers.`}),e;let _=await t(e.filePath,o,g.content,f);return h(p,s(_))?(d.onProgress?.({type:`refine:discarded`,filePath:e.filePath,reason:`Cross-file fix left the file with a new or additional error.`}),e):c({...e,content:g.content,strategy:`ai`,edits:[...e.edits??[],...g.edits],confidence:Math.min(e.confidence,a.refineApplied)},_.validator)}function S(e,t){let n=new Set(t.filter(_).map(e=>e.filePath)),r=new Map;for(let t of e){if(t.tier!==`project`||t.severity!==`error`||!n.has(t.location.file))continue;let e=r.get(t.location.file)??[];e.push(t),r.set(t.location.file,e)}return r}async function C(e,t,n,r){let i=new Set;for(let n of e){let e=n.definitionFile;e&&t.has(e)&&i.add(e)}if(i.size===0)return;let a=[];for(let e of i){let i=t.get(e);if(i==null)continue;let o=(await n.analyze(new Map([[e,i]]),r)).get(e);if(!o||o.definitions.length===0)continue;let s=o.definitions.slice(0,50).map(e=>{let t=f(e.name),n=e.kind?f(e.kind):void 0;return n?`${t} (${n}, line ${e.line})`:`${t} (line ${e.line})`});a.push({file:f(e),symbols:s})}return a.length>0?a:void 0}export{o as runFixLoop,g as runFixPhase};

package/dist/resolver/mechanical.d.ts

@@ -0,0 +1,25 @@
+import { UnmergedEntry, UnmergedStages } from "../ports/git.js";
+
+//#region src/resolver/mechanical.d.ts
+declare const SYMLINK_MODE = "120000";
+/** How an unmerged entry may be settled without a model call. `mechanical` — git already decided the
+ *  content and placed it in the worktree; `removed` — both sides removed the path from their tree, so
+ *  only the surviving name (not its deletion) is undecided; `skip` — a tree-level entry no content
+ *  resolver can act on; `none` — ordinary, hand it to the normal resolve path. */
+type UnmergedClassification = {
+  kind: 'mechanical';
+} | {
+  kind: 'removed';
+} | {
+  kind: 'skip';
+  reason: 'submodule';
+} | {
+  kind: 'none';
+};
+/** Classifies every unmerged entry of one operation by its index-stage signature, keyed by path. */
+declare function classifyUnmergedEntries(entries: UnmergedEntry[]): Map<string, UnmergedClassification>;
+/** The mode of the sole present stage when that stage is 2 or 3 — no base and one side's content means
+ *  git already computed the result — and `null` for every other signature. */
+declare function loneSideStageMode(stages: UnmergedStages): string | null;
+//#endregion
+export { SYMLINK_MODE, UnmergedClassification, classifyUnmergedEntries, loneSideStageMode };

package/dist/resolver/mechanical.js

@@ -0,0 +1 @@
+const e=`120000`;function t(e){let t=e.some(e=>e.stages!=null&&r(e.stages)),i=new Map;for(let r of e)i.set(r.path,n(r.stages,t));return i}function n(e,t){if(!e)return{kind:`none`};if(r(e))return{kind:`removed`};let n=i(e);return n===null?{kind:`none`}:n===`160000`?{kind:`skip`,reason:`submodule`}:t?{kind:`none`}:{kind:`mechanical`}}function r(e){return e.stage1!==null&&e.stage2===null&&e.stage3===null}function i(e){return e.stage1===null?e.stage2!==null&&e.stage3===null?e.stage2:e.stage3!==null&&e.stage2===null?e.stage3:null:null}export{e as SYMLINK_MODE,t as classifyUnmergedEntries,i as loneSideStageMode};

package/dist/resolver/model-budget.d.ts

@@ -0,0 +1,26 @@
+import { ConflictModelPort } from "../ports/model.js";
+
+//#region src/resolver/model-budget.d.ts
+/** A shared, per-operation counter of `model.generate` calls. Created once per {@link resolveConflicts}
+ *  run; the wrapped model increments the counter but never blocks — enforcement is the caller's job via
+ *  {@link ModelBudget.exhausted}, checked before fix-phase model calls only. Counting instead of throwing
+ *  is deliberate: a throw inside the resolve loop would be caught by the fallback path and degrade a good
+ *  resolution into a whole-side take — the exact data loss this package guards against. */
+interface ModelBudget {
+  /** Wrap a model so every `generate` call increments this budget's shared counter, then delegates to
+   *  the real model unchanged. Multiple wraps share one counter. */
+  wrap(model: ConflictModelPort): ConflictModelPort;
+  spent(): number;
+  /** The configured cap. 0 when the budget is unlimited — check {@link ModelBudget.exhausted} rather
+   *  than comparing against this. */
+  limit(): number;
+  /** Calls left before the cap. `Infinity` when the budget is unlimited (`max` undefined). */
+  remaining(): number;
+  exhausted(): boolean;
+  /** Runs `notify` the first time it is called on this budget, and never again. The budget owns the
+   *  once-only invariant so no caller can get the dedupe wrong across the two fix stages. */
+  notifyExhaustedOnce(notify: () => void): void;
+}
+declare function createModelBudget(max?: number): ModelBudget;
+//#endregion
+export { ModelBudget, createModelBudget };

package/dist/resolver/model-budget.js

@@ -0,0 +1 @@
+function e(e){let t=Number.isFinite(e)?e:void 0,n=0,r=!1,i=()=>t===void 0?1/0:t-n;return{wrap(e){return{generate:t=>(n++,e.generate(t))}},spent:()=>n,limit:()=>t??0,remaining:i,exhausted:()=>i()<=0,notifyExhaustedOnce(e){r||(r=!0,e())}}}export{e as createModelBudget};

package/dist/resolver/parse-response.d.ts

@@ -9,5 +9,13 @@ interface ParsedResolution {
   followUpInstructions?: string[];
 }
 declare function parseModelResponse(text: string, markerCount: number): ParsedResolution;
+/** The model's answer to a rename/rename name decision. `path` is always one of the two candidates it
+ *  was offered — never the base path and never a new name. */
+interface RenameChoice {
+  path: string;
+  confidence: number;
+  description?: string;
+}
+declare function parseRenameChoice(text: string, candidates: readonly string[]): RenameChoice;
 //#endregion
-export { ParsedResolution, parseModelResponse };
+export { ParsedResolution, RenameChoice, parseModelResponse, parseRenameChoice };