@effect-agent/pr-review 0.1.0-beta.20 → 0.1.0-beta.22

package/dist/{github-DnenG3be.mjs → github-BgtP7Rdv.mjs}

@@ -169,6 +169,18 @@ const annotatePatch = (patch) => {
 	return output.join("\n");
 };
 //#endregion
+//#region src/internal/anchors.ts
+/** Why a finding cannot anchor to the current new-version diff, if any. */
+const anchorViolation = (finding, files) => {
+	const file = files.find((candidate) => candidate.path === finding.path);
+	if (file === void 0) return "path is not part of the changeset";
+	if (file.patch === void 0) return "file has no anchorable textual diff";
+	if (finding.endLine < finding.startLine) return "endLine precedes startLine";
+	if (finding.endLine - finding.startLine + 1 > 100) return "range is implausibly large";
+	const anchors = commentableLines(file.patch);
+	for (let line = finding.startLine; line <= finding.endLine; line += 1) if (!anchors.has(line)) return `line ${line} is not part of the diff`;
+};
+//#endregion
 //#region src/internal/source.ts
 /** Reading a file head version larger than this is refused, never truncated silently. */
 const MAX_FILE_CHARS = 2e5;
@@ -235,7 +247,7 @@ var PullRequestSource = class extends Context.Service()("@effect-agent/pr-review
 const MAX_FINDINGS = 20;
 /** The hard non-anchored-concerns bound carried by the CodeReview schema. */
 const MAX_CONCERNS = 10;
-/** Annotated patches larger than this are truncated with an explicit marker. */
+/** Maximum characters in one deterministic model-visible evidence chunk. */
 const MAX_PATCH_CHARS = 6e4;
 /** The encoded Tool result must retain one complete bounded content fallback. */
 const REVIEW_TOOL_RESULT_MAX_BYTES = 2 * 1024 * 1024;
@@ -287,6 +299,53 @@ var FileDiffView = class extends Schema.Class("@effect-agent/pr-review/FileDiffV
 	annotatedPatch: Schema.String,
 	truncated: Schema.Boolean
 }) {};
+/**
+* Split complete model-visible evidence at deterministic line boundaries.
+* A pathological single line is hard-sliced so every character is still
+* assigned and every chunk remains within the provider-independent bound.
+*/
+const boundedEvidenceChunks = (evidence) => {
+	if (evidence.length <= 6e4) return [evidence];
+	const chunks = [];
+	let offset = 0;
+	while (offset < evidence.length) {
+		let end = Math.min(offset + MAX_PATCH_CHARS, evidence.length);
+		if (end < evidence.length) {
+			const boundary = evidence.lastIndexOf("\n", end - 1);
+			if (boundary >= offset) end = boundary + 1;
+		}
+		if (end === offset) end = Math.min(offset + MAX_PATCH_CHARS, evidence.length);
+		chunks.push(evidence.slice(offset, end));
+		offset = end;
+	}
+	return chunks;
+};
+/** Complete bounded evidence chunks used by deterministic fan-out planning. */
+const fileReviewEvidenceChunks = (file) => {
+	const contentEvidence = renderReviewContent(file);
+	const reviewMode = file.patch !== void 0 ? "diff" : contentEvidence !== void 0 ? "content" : "unavailable";
+	const annotated = file.patch === void 0 ? contentEvidence ?? "" : annotatePatch(file.patch);
+	return boundedEvidenceChunks(annotated).map((annotatedPatch) => ({
+		reviewMode,
+		annotatedPatch
+	}));
+};
+/** Host-owned rendering of one changed file's bounded review evidence. */
+const fileDiffView = (file) => {
+	const chunks = fileReviewEvidenceChunks(file);
+	const first = chunks[0] ?? {
+		reviewMode: "unavailable",
+		annotatedPatch: ""
+	};
+	const truncated = first.reviewMode === "diff" && chunks.length > 1;
+	return FileDiffView.make({
+		path: file.path,
+		status: file.status,
+		reviewMode: first.reviewMode,
+		annotatedPatch: truncated ? `${first.annotatedPatch}\n[diff truncated]` : first.annotatedPatch,
+		truncated
+	});
+};
 const ReadFileDiff = Tool.make("read_file_diff", {
 	description: "Read one changed file's review evidence. A normal unified diff marks valid anchors as R<number>. When GitHub omitted the diff, bounded base/head content is returned with B/H line labels for review but no valid inline anchors.",
 	parameters: FileDiffQuery,
@@ -352,17 +411,7 @@ const readFileDiffHandler = (query) => Effect.gen(function* () {
 		input: relative,
 		reason: "Path is not part of this pull request's changeset."
 	});
-	const contentEvidence = renderReviewContent(file);
-	const reviewMode = file.patch !== void 0 ? "diff" : contentEvidence !== void 0 ? "content" : "unavailable";
-	const annotated = file.patch === void 0 ? contentEvidence ?? "" : annotatePatch(file.patch);
-	const truncated = reviewMode === "diff" && annotated.length > MAX_PATCH_CHARS;
-	return FileDiffView.make({
-		path: file.path,
-		status: file.status,
-		reviewMode,
-		annotatedPatch: truncated ? `${annotated.slice(0, MAX_PATCH_CHARS)}\n[diff truncated]` : annotated,
-		truncated
-	});
+	return fileDiffView(file);
 });
 /**
 * The `read_file` handler, shared verbatim by the flat reviewer's toolkit
@@ -434,7 +483,7 @@ var ReviewFinding = class extends Schema.Class("@effect-agent/pr-review/ReviewFi
 	title: Schema.NonEmptyString.check(Schema.isMaxLength(120)),
 	body: Schema.NonEmptyString.check(Schema.isMaxLength(2e3)),
 	/** Replacement for exactly lines startLine..endLine; omit when unsure. */
-	suggestion: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(2e3)))
+	suggestion: Schema.optionalKey(Schema.String.annotate({ description: "Committable replacement source code for exactly lines startLine..endLine: the full replacement for every line in the range and nothing else — never prose describing the change, which belongs in body." }).check(Schema.isMaxLength(2e3)))
 }) {};
 const ReviewVerdict = Schema.Literals([
 	"approve",
@@ -489,15 +538,15 @@ const makeReviewInstructions = (options = {}) => (mission) => {
 		mission.body.length > 0 ? `Author description:\n${mission.body}` : "The author provided no description.",
 		...resolveGuidance(options.guidance, mission),
 		"Work in this order:",
-		"1. Call list_changed_files once to see the changeset. That list is your COMPLETE review scope: in incremental reviews it is deliberately a subset of the pull request's full diff (totalFiles counts the whole pull request), and everything it omits was already reviewed or excluded.",
-		"2. Call read_file_diff for every file you review. A normal diff marks new-version anchors as R<number>; only those numbers are valid startLine/endLine values. When GitHub omitted a diff, the tool may return bounded base/head content marked B/H instead. Review that content, but report its defects as non-anchored concerns because B/H lines cannot anchor GitHub comments. Never anchor a finding to a removed (-), B, or H line.",
+		"1. Call list_changed_files once to see the selected input scope. In incremental reviews it is deliberately a subset of the pull request's full diff (totalFiles counts the whole pull request); omitted paths belong to settled prior scope or explicit host exclusions, not to this run.",
+		"2. Call read_file_diff for every listed file. A normal diff marks new-version anchors as R<number>; only those numbers are valid startLine/endLine values. When GitHub omitted a diff, the tool may return bounded base/head content marked B/H instead. Review that content, but report its defects as non-anchored concerns because B/H lines cannot anchor GitHub comments. Never anchor a finding to a removed (-), B, or H line.",
 		"3. Call read_file when you need surrounding context the diff does not show. ONLY listed files are readable — read_file_diff and read_file both return a failed result for any other path (an import, a neighbor, a file named in the description). Do not request or retry unlisted paths; reason from the visible diffs instead and note the gap honestly in your summary when it matters.",
 		"4. Review for real defects first: correctness, security, concurrency, resource leaks, error handling, API misuse. Style nits are least important. Do not praise; do not restate the diff.",
 		"When the diff adds or changes a test, check that it can actually fail: a test that would still pass with the bug present is theatre, not coverage. The usual tell is a loose assertion standing where an exact one belongs — >= or a truthiness check over an expected value, or a snapshot that absorbs whatever it is handed.",
 		"Go shallow only when the diff has no behavioral surface at all: doc typos, formatting, lockfile or generated-code regeneration, a mechanical rename. Line count is not the signal — a one-line change to auth, money, SQL, a comparison operator, or a config default is not trivial.",
 		"Drop bloat-shaped findings before reporting: defensive checks for cases that cannot happen, abstractions used once, comments restating obvious code, tests asserting tautologies, just-in-case guards. A finding must be sound, correct, and worth acting on; prefer an explicit keep over an invented finding.",
 		"5. After collecting anchored findings, deliberately scan for concerns with NO line to point at: deletion or cleanup plans for code the diff replaces, rollout or migration sequencing, coverage gaps the diff implies but does not add, scope questions only the author can answer. Report each as a \"concern\", never as a finding with an invented anchor; report none when none exist.",
-		`6. Write a walkthrough: for every file you reviewed, one factual sentence (<= 240 chars) describing what changed in that file — written for a reader scanning the pull request, never restating the diff line by line. Use only paths from list_changed_files; invented paths are dropped.`,
+		`6. Write a walkthrough: for every file whose evidence you examined, one factual sentence (<= 240 chars) describing what changed in that file — written for a reader scanning the pull request, never restating the diff line by line. Use only paths from list_changed_files; invented paths are dropped.`,
 		"7. Then return ONLY a JSON object — no Markdown fences, no prose before or after — exactly this shape: {\"summary\": <string, 1-3 paragraphs of overall assessment>, \"verdict\": <\"approve\" | \"comment\" | \"request-changes\">, \"findings\": [{\"path\": <string, a changed file path>, \"startLine\": <integer, an R-marked new-file line>, \"endLine\": <integer, >= startLine, same file, R-marked>, \"severity\": <\"blocking\" | \"important\" | \"nit\">, \"category\": <OPTIONAL: \"correctness\" | \"security\" | \"concurrency\" | \"performance\" | \"resources\" | \"error-handling\" | \"testing\" | \"maintainability\" | \"style\" | \"docs\">, \"title\": <string, <= 120 chars>, \"body\": <string, why it matters and what to do>, \"suggestion\": <string, OPTIONAL: replacement text for exactly lines startLine..endLine, ready to commit>}], \"concerns\": <array, OPTIONAL: [{\"severity\": <\"blocking\" | \"important\" | \"nit\">, \"title\": <string, <= 120 chars>, \"body\": <string>}], only for step-5 concerns with no valid anchor — never duplicate a finding here>, \"walkthrough\": <array, OPTIONAL: [{\"path\": <string, a changed file path>, \"summary\": <string, the step-6 sentence>}], one entry per reviewed file>}.",
 		`Report at most ${maxFindings} findings and at most 10 concerns; prefer the most important ones. An empty findings array with verdict "approve" is a valid review. Include "suggestion" only when you are confident the replacement compiles and preserves intent; its text must contain the full replacement for every line in the range and nothing else.`,
 		"Use verdict \"request-changes\" only when at least one finding or concern is \"blocking\". Line anchors you invent will be discarded, so copy R-numbers from read_file_diff output."
@@ -535,19 +584,70 @@ const PullRequestReviewer = Agent.define("pr-reviewer", {
 const MAX_REVIEW_UNITS = 8;
 /** A unit never carries more files than this, regardless of their size. */
 const MAX_UNIT_FILES = 12;
-/** Soft changed-line budget per unit; a single oversized file still gets its own unit. */
+/** Compatibility export; complete evidence chars now own unit packing. */
 const UNIT_CHANGED_LINE_BUDGET = 800;
-/** Flat per-file cost so many tiny files still spread across units. */
-const FILE_OVERHEAD_LINES = 20;
+/**
+* Bound the complete model-visible evidence assigned to one child. This is a
+* character bound rather than a token estimate because it is deterministic,
+* provider-independent, and enforced before any model call.
+*/
+const UNIT_EVIDENCE_CHAR_BUDGET = 24e4;
+/** Maximum complete evidence shards placed in one child brief. */
+const MAX_UNIT_EVIDENCE_SHARDS = 12;
+/**
+* Keep overflow diagnostics bounded to one plan's total assignment capacity.
+* The plan separately records the exact overflow count and every affected
+* path, so identifiers are a deterministic diagnostic sample rather than the
+* authority for whether input coverage is complete.
+*/
+const MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS = 96;
+/** @deprecated Use `MAX_PATCH_CHARS`; this is now the per-shard bound. */
+const MAX_FILE_EVIDENCE_CHARS = MAX_PATCH_CHARS;
 /** The merged review never exceeds the `CodeReview` findings bound. */
 const MAX_MERGED_FINDINGS = 20;
 const ReviewUnitId = Schema.NonEmptyString.check(Schema.isMaxLength(32));
+/** High-risk surfaces that receive an explicit specialist focus label. */
+const ReviewRiskCategory = Schema.Literals([
+	"authentication-authorization",
+	"security-boundary",
+	"persistence-durability",
+	"concurrency",
+	"credential-handling",
+	"external-side-effects"
+]);
+const ReviewDiscoveryPerspective = Schema.Literals(["general", "risk-specialist"]);
+const ReviewPassId = Schema.NonEmptyString.check(Schema.isMaxLength(64));
+const ReviewEvidenceShardId = Schema.NonEmptyString.check(Schema.isMaxLength(32));
+/** One complete bounded slice of a changed path's model-visible evidence. */
+var ReviewEvidenceShard = class extends Schema.Class("@effect-agent/pr-review/ReviewEvidenceShard")({
+	shardId: ReviewEvidenceShardId,
+	path: ChangedPath,
+	ordinal: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+	total: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+	evidenceChars: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).check(Schema.isLessThanOrEqualTo(MAX_PATCH_CHARS))
+}) {};
+const EvidenceShardIds$1 = Schema.Array(ReviewEvidenceShardId).check(Schema.isMinLength(1)).check(Schema.isMaxLength(12));
+/** One required, independently scoped discovery attempt. */
+var ReviewDiscoveryPass = class extends Schema.Class("@effect-agent/pr-review/ReviewDiscoveryPass")({
+	passId: ReviewPassId,
+	unitId: ReviewUnitId,
+	paths: Schema.Array(ChangedPath).check(Schema.isMinLength(1)).check(Schema.isMaxLength(12)),
+	evidenceShardIds: EvidenceShardIds$1,
+	perspective: ReviewDiscoveryPerspective,
+	/** Empty for the general pass; explicit deterministic focus for specialists. */
+	riskCategories: Schema.Array(ReviewRiskCategory).check(Schema.isMaxLength(6))
+}) {};
 /** One bounded slice of the changeset delegated to one child reviewer. */
 var ReviewUnit = class extends Schema.Class("@effect-agent/pr-review/ReviewUnit")({
 	unitId: ReviewUnitId,
 	paths: Schema.Array(ChangedPath).check(Schema.isMinLength(1)).check(Schema.isMaxLength(12)),
+	evidenceShards: Schema.Array(ReviewEvidenceShard).check(Schema.isMinLength(1)).check(Schema.isMaxLength(12)),
 	/** additions + deletions across the unit's files, for honest sizing. */
-	changedLines: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+	changedLines: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	/** Complete model-visible diff/content evidence assigned to each child. */
+	evidenceChars: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).check(Schema.isLessThanOrEqualTo(UNIT_EVIDENCE_CHAR_BUDGET)),
+	/** Host-classified focus labels for the unit's redundant specialist pass. */
+	riskCategories: Schema.Array(ReviewRiskCategory).check(Schema.isMaxLength(6))
 }) {};
 /** The complete deterministic fan-out plan over one changeset. */
 var ReviewUnitPlan = class extends Schema.Class("@effect-agent/pr-review/ReviewUnitPlan")({
@@ -555,8 +655,16 @@ var ReviewUnitPlan = class extends Schema.Class("@effect-agent/pr-review/ReviewU
 	/** True when the source returned fewer files than the pull request has. */
 	truncated: Schema.Boolean,
 	units: Schema.Array(ReviewUnit).check(Schema.isMaxLength(8)),
+	/** Exact discovery calls the coordinator must make. */
+	discoveryPasses: Schema.Array(ReviewDiscoveryPass).check(Schema.isMaxLength(16)),
 	/** Changed files with neither a textual diff nor bounded base/head text. */
 	undiffablePaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(300)),
+	/** Assigned paths with one or more evidence shards beyond plan capacity. */
+	partialEvidencePaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(300)),
+	/** Exact number of shards beyond the bounded unit capacity. */
+	unassignedEvidenceShardCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	/** Bounded deterministic prefix of the unassigned shard identifiers. */
+	unassignedEvidenceShardIds: Schema.Array(ReviewEvidenceShardId).check(Schema.isMaxLength(96)),
 	/**
 	* Diffable files beyond the fan-out capacity (MAX_REVIEW_UNITS units of
 	* MAX_UNIT_FILES files). Never silently dropped: the coordinator must name
@@ -564,62 +672,232 @@ var ReviewUnitPlan = class extends Schema.Class("@effect-agent/pr-review/ReviewU
 	*/
 	unassignedPaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(300))
 }) {};
-const fileCost = (file) => {
-	const contentChars = (file.reviewBaseContent?.length ?? 0) + (file.reviewHeadContent?.length ?? 0);
-	const contentWeight = Math.ceil(contentChars / 200);
-	return file.additions + file.deletions + contentWeight + FILE_OVERHEAD_LINES;
+const riskRules = [
+	{
+		category: "authentication-authorization",
+		patterns: [
+			/auth/,
+			/authoriz/,
+			/permission/,
+			/principal/,
+			/access[-_ ]?control/,
+			/role\b/
+		]
+	},
+	{
+		category: "security-boundary",
+		patterns: [
+			/security/,
+			/sandbox/,
+			/untrusted/,
+			/schema\.decode/,
+			/validation/,
+			/injection/,
+			/csrf/,
+			/xss/,
+			/path traversal/
+		]
+	},
+	{
+		category: "persistence-durability",
+		patterns: [
+			/durab/,
+			/persist/,
+			/storage/,
+			/database/,
+			/\bsql\b/,
+			/journal/,
+			/ledger/,
+			/checkpoint/,
+			/migration/,
+			/transaction/
+		]
+	},
+	{
+		category: "concurrency",
+		patterns: [
+			/concurr/,
+			/semaphore/,
+			/\bfiber/,
+			/race/,
+			/mutex/,
+			/\block\b/,
+			/queue/,
+			/parallel/,
+			/interrupt/
+		]
+	},
+	{
+		category: "credential-handling",
+		patterns: [
+			/credential/,
+			/secret/,
+			/password/,
+			/api[-_ ]?key/,
+			/bearer/,
+			/hmac/,
+			/signature/
+		]
+	},
+	{
+		category: "external-side-effects",
+		patterns: [
+			/publish/,
+			/webhook/,
+			/github/,
+			/fetch\(/,
+			/http/,
+			/send[-_ ]?(email|message)/,
+			/write[-_ ]?(file|record)/,
+			/delete/,
+			/mutation/,
+			/side[-_ ]?effect/,
+			/spawn/,
+			/exec/
+		]
+	}
+];
+/**
+* Deterministic host policy for specialist assignment. It intentionally
+* favors false positives: an extra bounded pass costs work, while a missed
+* high-risk classification removes redundancy. This is not a claim that the
+* keyword policy recognizes every semantically risky change.
+*/
+const classifyReviewRisks = (file) => {
+	const text = [
+		file.path,
+		file.previousPath ?? "",
+		file.patch ?? "",
+		file.reviewBaseContent ?? "",
+		file.reviewHeadContent ?? ""
+	].join("\n").toLowerCase();
+	return riskRules.filter((rule) => rule.patterns.some((pattern) => pattern.test(text))).map((rule) => rule.category);
+};
+/**
+* Whether every claimed finding anchor was present in the exact bounded
+* evidence shards assigned to one unit. This is stricter than checking the
+* full pull-request diff when an oversized path spans multiple units.
+*/
+const findingAnchorInUnitEvidence = (finding, unit, files) => {
+	const file = files.find((candidate) => candidate.path === finding.path);
+	if (file?.patch === void 0 || finding.endLine < finding.startLine) return false;
+	const assignedOrdinals = new Set(unit.evidenceShards.filter((shard) => shard.path === finding.path).map((shard) => shard.ordinal));
+	const visibleLines = /* @__PURE__ */ new Set();
+	const chunks = fileReviewEvidenceChunks(file);
+	for (let index = 0; index < chunks.length; index += 1) {
+		if (!assignedOrdinals.has(index + 1)) continue;
+		for (const line of chunks[index]?.annotatedPatch.split("\n") ?? []) {
+			const match = /^R(\d+) /.exec(line);
+			if (match?.[1] !== void 0) visibleLines.add(Number(match[1]));
+		}
+	}
+	for (let line = finding.startLine; line <= finding.endLine; line += 1) if (!visibleLines.has(line)) return false;
+	return true;
 };
-const unitOf = (index, files) => ReviewUnit.make({
+const uniquePaths = (shards) => [...new Set(shards.map(({ shard }) => shard.path))];
+const plannedEvidenceShards = (files) => {
+	const planned = [];
+	let shardIndex = 0;
+	for (const file of files) {
+		const chunks = fileReviewEvidenceChunks(file);
+		for (let index = 0; index < chunks.length; index += 1) {
+			const chunk = chunks[index];
+			if (chunk === void 0) continue;
+			shardIndex += 1;
+			planned.push({
+				shard: ReviewEvidenceShard.make({
+					shardId: `shard-${String(shardIndex).padStart(4, "0")}`,
+					path: file.path,
+					ordinal: index + 1,
+					total: chunks.length,
+					evidenceChars: chunk.annotatedPatch.length
+				}),
+				file,
+				changedLines: index === 0 ? file.additions + file.deletions : 0
+			});
+		}
+	}
+	return planned;
+};
+const unitOf = (index, shards) => ReviewUnit.make({
 	unitId: `unit-${String(index + 1).padStart(3, "0")}`,
-	paths: files.map((file) => file.path),
-	changedLines: files.reduce((total, file) => total + file.additions + file.deletions, 0)
+	paths: uniquePaths(shards),
+	evidenceShards: shards.map(({ shard }) => shard),
+	changedLines: shards.reduce((total, shard) => total + shard.changedLines, 0),
+	evidenceChars: shards.reduce((total, { shard }) => total + shard.evidenceChars, 0),
+	riskCategories: [...new Set(shards.flatMap(({ file }) => classifyReviewRisks(file)))]
 });
+const discoveryPassesFor = (units) => units.flatMap((unit) => [ReviewDiscoveryPass.make({
+	passId: `${unit.unitId}-general`,
+	unitId: unit.unitId,
+	paths: unit.paths,
+	evidenceShardIds: unit.evidenceShards.map((shard) => shard.shardId),
+	perspective: "general",
+	riskCategories: []
+}), ReviewDiscoveryPass.make({
+	passId: `${unit.unitId}-specialist`,
+	unitId: unit.unitId,
+	paths: unit.paths,
+	evidenceShardIds: unit.evidenceShards.map((shard) => shard.shardId),
+	perspective: "risk-specialist",
+	riskCategories: unit.riskCategories
+})]);
 /**
 * Group the changeset into at most `MAX_REVIEW_UNITS` review units.
 *
 * Deterministic by construction: files are ordered by path (so files sharing
 * a directory become neighbors — directory affinity without a heuristic),
-* then packed greedily in that order under the soft changed-line budget and
-* the hard per-unit file bound. Capacity is finite and explicit:
+* then split into complete line-bounded evidence shards and packed greedily
+* under the hard evidence and per-unit shard bounds. Capacity is finite and
+* explicit:
 *
 * - files without a textual diff are still delegated when the source
 *   recovered complete bounded UTF-8 base/head content. Findings from that
 *   evidence cannot anchor inline and are reported as concerns;
 * - files with neither form of textual evidence surface in
 *   `undiffablePaths` instead of laundering missing coverage;
-* - reviewable files beyond `MAX_REVIEW_UNITS` full units surface in
-*   `unassignedPaths` so the review can report them as unreviewed, never
-*   silently truncated.
+* - an oversized path spans as many deterministic shards and units as needed;
+* - shards beyond `MAX_REVIEW_UNITS` full units surface explicitly, so a path
+*   is partial only when finite plan capacity is genuinely exhausted.
 */
 const planReviewUnits = (files, options) => {
 	const ordered = [...files].sort((left, right) => left.path < right.path ? -1 : 1);
 	const reviewable = ordered.filter(isReviewableFile);
 	const undiffable = ordered.filter((file) => !isReviewableFile(file));
+	const shards = plannedEvidenceShards(reviewable);
 	const groups = [];
 	const unassigned = [];
 	let current = [];
-	let currentCost = 0;
-	for (const file of reviewable) {
-		const cost = fileCost(file);
-		if (current.length >= 12 || current.length > 0 && currentCost + cost > 800) {
+	let currentEvidenceChars = 0;
+	for (const shard of shards) {
+		const nextPaths = /* @__PURE__ */ new Set([...uniquePaths(current), shard.shard.path]);
+		if (current.length >= 12 || nextPaths.size > 12 || current.length > 0 && currentEvidenceChars + shard.shard.evidenceChars > 24e4) {
 			groups.push(current);
 			current = [];
-			currentCost = 0;
+			currentEvidenceChars = 0;
 		}
 		if (groups.length >= 8) {
-			unassigned.push(file);
+			unassigned.push(shard);
 			continue;
 		}
-		current.push(file);
-		currentCost += cost;
+		current.push(shard);
+		currentEvidenceChars += shard.shard.evidenceChars;
 	}
 	if (current.length > 0 && groups.length < 8) groups.push(current);
+	const units = groups.map((group, index) => unitOf(index, group));
+	const assignedShardIds = new Set(units.flatMap((unit) => unit.evidenceShards.map((shard) => shard.shardId)));
+	const assignedPaths = new Set(shards.filter(({ shard }) => assignedShardIds.has(shard.shardId)).map(({ shard }) => shard.path));
+	const unassignedPathsWithEvidence = new Set(unassigned.map(({ shard }) => shard.path));
 	return ReviewUnitPlan.make({
 		totalFiles: files.length,
 		truncated: files.length < options.totalChangedFiles,
-		units: groups.map((group, index) => unitOf(index, group)),
+		units,
+		discoveryPasses: discoveryPassesFor(units),
 		undiffablePaths: undiffable.map((file) => file.path),
-		unassignedPaths: unassigned.map((file) => file.path)
+		partialEvidencePaths: [...unassignedPathsWithEvidence].filter((path) => assignedPaths.has(path)),
+		unassignedEvidenceShardCount: unassigned.length,
+		unassignedEvidenceShardIds: unassigned.slice(0, 96).map(({ shard }) => shard.shardId),
+		unassignedPaths: [...unassignedPathsWithEvidence].filter((path) => !assignedPaths.has(path))
 	});
 };
 const severityRank = {
@@ -652,116 +930,340 @@ const rankAndDedupeFindings = (findings) => {
 };
 //#endregion
 //#region src/internal/fan-out.ts
-/** One child returns at most this many findings; the merge caps the total. */
-const MAX_CHILD_FINDINGS = 8;
-/** One child returns at most this many non-anchored concerns. */
+/** One discovery pass returns at most this many anchored candidates. */
+const MAX_CHILD_FINDINGS = 6;
+/** One discovery pass returns at most this many non-anchored candidates. */
 const MAX_CHILD_CONCERNS = 3;
+/** Every unit receives independent general and specialist discovery passes. */
+const MAX_UNIT_CANDIDATES = 18;
+/** General + specialist discovery for every unit, then one verifier per unit. */
+const MAX_REVIEW_CHILDREN = 24;
+/** Structural minimum for a child that exposes no tools. */
+const MAX_FILE_REVIEW_TOOL_CALLS = 1;
+const ReviewWorkPhase = Schema.Literals(["discovery", "verification"]);
+const ReviewWorkPerspective = Schema.Literals([
+	"general",
+	"risk-specialist",
+	"candidate-verification"
+]);
+const ReviewCandidateId = Schema.NonEmptyString.check(Schema.isMaxLength(96));
+var FindingCandidate = class extends Schema.TaggedClass()("FindingCandidate", {
+	candidateId: ReviewCandidateId,
+	workId: ReviewPassId,
+	unitId: ReviewUnitId,
+	finding: ReviewFinding,
+	evidencePaths: Schema.Array(ChangedPath).check(Schema.isMinLength(1)).check(Schema.isMaxLength(1))
+}) {};
+var ConcernCandidate = class extends Schema.TaggedClass()("ConcernCandidate", {
+	candidateId: ReviewCandidateId,
+	workId: ReviewPassId,
+	unitId: ReviewUnitId,
+	concern: ReviewConcern,
+	evidencePaths: Schema.Array(ChangedPath).check(Schema.isMinLength(1)).check(Schema.isMaxLength(3))
+}) {};
+const ReviewCandidate = Schema.Union([FindingCandidate, ConcernCandidate]);
+/** Deterministic host equivalence for claims repeated across discovery passes. */
+const reviewCandidateSubjectKey = (candidate) => candidate._tag === "FindingCandidate" ? `finding:${JSON.stringify(Schema.encodeSync(ReviewFinding)(candidate.finding))}` : `concern:${JSON.stringify(Schema.encodeSync(ReviewConcern)(candidate.concern))}`;
+var CandidateAssessment = class extends Schema.Class("@effect-agent/pr-review/CandidateAssessment")({
+	candidateId: ReviewCandidateId,
+	disposition: Schema.Literals(["confirmed", "rejected"]),
+	/**
+	* Exact suggestion settlement: required when the candidate finding carries
+	* a suggestion, forbidden otherwise. Untrusted child output cannot publish
+	* a GitHub replacement block by prompt compliance alone — the host keeps a
+	* confirmed finding's suggestion only on an exact "committable" settlement.
+	*/
+	suggestion: Schema.optionalKey(Schema.Literals(["committable", "not-committable"]).annotate({ description: "Required exactly when the candidate finding carries a suggestion: \"committable\" only when its text is the full replacement source for exactly lines startLine..endLine and nothing else. Forbidden for candidates without a suggestion." })),
+	rationale: Schema.NonEmptyString.check(Schema.isMaxLength(600))
+}) {};
 /**
-* One mandatory diff read plus one bounded context read for every path in a
-* maximum-size unit. Keep the child and delegation reservation aligned.
+* Exact suggestion settlement shape: a carried suggestion must be settled and
+* nothing else may be. Enforced identically by the live delegation projection
+* and the independent host coverage fold.
 */
-const MAX_FILE_REVIEW_TOOL_CALLS = 24;
-const FileReviewToolkit = Toolkit.make(ReadFileDiff, ReadFile);
-const FileReviewToolkitLayer = FileReviewToolkit.toLayer({
-	read_file_diff: readFileDiffHandler,
-	read_file: readFileHandler
-});
+const assessmentSettlesSuggestionExactly = (assessment, candidate) => candidate._tag === "FindingCandidate" && candidate.finding.suggestion !== void 0 ? assessment.suggestion !== void 0 : assessment.suggestion === void 0;
+/**
+* Fail-closed publication of a confirmed finding: only an exact "committable"
+* settlement keeps the suggestion; anything else publishes the finding with
+* the suggestion stripped so unverified text can never become a one-click
+* GitHub replacement block.
+*/
+const confirmedFindingForPublication = (assessment, candidate) => {
+	if (candidate.finding.suggestion === void 0 || assessment.suggestion === "committable") return candidate.finding;
+	const { suggestion: _stripped, ...finding } = candidate.finding;
+	return ReviewFinding.make(finding);
+};
+/**
+* Concern candidates need explicit paths internally to bind the claim to
+* scheduled evidence. The verifier receives the complete bounded unit so it
+* can use neighboring evidence to falsify the claim. The public ReviewConcern
+* remains path-free after the host confirms and projects it.
+*/
+var DiscoveredConcern = class extends Schema.Class("@effect-agent/pr-review/DiscoveredConcern")({
+	concern: ReviewConcern,
+	evidencePaths: Schema.Array(ChangedPath).check(Schema.isMinLength(1)).check(Schema.isMaxLength(3))
+}) {};
 const UnitPaths = Schema.Array(ChangedPath).check(Schema.isMinLength(1)).check(Schema.isMaxLength(12));
-/** The child Agent input: one briefed unit of the changeset. */
+const RiskCategories = Schema.Array(ReviewRiskCategory).check(Schema.isMaxLength(6));
+const Candidates = Schema.Array(ReviewCandidate).check(Schema.isMaxLength(18));
+const EvidenceShardIds = Schema.Array(ReviewEvidenceShardId).check(Schema.isMinLength(1)).check(Schema.isMaxLength(12));
+/** Strict-object coordinator request for either discovery or verification. */
+var FileReviewRequest = class extends Schema.Class("@effect-agent/pr-review/FileReviewRequest")({
+	phase: ReviewWorkPhase,
+	workId: ReviewPassId,
+	unitId: ReviewUnitId,
+	paths: UnitPaths,
+	evidenceShardIds: EvidenceShardIds,
+	perspective: ReviewWorkPerspective,
+	riskCategories: RiskCategories,
+	/** Empty for discovery; the exact discovered set for unit verification. */
+	candidates: Candidates
+}) {};
+/** One complete host-selected evidence shard supplied to a review child. */
+var FileReviewEvidence = class extends Schema.Class("@effect-agent/pr-review/FileReviewEvidence")({
+	shardId: ReviewEvidenceShardId,
+	path: ChangedPath,
+	status: ChangedFileStatus,
+	reviewMode: Schema.Literals([
+		"diff",
+		"content",
+		"unavailable"
+	]),
+	ordinal: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+	total: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+	annotatedPatch: Schema.String.check(Schema.isMaxLength(MAX_PATCH_CHARS))
+}) {};
+/** Host-prepared child input with complete bounded diff/content evidence. */
 var FileReviewBrief = class extends Schema.Class("@effect-agent/pr-review/FileReviewBrief")({
+	phase: ReviewWorkPhase,
+	workId: ReviewPassId,
 	unitId: ReviewUnitId,
 	paths: UnitPaths,
-	focus: Schema.NonEmptyString.check(Schema.isMaxLength(200))
+	evidenceShardIds: EvidenceShardIds,
+	perspective: ReviewWorkPerspective,
+	riskCategories: RiskCategories,
+	candidates: Candidates,
+	evidence: Schema.Array(FileReviewEvidence).check(Schema.isMinLength(1)).check(Schema.isMaxLength(12))
 }) {};
-/** The child Agent output: the briefed unit's bounded findings and concerns. */
+/** Child output; phase-inapplicable collections must be empty. */
 var FileReviewReport = class extends Schema.Class("@effect-agent/pr-review/FileReviewReport")({
+	phase: ReviewWorkPhase,
+	workId: ReviewPassId,
 	unitId: ReviewUnitId,
-	findings: Schema.Array(ReviewFinding).check(Schema.isMaxLength(8)),
-	/** Unit-scoped concerns with no diff line to anchor to. */
-	concerns: Schema.optionalKey(Schema.Array(ReviewConcern).check(Schema.isMaxLength(3))),
-	/** One-sentence per-file change summaries for the merged walkthrough. */
-	fileSummaries: Schema.optionalKey(Schema.Array(WalkthroughEntry).check(Schema.isMaxLength(12)))
+	findings: Schema.Array(ReviewFinding).check(Schema.isMaxLength(6)),
+	concerns: Schema.Array(DiscoveredConcern).check(Schema.isMaxLength(3)),
+	fileSummaries: Schema.Array(WalkthroughEntry).check(Schema.isMaxLength(12)),
+	assessments: Schema.Array(CandidateAssessment).check(Schema.isMaxLength(18))
 }) {};
+/** Bounded coordinator-visible result with host-assigned candidate IDs. */
+var FileReviewUnitResult = class extends Schema.Class("@effect-agent/pr-review/FileReviewUnitResult")({
+	phase: ReviewWorkPhase,
+	workId: ReviewPassId,
+	unitId: ReviewUnitId,
+	candidates: Candidates,
+	fileSummaries: Schema.Array(WalkthroughEntry).check(Schema.isMaxLength(12)),
+	assessments: Schema.Array(CandidateAssessment).check(Schema.isMaxLength(18))
+}) {};
+var FileReviewUnitFailed = class extends Schema.TaggedError()("FileReviewUnitFailed", {
+	childErrorTag: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	message: Schema.String.check(Schema.isMaxLength(400))
+}) {};
+var FileReviewWorkRejected = class extends Schema.TaggedError()("FileReviewWorkRejected", {
+	workId: ReviewPassId,
+	reason: Schema.NonEmptyString.check(Schema.isMaxLength(600))
+}) {};
+const FileReviewFailure = Schema.Union([FileReviewUnitFailed, FileReviewWorkRejected]);
 const staticGuidanceLines = (guidance) => {
 	if (guidance === void 0) return [];
 	return (typeof guidance === "string" ? [guidance] : guidance).filter((line) => line.length > 0);
 };
-/** Build the child file-reviewer instructions with optional static guidance. */
-const makeFileReviewerInstructions = (options = {}) => (brief) => [
-	`You are a code reviewer for one unit of a pull request: unit ${brief.unitId}, covering exactly these changed files: ${brief.paths.join(", ")}. Focus: ${brief.focus}.`,
-	...staticGuidanceLines(options.guidance),
-	"Work in this order:",
-	"1. Call read_file_diff for every file in your unit. A normal diff marks new-version anchors as R<number>; only those numbers are valid startLine/endLine values. When GitHub omitted a diff, the tool may return bounded base/head content marked B/H instead. Review that content, but report its defects as non-anchored concerns because B/H lines cannot anchor GitHub comments. Never anchor a finding to a removed (-), B, or H line.",
-	"2. Call read_file when you need surrounding context the diff does not show. ONLY files in the changeset are readable: a request for any other path (an import, a neighbor, a config) returns a failed result — do not retry it; reason from the diff instead and note the gap in your report when it matters.",
-	"3. Review for real defects first: correctness, security, concurrency, resource leaks, error handling, API misuse. Style nits are least important. Do not praise; do not restate the diff.",
-	"When the diff adds or changes a test, check that it can actually fail: a test that would still pass with the bug present is theatre, not coverage. The usual tell is a loose assertion standing where an exact one belongs — >= or a truthiness check over an expected value, or a snapshot that absorbs whatever it is handed.",
-	"Drop bloat-shaped findings before reporting: defensive checks for cases that cannot happen, abstractions used once, comments restating obvious code, tests asserting tautologies, just-in-case guards. A finding must be sound, correct, and worth acting on; prefer an explicit keep over an invented finding.",
-	`4. For every file in your unit, write one factual sentence (<= 240 chars) describing what changed in that file — for a reader scanning the pull request, never a line-by-line restatement.`,
-	`5. Then return ONLY a JSON object — no Markdown fences, no prose before or after — exactly this shape: {"unitId": ${JSON.stringify(brief.unitId)}, "findings": [{"path": <string, a file in your unit>, "startLine": <integer, an R-marked new-file line>, "endLine": <integer, >= startLine, same file, R-marked>, "severity": <"blocking" | "important" | "nit">, "category": <OPTIONAL: "correctness" | "security" | "concurrency" | "performance" | "resources" | "error-handling" | "testing" | "maintainability" | "style" | "docs">, "title": <string, <= 120 chars>, "body": <string, why it matters and what to do>, "suggestion": <string, OPTIONAL: replacement text for exactly lines startLine..endLine, ready to commit>}], "concerns": <array, OPTIONAL: [{"severity": <"blocking" | "important" | "nit">, "title": <string, <= 120 chars>, "body": <string>}], only for concerns about YOUR unit's files with no valid line anchor (a missing cleanup, a coverage gap the diff implies, sequencing the diff leaves open) — never duplicate a finding here>, "fileSummaries": <array, OPTIONAL: [{"path": <string, a file in your unit>, "summary": <string, the step-4 sentence>}], one entry per file in your unit>}.`,
-	`Report at most 8 findings and at most 3 concerns; prefer the most important ones. An empty findings array is a valid report. Never report on files outside your unit. Line anchors you invent will be discarded, so copy R-numbers from read_file_diff output.`
-].join("\n");
+const evidenceInstructions = [
+	"The host placed complete bounded review evidence shards in the input evidence array. Treat every shard as required input; ordinal/total identifies multi-shard paths.",
+	"You have no tools and cannot roam outside this evidence. If it is insufficient for a candidate, reject or omit that candidate rather than guessing.",
+	"A diff marks new-version anchors as R<number>; only those lines may anchor findings. B/H content evidence is non-anchorable."
+];
+/** Discovery and verification instructions share one child definition. */
+const makeFileReviewerInstructions = (options = {}) => (brief) => {
+	const common = [
+		`You are an attached review worker for ${brief.workId} in host-planned unit ${brief.unitId}: ${brief.paths.join(", ")}.`,
+		...staticGuidanceLines(options.guidance),
+		...evidenceInstructions
+	];
+	if (brief.phase === "verification") return [
+		...common,
+		"Independently verify every candidate in the input. You did not receive another reviewer's transcript or reasoning; use only the candidate claim and bounded evidence.",
+		"The evidence array contains the complete bounded unit, including neighboring changed code that may confirm or falsify a locally plausible claim.",
+		"For each candidate, try to falsify it first. Confirm only when the cited behavior is supported and actionable. Reject unsupported, speculative, duplicate, or non-actionable candidates.",
+		"Return ONLY JSON with phase \"verification\", the exact workId/unitId, empty findings/concerns/fileSummaries arrays, and exactly one assessment per candidateId. Each assessment is {\"candidateId\": <exact id>, \"disposition\": <\"confirmed\" | \"rejected\">, \"suggestion\": <\"committable\" | \"not-committable\", present exactly when the candidate finding carries a suggestion>, \"rationale\": <bounded evidence-based reason>}. Never add or omit an id.",
+		"Settle every carried suggestion independently of the claim: answer \"committable\" only when its text is the full replacement source for exactly lines startLine..endLine and nothing else — it compiles in context and preserves the finding's intent, never prose describing a change. Otherwise answer \"not-committable\"; the host then publishes the confirmed finding without its suggestion. Omit the assessment \"suggestion\" field for candidates without one."
+	].join("\n");
+	const focus = brief.perspective === "risk-specialist" ? brief.riskCategories.length > 0 ? `This is a fresh specialist discovery pass. Concentrate on these host-classified risks without relying on another pass: ${brief.riskCategories.join(", ")}.` : "This is a fresh specialist discovery pass. The host found no keyword-classified category, so independently scrutinize authentication/authorization, security boundaries, durability, concurrency, credentials, and external side effects rather than treating classification silence as low risk." : "This is the general discovery pass. Review broadly for correctness, security, concurrency, resource, API, and error-handling defects.";
+	return [
+		...common,
+		focus,
+		"The discovery evidence array contains every complete shard in the unit. Review every entry and every shard of a multi-shard path. A later independent verifier, not you, decides which candidates publish.",
+		"When a non-anchored concern depends on one or more unit files, list 1-3 exact evidencePaths to bind the claim to scheduled evidence.",
+		`Return ONLY JSON with phase "discovery", the exact workId/unitId, up to 6 findings, up to 3 concerns shaped as {concern, evidencePaths}, one factual file summary per path (<= 240 chars), and an empty assessments array. Empty candidate arrays are valid; do not invent defects.`,
+		"Each finding is {\"path\": <a unit file path>, \"startLine\": <integer, an R-marked new-file line>, \"endLine\": <integer, >= startLine, same file, R-marked>, \"severity\": <\"blocking\" | \"important\" | \"nit\">, \"category\": <OPTIONAL problem-kind label>, \"title\": <string, <= 120 chars>, \"body\": <string, why it matters and what to do>, \"suggestion\": <string, OPTIONAL: replacement source code for exactly lines startLine..endLine, ready to commit>}.",
+		"Include \"suggestion\" only when you are confident the replacement compiles and preserves intent; its text must contain the full replacement source for every line in the range and nothing else — never prose describing the change, which belongs in \"body\"."
+	].join("\n");
+};
 const fileReviewerInstructions = makeFileReviewerInstructions();
-/** The default per-unit child execution bounds. */
+const FileReviewToolkit = Toolkit.empty;
+/** Compatibility export: the evidence-only child has no handler requirements. */
+const FileReviewToolkitLayer = Layer.empty;
 const defaultFileReviewerPolicy = AgentPolicy.make({
-	maxTurns: 8,
-	maxToolCalls: MAX_FILE_REVIEW_TOOL_CALLS,
+	maxTurns: 6,
+	maxToolCalls: 1,
 	maxDuration: "6 minutes",
 	toolConcurrency: 2,
-	repeatedFailureLimit: 12,
+	repeatedFailureLimit: 6,
 	tokenBudget: 2e5,
 	contextTokenLimit: 15e4,
 	toolResultBounds: ToolResultBounds.make({ maxBytes: REVIEW_TOOL_RESULT_MAX_BYTES }),
 	onExhaustion: "fail"
 });
-/** The model-decoded delegation parameters: which unit to review. */
-var FileReviewRequest = class extends Schema.Class("@effect-agent/pr-review/FileReviewRequest")({
-	unitId: ReviewUnitId,
-	paths: UnitPaths
-}) {};
-/** The bounded parent-visible result of one delegated unit review. */
-var FileReviewUnitResult = class extends Schema.Class("@effect-agent/pr-review/FileReviewUnitResult")({
-	unitId: ReviewUnitId,
-	findings: Schema.Array(ReviewFinding).check(Schema.isMaxLength(8)),
-	/** Unit-scoped concerns with no diff line to anchor to. */
-	concerns: Schema.optionalKey(Schema.Array(ReviewConcern).check(Schema.isMaxLength(3))),
-	/** One-sentence per-file change summaries for the merged walkthrough. */
-	fileSummaries: Schema.optionalKey(Schema.Array(WalkthroughEntry).check(Schema.isMaxLength(12)))
-}) {};
-/**
-* One unit's review failed: the child Run ended in a typed failure (policy
-* bound, output violation, model fault). The marker is bounded and carries no
-* child transcript content beyond the failure tag and message.
-*/
-var FileReviewUnitFailed = class extends Schema.TaggedError()("FileReviewUnitFailed", {
-	childErrorTag: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
-	message: Schema.String.check(Schema.isMaxLength(400))
-}) {};
-/**
-* Finite per-invocation bounds (SUB-009), aligned with the child's own
-* AgentPolicy: the child's policy is the limit that trips typed; the
-* reservation mirrors it so parent-side accounting stays honest.
-*/
 const fileReviewPolicy = SubagentPolicy.make({
-	maxChildren: 8,
-	maxConcurrency: 3,
-	maxTurns: 8,
-	maxToolCalls: MAX_FILE_REVIEW_TOOL_CALLS,
-	maxDuration: "6 minutes"
+	maxChildren: MAX_REVIEW_CHILDREN,
+	maxConcurrency: 4,
+	maxTurns: 6,
+	maxToolCalls: 1,
+	maxDuration: "6 minutes",
+	maxResultBytes: 256 * 1024
 });
-const delegationDescription = "Delegate the review of one planned unit to a bounded file-reviewer child and return its line-anchored findings. Call it exactly once per unit from list_review_units; never retry a failed unit.";
-/**
-* Total mapping from every expected child Run failure to the declared unit
-* failure (SUB-028): the tag plus a bounded message, nothing else crosses.
-*/
 const mapFileReviewChildFailure = (failure) => FileReviewUnitFailed.make({
 	childErrorTag: failure._tag,
 	message: (failure.message ?? "").slice(0, 400)
 });
-var ListReviewUnitsQuery = class extends Schema.Class("@effect-agent/pr-review/ListReviewUnitsQuery")({ 
-/** Explicit constant keeps the zero-choice operation compatible with strict provider schemas. */
-scope: Schema.Literal("all") }) {};
+const sameStrings = (left, right) => left.length === right.length && left.every((value, index) => value === right[index]);
+const rejectWork = (workId, reason) => FileReviewWorkRejected.make({
+	workId,
+	reason
+});
+/** Validate coordinator scheduling against the current deterministic plan. */
+const prepareReviewBrief = (request) => Effect.gen(function* () {
+	const source = yield* PullRequestSource;
+	const mapSourceFailure = (failure) => rejectWork(request.workId, `pull-request source ${failure.operation} failed: ${failure.reason}`.slice(0, 600));
+	const files = yield* source.changedFiles.pipe(Effect.mapError(mapSourceFailure));
+	const plan = planReviewUnits(files, { totalChangedFiles: (yield* source.metadata.pipe(Effect.mapError(mapSourceFailure))).totalChangedFiles });
+	const unit = plan.units.find((candidate) => candidate.unitId === request.unitId);
+	if (unit === void 0 || !sameStrings(request.paths, unit.paths) || !sameStrings(request.evidenceShardIds, unit.evidenceShards.map((shard) => shard.shardId))) return yield* rejectWork(request.workId, "request does not match a host-planned unit");
+	if (request.phase === "discovery") {
+		const pass = plan.discoveryPasses.find((candidate) => candidate.passId === request.workId);
+		if (pass === void 0 || pass.unitId !== request.unitId || !sameStrings(pass.paths, request.paths) || !sameStrings(pass.evidenceShardIds, request.evidenceShardIds) || pass.perspective !== request.perspective || !sameStrings(pass.riskCategories, request.riskCategories) || request.candidates.length !== 0) return yield* rejectWork(request.workId, "discovery request does not match the host plan");
+	} else {
+		if (request.workId !== `${request.unitId}-verification` || request.perspective !== "candidate-verification" || !sameStrings(request.riskCategories, unit.riskCategories) || request.candidates.length === 0) return yield* rejectWork(request.workId, "verification request does not match the host-planned unit");
+		const candidateIds = /* @__PURE__ */ new Set();
+		const candidateSubjects = /* @__PURE__ */ new Set();
+		const allowed = new Set(unit.paths);
+		for (const candidate of request.candidates) {
+			const subjectKey = reviewCandidateSubjectKey(candidate);
+			if (candidateIds.has(candidate.candidateId) || candidateSubjects.has(subjectKey) || candidate.unitId !== unit.unitId || candidate.evidencePaths.some((path) => !allowed.has(path)) || candidate._tag === "FindingCandidate" && !allowed.has(candidate.finding.path)) return yield* rejectWork(request.workId, "verification candidates are duplicated or outside the planned unit");
+			candidateIds.add(candidate.candidateId);
+			candidateSubjects.add(subjectKey);
+		}
+	}
+	const byPath = new Map(files.map((file) => [file.path, file]));
+	const evidence = [];
+	for (const shard of unit.evidenceShards) {
+		const file = byPath.get(shard.path);
+		if (file === void 0) return yield* rejectWork(request.workId, `planned evidence path is unavailable: ${shard.path}`);
+		const chunks = fileReviewEvidenceChunks(file);
+		const chunk = chunks[shard.ordinal - 1];
+		if (chunk === void 0 || chunks.length !== shard.total || chunk.annotatedPatch.length !== shard.evidenceChars) return yield* rejectWork(request.workId, `planned evidence shard no longer matches source: ${shard.shardId}`);
+		evidence.push(FileReviewEvidence.make({
+			shardId: shard.shardId,
+			path: shard.path,
+			status: file.status,
+			reviewMode: chunk.reviewMode,
+			ordinal: shard.ordinal,
+			total: shard.total,
+			annotatedPatch: chunk.annotatedPatch
+		}));
+	}
+	return FileReviewBrief.make({
+		...request,
+		evidence
+	});
+});
+const candidateOrdinal = (index) => String(index + 1).padStart(3, "0");
+const projectReviewResult = (report, context, request) => {
+	if (context.budgetExhausted) return Effect.fail(rejectWork(report.workId, "review work exhausted its budget before exact settlement"));
+	if (report.phase !== request.phase || report.workId !== request.workId || report.unitId !== request.unitId) return Effect.fail(rejectWork(request.workId, "review output identity does not match the scheduled request"));
+	if (report.phase === "verification") {
+		if (report.findings.length > 0 || report.concerns.length > 0 || report.fileSummaries.length > 0) return Effect.fail(rejectWork(report.workId, "verification output contained discovery-only fields"));
+		const expectedById = new Map(request.candidates.map((candidate) => [candidate.candidateId, candidate]));
+		const assessedIds = /* @__PURE__ */ new Set();
+		for (const assessment of report.assessments) {
+			const candidate = expectedById.get(assessment.candidateId);
+			if (candidate === void 0 || assessedIds.has(assessment.candidateId)) return Effect.fail(rejectWork(report.workId, "verification output did not assess the exact candidate set"));
+			if (!assessmentSettlesSuggestionExactly(assessment, candidate)) return Effect.fail(rejectWork(report.workId, "verification output did not settle suggestion publication exactly"));
+			assessedIds.add(assessment.candidateId);
+		}
+		if (assessedIds.size !== expectedById.size) return Effect.fail(rejectWork(report.workId, "verification output did not assess the exact candidate set"));
+		return Effect.succeed(FileReviewUnitResult.make({
+			phase: report.phase,
+			workId: report.workId,
+			unitId: report.unitId,
+			candidates: [],
+			fileSummaries: [],
+			assessments: report.assessments
+		}));
+	}
+	if (report.assessments.length > 0) return Effect.fail(rejectWork(report.workId, "discovery output contained verification-only assessments"));
+	const allowed = new Set(request.paths);
+	if (report.findings.some((finding) => !allowed.has(finding.path)) || report.concerns.some((candidate) => candidate.evidencePaths.some((path) => !allowed.has(path))) || report.fileSummaries.some((entry) => !allowed.has(entry.path))) return Effect.fail(rejectWork(report.workId, "discovery output referenced evidence outside the scheduled unit"));
+	return Effect.gen(function* () {
+		const source = yield* PullRequestSource;
+		const mapSourceFailure = (failure) => rejectWork(request.workId, `pull-request source ${failure.operation} failed: ${failure.reason}`.slice(0, 600));
+		const files = yield* source.changedFiles.pipe(Effect.mapError(mapSourceFailure));
+		const metadata = yield* source.metadata.pipe(Effect.mapError(mapSourceFailure));
+		const anchorFiles = yield* source.anchorFiles.pipe(Effect.mapError(mapSourceFailure));
+		const unit = planReviewUnits(files, { totalChangedFiles: metadata.totalChangedFiles }).units.find((candidate) => candidate.unitId === request.unitId);
+		if (unit === void 0) return yield* rejectWork(request.workId, "scheduled review unit is no longer available");
+		for (const finding of report.findings) {
+			const violation = anchorViolation(finding, anchorFiles);
+			if (violation !== void 0 || !findingAnchorInUnitEvidence(finding, unit, files)) return yield* rejectWork(request.workId, `discovery finding has no valid anchor in its assigned evidence: ${violation ?? finding.path}`);
+		}
+		const findingCandidates = report.findings.map((finding, index) => FindingCandidate.make({
+			candidateId: `${request.workId}:finding:${candidateOrdinal(index)}`,
+			workId: request.workId,
+			unitId: request.unitId,
+			finding,
+			evidencePaths: [finding.path]
+		}));
+		const concernCandidates = report.concerns.map((candidate, index) => ConcernCandidate.make({
+			candidateId: `${request.workId}:concern:${candidateOrdinal(index)}`,
+			workId: request.workId,
+			unitId: request.unitId,
+			concern: candidate.concern,
+			evidencePaths: candidate.evidencePaths
+		}));
+		return FileReviewUnitResult.make({
+			phase: report.phase,
+			workId: report.workId,
+			unitId: report.unitId,
+			candidates: [...findingCandidates, ...concernCandidates],
+			fileSummaries: report.fileSummaries,
+			assessments: []
+		});
+	});
+};
+const delegationDescription = "Run exactly one host-planned discovery or candidate-verification child. Copy every plan field and candidate verbatim; never retry failed work.";
+const makeFileReviewDelegation = (child) => Subagent.define("delegate_file_review", {
+	description: delegationDescription,
+	target: child,
+	parameters: FileReviewRequest,
+	success: FileReviewUnitResult,
+	failure: FileReviewFailure,
+	failureMode: "return",
+	prepareInput: prepareReviewBrief,
+	projectResult: projectReviewResult,
+	policy: fileReviewPolicy
+});
+var ListReviewUnitsQuery = class extends Schema.Class("@effect-agent/pr-review/ListReviewUnitsQuery")({ scope: Schema.Literal("all") }) {};
 const ListReviewUnits = Tool.make("list_review_units", {
-	description: "List this pull request's changeset grouped into bounded review units (size-budgeted, directory-affine), plus the files no unit can cover.",
+	description: "List deterministic bounded review units, explicit risk categories, every required discovery pass, and paths the pipeline cannot cover.",
 	parameters: ListReviewUnitsQuery,
 	success: ReviewUnitPlan,
 	failure: PullRequestSourceFailure,
@@ -773,80 +1275,44 @@ const FanOutCoordinatorToolkitLayer = FanOutCoordinatorToolkit.toLayer({ list_re
 	const source = yield* PullRequestSource;
 	return planReviewUnits(yield* source.changedFiles, { totalChangedFiles: (yield* source.metadata).totalChangedFiles });
 }) });
-/**
-* Build the coordinator's instructions. The same consumer guidance the
-* children receive is injected between the mission framing and the procedure
-* so the merged summary and verdict are shaped by the same review profile,
-* and the configured findings bound reaches the merge step instead of only
-* the host-side trim.
-*/
 const makeFanOutReviewInstructions = (options = {}) => (mission) => {
 	const maxFindings = clampMaxFindings(options.maxFindings);
 	return [
-		`You coordinate the review of pull request #${mission.number} ("${mission.title}") in ${mission.repository}, merging ${mission.headRef} into ${mission.baseRef}. It changes ${mission.changedFileCount} file(s).`,
-		mission.body.length > 0 ? `Author description:\n${mission.body}` : "The author provided no description.",
+		`You coordinate the bounded multi-pass review of pull request #${mission.number} ("${mission.title}") in ${mission.repository}.`,
+		mission.body.length > 0 ? `Author description:\n${mission.body}` : "No author description.",
 		...staticGuidanceLines(options.guidance),
-		"Work in this order:",
-		"1. Call list_review_units once to get the planned review units.",
-		"2. Call delegate_file_review EXACTLY once per unit, passing each unit's unitId and paths verbatim. Prefer declaring all delegation calls in one batch. Never review files yourself and never invent units.",
-		"3. A delegation result with \"_tag\" is a FAILED unit. Never retry it; instead your summary MUST name it honestly, e.g. \"unit-002 unreviewed: AgentPolicyError\". The plan's undiffablePaths and unassignedPaths must also be named as not reviewed when present.",
-		`4. Merge the successful units' findings: drop duplicates sharing the same path and line range keeping the most severe, rank blocking > important > nit, and keep at most ${maxFindings} findings. Drop bloat-shaped findings during the merge — defensive checks for cases that cannot happen, abstractions used once, comments restating obvious code, tests asserting tautologies; children bias toward recommending changes, and a finding must be sound, correct, and worth acting on to survive.`,
-		`5. Merge the units' concerns the same way: drop duplicates keeping the most severe, and keep at most 10.`,
-		"6. Merge the units' fileSummaries into one walkthrough: copy each entry verbatim, one entry per file, dropping duplicate paths.",
-		"7. Then return ONLY a JSON object — no Markdown fences, no prose before or after — exactly this shape: {\"summary\": <string, 1-3 paragraphs of overall assessment, including every unreviewed unit or file>, \"verdict\": <\"approve\" | \"comment\" | \"request-changes\">, \"findings\": [{\"path\": <string>, \"startLine\": <integer>, \"endLine\": <integer>, \"severity\": <\"blocking\" | \"important\" | \"nit\">, \"category\": <string, OPTIONAL>, \"title\": <string, <= 120 chars>, \"body\": <string>, \"suggestion\": <string, OPTIONAL>}], \"concerns\": <array, OPTIONAL: [{\"severity\": <\"blocking\" | \"important\" | \"nit\">, \"title\": <string, <= 120 chars>, \"body\": <string>}], the merged unit concerns>, \"walkthrough\": <array, OPTIONAL: [{\"path\": <string>, \"summary\": <string>}], the merged fileSummaries>}. Copy findings (including \"category\" and \"suggestion\" when present), concerns, and walkthrough entries verbatim from the delegation results; never invent or edit anchors.",
-		"Use verdict \"request-changes\" only when at least one finding or concern is \"blocking\". An empty findings array with verdict \"approve\" is a valid review when every unit succeeded and found nothing."
+		"1. Call list_review_units exactly once.",
+		"2. For EVERY discoveryPass, call delegate_file_review exactly once with phase \"discovery\", workId=passId, and the pass unitId/paths/evidenceShardIds/perspective/riskCategories verbatim; candidates must be []. Prefer one bounded parallel batch. Never retry.",
+		"3. Group candidates returned by all successful discovery passes by unit. Deterministically deduplicate byte-identical finding or concern payloads, retaining the first candidate in discoveryPass plan order. For every unit with at least one retained candidate, call delegate_file_review exactly once with phase \"verification\", workId \"<unitId>-verification\", perspective \"candidate-verification\", the unit paths/evidenceShardIds/riskCategories, and EVERY retained candidate copied byte-for-byte. Prefer one bounded parallel batch. Never retry.",
+		"4. Verification is authoritative: rejected candidates must not be reported. The host independently reconstructs publishable findings from exact confirmed assessments, so do not select, rewrite, downgrade, or invent findings.",
+		`5. Return ONLY CodeReview JSON. Write a concise summary of completed and failed stages. Set findings=[] and concerns=[]; the host injects exact confirmed candidates. Copy factual fileSummaries into walkthrough without invention. The host publication cap is ${maxFindings}.`,
+		"No configured pipeline can prove absence of defects. Describe settled work, never an exhaustive or defect-free review."
 	].join("\n");
 };
 const fanOutReviewInstructions = makeFanOutReviewInstructions();
-/** The default fan-out coordinator execution bounds. */
 const defaultFanOutPolicy = AgentPolicy.make({
-	maxTurns: 6,
-	maxToolCalls: 9,
-	maxDuration: "15 minutes",
-	toolConcurrency: 3,
+	maxTurns: 7,
+	maxToolCalls: 25,
+	maxDuration: "20 minutes",
+	toolConcurrency: 4,
 	repeatedFailureLimit: 3,
-	tokenBudget: 3e5,
+	tokenBudget: 4e5,
 	contextTokenLimit: 15e4,
 	onExhaustion: "final-answer"
 });
-const makeFileReviewerDefinition = (options = {}) => Agent.define("pr-file-reviewer", {
+const makeFileReviewerDefinition = (options = {}) => Agent.define("pr-review-worker", {
 	input: FileReviewBrief,
 	output: FileReviewReport,
 	instructions: makeFileReviewerInstructions(options),
 	toolkit: FileReviewToolkit,
 	policy: defaultFileReviewerPolicy,
-	description: "Review one bounded unit of a pull request's changeset read-only and return line-anchored findings for exactly those files.",
+	description: "Perform one bounded discovery or independent candidate-verification pass over host-supplied pull-request evidence.",
 	metadata: {
 		deploymentClass: "E",
-		surface: "read-only"
+		surface: "read-only",
+		stage: "discovery-verification"
 	}
 });
-const makeFileReviewDelegation = (child) => Subagent.define("delegate_file_review", {
-	description: delegationDescription,
-	target: child,
-	parameters: FileReviewRequest,
-	success: FileReviewUnitResult,
-	failure: FileReviewUnitFailed,
-	failureMode: "return",
-	prepareInput: (request) => Effect.succeed(FileReviewBrief.make({
-		unitId: request.unitId,
-		paths: request.paths,
-		focus: "defects-first: correctness, security, concurrency, resources, error handling"
-	})),
-	projectResult: (report) => Effect.succeed(FileReviewUnitResult.make({
-		unitId: report.unitId,
-		findings: report.findings,
-		...report.concerns !== void 0 ? { concerns: report.concerns } : {},
-		...report.fileSummaries !== void 0 ? { fileSummaries: report.fileSummaries } : {}
-	})),
-	policy: fileReviewPolicy
-});
-/**
-* The coordinator-facing delegation Tool: the delegation's own first-party
-* contained Tool plus the read-only execution class (the delegated child's
-* whole tool surface is read-only). Effect AI resolves handlers by Tool name,
-* so `SubagentRuntime.layer`'s handler serves this annotated copy unchanged.
-*/
 const delegationToolFor = (delegation) => delegation.tool.annotate(ToolExecutionClass, "readonly");
 const makeFanOutReviewerDefinition = (options, delegation) => Agent.define("pr-fanout-reviewer", {
 	input: ReviewMission,
@@ -854,14 +1320,14 @@ const makeFanOutReviewerDefinition = (options, delegation) => Agent.define("pr-f
 	instructions: makeFanOutReviewInstructions(options),
 	toolkit: Toolkit.make(ListReviewUnits, delegationToolFor(delegation)),
 	policy: defaultFanOutPolicy,
-	description: "Coordinate one pull-request review by fanning bounded per-unit file reviews out to delegated children and merging their findings into one structured review.",
+	description: "Coordinate deterministic general/specialist discovery and independent candidate verification over bounded review units.",
 	metadata: {
 		deploymentClass: "E",
 		surface: "read-only",
-		delegation: "S1-attached"
+		delegation: "S1-attached",
+		assurance: "multi-pass"
 	}
 });
-/** Build one coherent fan-out suite: child, coordinator, and delegation. */
 const makeFanOutReviewSuite = (options = {}) => {
 	const child = makeFileReviewerDefinition({ guidance: options.guidance });
 	const delegation = makeFileReviewDelegation(child);
@@ -872,25 +1338,13 @@ const makeFanOutReviewSuite = (options = {}) => {
 	};
 };
 const defaultSuite = makeFanOutReviewSuite();
-/** The default child Agent Definition. */
 const FileReviewer = defaultSuite.child;
-/** The default coordinator Agent Definition. */
 const FanOutReviewer = defaultSuite.parent;
-/** The default delegation over the default child. */
 const fileReviewDelegation = defaultSuite.delegation;
-/** The default coordinator-facing delegation Tool (first-party contained mode). */
 const DelegateFileReview = delegationToolFor(fileReviewDelegation);
-/** The default coordinator Toolkit. */
 const FanOutReviewToolkit = FanOutReviewer.toolkit;
-/**
-* The contained failure family the delegation can surface as result data
-* (SUB-033), derived from the delegation itself so the coverage decoder can
-* never diverge from what the runtime actually contains.
-*/
 const FileReviewDelegationFailure = fileReviewDelegation.containedFailure;
-/** Runtime wiring: one delegation plus one explicit child Binding. */
 const fanOutHandlersLayerFor = (delegation) => (childBinding) => SubagentRuntime.layer(delegation, childBinding, { mapChildFailure: mapFileReviewChildFailure });
-/** Runtime wiring over the default delegation, mirroring the leaf example. */
 const fanOutHandlersLayer = fanOutHandlersLayerFor(fileReviewDelegation);
 //#endregion
 //#region src/internal/fingerprint.ts
@@ -957,10 +1411,12 @@ var StoredReviewConcern = class extends Schema.Class("@effect-agent/pr-review/St
 	body: StoredText
 }) {};
 /**
-* Versioned state embedded in one successfully covered review. The reviewed
-* head plus the full-scope fingerprint means every path not represented by an
-* unresolved item is accepted at that head; storing hundreds of path strings
-* separately would not fit GitHub's bounded review body in the worst case.
+* Versioned state embedded only after complete input assignment and settled
+* configured review assurance. The head plus full-scope fingerprint forms an
+* incremental baseline; an absent unresolved item never means the path is
+* defect-free. The `acceptedScopeFingerprint` name is retained for wire
+* compatibility. Storing hundreds of path strings separately would not fit
+* GitHub's bounded review body in the worst case.
 */
 var ReviewState = class extends Schema.Class("@effect-agent/pr-review/ReviewState")({
 	version: Schema.Literal(1),
@@ -1170,7 +1626,7 @@ const selectReviewRange = (input) => {
 	const selectedFiles = [...selectedByPath.values()].sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
 	return {
 		mode: "incremental",
-		reason: `changes since successfully reviewed head ${input.priorState.reviewedHeadSha.slice(0, 7)}${baseReason}`,
+		reason: `changes since settled review head ${input.priorState.reviewedHeadSha.slice(0, 7)}${baseReason}`,
 		files: selectedFiles,
 		affectedPaths: [...affectedPaths].sort(),
 		totalFiles: selectedFiles.length,
@@ -1842,6 +2298,6 @@ const fingerprintUnchanged = (current) => Effect.gen(function* () {
 	return Option.isSome(latest) && latest.value === current;
 });
 //#endregion
-export { FanOutReviewToolkit as $, ReadFile as $t, ReviewStateAuthenticator as A, isReviewableFile as An, ReviewUnit as At, selectedPullRequestSourceLayer as B, FileDiffView as Bt, MAX_REVIEW_STATE_MARKER_CHARS as C, ChangedFile as Cn, makeFanOutReviewInstructions as Ct, ReviewScopeMode as D, annotatePatch as Dn, MAX_MERGED_FINDINGS as Dt, ReviewMode as E, MAX_REVIEW_CONTENT_CHARS as En, mapFileReviewChildFailure as Et, buildProfileMission as F, rankAndDedupeFindings as Ft, webCryptoReviewStateAuthenticatorLayer as G, ListChangedFiles as Gt, toStoredFinding as H, FileSliceQuery as Ht, computeProfileFingerprint as I, ChangedFileSummary as It, extractFingerprint as J, MAX_FINDINGS as Jt, FINGERPRINT_MARKER_LENGTH as K, ListChangedFilesQuery as Kt, fromStoredConcern as L, ChangedFilesView as Lt, ReviewStateMarkerTooLarge as M, renderReviewContent as Mn, ReviewUnitPlan as Mt, StoredReviewConcern as N, UNIT_CHANGED_LINE_BUDGET as Nt, ReviewState as O, commentableLines as On, MAX_REVIEW_UNITS as Ot, StoredReviewFinding as P, planReviewUnits as Pt, FanOutCoordinatorToolkitLayer as Q, REVIEW_TOOL_RESULT_MAX_BYTES as Qt, fromStoredFinding as R, CodeReview as Rt, GitCommitSha as S, normalizeRepoRelativePath as Sn, fileReviewerInstructions as St, ReviewHeadComparison as T, ChangedPath as Tn, makeFileReviewerInstructions as Tt, unavailableReviewStateAuthenticatorLayer as U, FindingCategory as Ut, toStoredConcern as V, FileSlice as Vt, validateReviewState as W, FindingSeverity as Wt, DelegateFileReview as X, MAX_WALKTHROUGH_SUMMARY_CHARS as Xt, renderFingerprintMarker as Y, MAX_WALKTHROUGH_ENTRIES as Yt, FanOutCoordinatorToolkit as Z, PullRequestReviewer as Zt, ReviewRetirementHost as _, MAX_FILE_CHARS as _n, fanOutHandlersLayer as _t, PriorReviews as a, ReviewToolkitLayer as an, FileReviewToolkit as at, hasReviewMetadataMarker as b, PullRequestSourceFailure as bn, fileReviewDelegation as bt, fingerprintUnchanged as c, clampMaxFindings as cn, FileReviewUnitResult as ct, gitHubReviewPublisherLayer as d, makeReviewInstructions as dn, ListReviewUnitsQuery as dt, ReadFileDiff as en, FanOutReviewer as et, gitHubReviewRetirementHostLayer as f, readFileDiffHandler as fn, MAX_CHILD_CONCERNS as ft, ReviewRetirementFailure as g, MAX_CHANGED_FILES as gn, defaultFileReviewerPolicy as gt, RetirableReviewComment as h, reviewInstructions as hn, defaultFanOutPolicy as ht, PriorReviewLookupFailure as i, ReviewToolkit as in, FileReviewRequest as it, ReviewStateMarker as j, parsePatch as jn, ReviewUnitId as jt, ReviewStateAuthenticationFailure as k, hasReviewableContent as kn, MAX_UNIT_FILES as kt, gitHubPriorReviewsLayer as l, defaultReviewPolicy as ln, FileReviewer as lt, RetirableReview as m, resolveGuidance as mn, MAX_FILE_REVIEW_TOOL_CALLS as mt, GitHubApiFailure as n, ReviewFinding as nn, FileReviewDelegationFailure as nt, PublishedReview as o, ReviewVerdict as on, FileReviewToolkitLayer as ot, parseGitHubSubmittedAt as p, readFileHandler as pn, MAX_CHILD_FINDINGS as pt, computeChangesetFingerprint as q, MAX_CONCERNS as qt, GitHubReviewTarget as r, ReviewMission as rn, FileReviewReport as rt, ReviewPublisher as s, WalkthroughEntry as sn, FileReviewUnitFailed as st, DEFAULT_GITHUB_REVIEW_AUTHOR_LOGIN as t, ReviewConcern as tn, FileReviewBrief as tt, gitHubPullRequestSourceLayer as u, listChangedFilesHandler as un, ListReviewUnits as ut, ReviewRetirementReport as v, PullRequestMetadata as vn, fanOutHandlersLayerFor as vt, ReviewExecutionContext as w, ChangedFileStatus as wn, makeFanOutReviewSuite as wt, retireStaleReviews as x, ReviewInputViolation as xn, fileReviewPolicy as xt, decideReviewRetirement as y, PullRequestSource as yn, fanOutReviewInstructions as yt, selectReviewRange as z, FileDiffQuery as zt };
+export { DiscoveredConcern as $, normalizeRepoRelativePath as $n, ReviewPassId as $t, ReviewStateAuthenticator as A, ReviewConcern as An, defaultFanOutPolicy as At, selectedPullRequestSourceLayer as B, fileReviewEvidenceChunks as Bn, makeFileReviewerInstructions as Bt, MAX_REVIEW_STATE_MARKER_CHARS as C, MAX_PATCH_CHARS as Cn, MAX_UNIT_CANDIDATES as Ct, ReviewScopeMode as D, REVIEW_TOOL_RESULT_MAX_BYTES as Dn, ReviewWorkPhase as Dt, ReviewMode as E, PullRequestReviewer as En, ReviewWorkPerspective as Et, buildProfileMission as F, ReviewVerdict as Fn, fileReviewDelegation as Ft, webCryptoReviewStateAuthenticatorLayer as G, resolveGuidance as Gn, MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS as Gt, toStoredFinding as H, makeReviewInstructions as Hn, reviewCandidateSubjectKey as Ht, computeProfileFingerprint as I, WalkthroughEntry as In, fileReviewPolicy as It, extractFingerprint as J, MAX_FILE_CHARS as Jn, MAX_UNIT_FILES as Jt, FINGERPRINT_MARKER_LENGTH as K, reviewInstructions as Kn, MAX_REVIEW_UNITS as Kt, fromStoredConcern as L, clampMaxFindings as Ln, fileReviewerInstructions as Lt, ReviewStateMarkerTooLarge as M, ReviewMission as Mn, fanOutHandlersLayer as Mt, StoredReviewConcern as N, ReviewToolkit as Nn, fanOutHandlersLayerFor as Nt, ReviewState as O, ReadFile as On, assessmentSettlesSuggestionExactly as Ot, StoredReviewFinding as P, ReviewToolkitLayer as Pn, fanOutReviewInstructions as Pt, DelegateFileReview as Q, ReviewInputViolation as Qn, ReviewEvidenceShardId as Qt, fromStoredFinding as R, defaultReviewPolicy as Rn, makeFanOutReviewInstructions as Rt, GitCommitSha as S, MAX_FINDINGS as Sn, MAX_REVIEW_CHILDREN as St, ReviewHeadComparison as T, MAX_WALKTHROUGH_SUMMARY_CHARS as Tn, ReviewCandidateId as Tt, unavailableReviewStateAuthenticatorLayer as U, readFileDiffHandler as Un, MAX_FILE_EVIDENCE_CHARS as Ut, toStoredConcern as V, listChangedFilesHandler as Vn, mapFileReviewChildFailure as Vt, validateReviewState as W, readFileHandler as Wn, MAX_MERGED_FINDINGS as Wt, CandidateAssessment as X, PullRequestSource as Xn, ReviewDiscoveryPerspective as Xt, renderFingerprintMarker as Y, PullRequestMetadata as Yn, ReviewDiscoveryPass as Yt, ConcernCandidate as Z, PullRequestSourceFailure as Zn, ReviewEvidenceShard as Zt, ReviewRetirementHost as _, FindingCategory as _n, ListReviewUnits as _t, PriorReviews as a, UNIT_EVIDENCE_CHAR_BUDGET as an, annotatePatch as ar, FileReviewDelegationFailure as at, hasReviewMetadataMarker as b, ListChangedFilesQuery as bn, MAX_CHILD_FINDINGS as bt, fingerprintUnchanged as c, planReviewUnits as cn, isReviewableFile as cr, FileReviewReport as ct, gitHubReviewPublisherLayer as d, ChangedFilesView as dn, FileReviewToolkitLayer as dt, ReviewRiskCategory as en, anchorViolation as er, FanOutCoordinatorToolkit as et, gitHubReviewRetirementHostLayer as f, CodeReview as fn, FileReviewUnitFailed as ft, ReviewRetirementFailure as g, FileSliceQuery as gn, FindingCandidate as gt, RetirableReviewComment as h, FileSlice as hn, FileReviewer as ht, PriorReviewLookupFailure as i, UNIT_CHANGED_LINE_BUDGET as in, MAX_REVIEW_CONTENT_CHARS as ir, FileReviewBrief as it, ReviewStateMarker as j, ReviewFinding as jn, defaultFileReviewerPolicy as jt, ReviewStateAuthenticationFailure as k, ReadFileDiff as kn, confirmedFindingForPublication as kt, gitHubPriorReviewsLayer as l, rankAndDedupeFindings as ln, parsePatch as lr, FileReviewRequest as lt, RetirableReview as m, FileDiffView as mn, FileReviewWorkRejected as mt, GitHubApiFailure as n, ReviewUnitId as nn, ChangedFileStatus as nr, FanOutReviewToolkit as nt, PublishedReview as o, classifyReviewRisks as on, commentableLines as or, FileReviewEvidence as ot, parseGitHubSubmittedAt as p, FileDiffQuery as pn, FileReviewUnitResult as pt, computeChangesetFingerprint as q, MAX_CHANGED_FILES as qn, MAX_UNIT_EVIDENCE_SHARDS as qt, GitHubReviewTarget as r, ReviewUnitPlan as rn, ChangedPath as rr, FanOutReviewer as rt, ReviewPublisher as s, findingAnchorInUnitEvidence as sn, hasReviewableContent as sr, FileReviewFailure as st, DEFAULT_GITHUB_REVIEW_AUTHOR_LOGIN as t, ReviewUnit as tn, ChangedFile as tr, FanOutCoordinatorToolkitLayer as tt, gitHubPullRequestSourceLayer as u, ChangedFileSummary as un, renderReviewContent as ur, FileReviewToolkit as ut, ReviewRetirementReport as v, FindingSeverity as vn, ListReviewUnitsQuery as vt, ReviewExecutionContext as w, MAX_WALKTHROUGH_ENTRIES as wn, ReviewCandidate as wt, retireStaleReviews as x, MAX_CONCERNS as xn, MAX_FILE_REVIEW_TOOL_CALLS as xt, decideReviewRetirement as y, ListChangedFiles as yn, MAX_CHILD_CONCERNS as yt, selectReviewRange as z, fileDiffView as zn, makeFanOutReviewSuite as zt };
 
-//# sourceMappingURL=github-DnenG3be.mjs.map
+//# sourceMappingURL=github-BgtP7Rdv.mjs.map