@effect-agent/pr-review 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/{fan-out-D5xrmadQ.d.mts → fan-out-BJBTAYuh.d.mts}

@@ -1,5 +1,5 @@
 import { Context, DateTime, Effect, Layer, Option, Redacted, Schema } from "effect";
-import { AgentPolicy, RunEvent, RuntimeBinding, SubagentPolicy } from "effect-agent";
+import { AgentPolicy, BudgetAdapterError, BudgetExceeded, RunBudgetHook, RunEvent, RuntimeBinding } from "effect-agent";
 import { Tool, Toolkit } from "effect/unstable/ai";
 import { HttpClient } from "effect/unstable/http";
 //#region src/internal/diff.d.ts
@@ -384,9 +384,148 @@ declare const PullRequestReviewer: import("effect-agent").Definition<typeof Revi
 /** Why a finding cannot anchor to the current new-version diff, if any. */
 declare const anchorViolation: (finding: ReviewFinding, files: ReadonlyArray<ChangedFile>) => string | undefined;
 //#endregion
+//#region src/internal/review-units.d.ts
+/** The delegation fan-out bound: one parent Run spawns at most this many children. */
+declare const MAX_REVIEW_UNITS = 8;
+/** A unit never carries more files than this, regardless of their size. */
+declare const MAX_UNIT_FILES = 12;
+/** Compatibility export; complete evidence chars now own unit packing. */
+declare const UNIT_CHANGED_LINE_BUDGET = 800;
+/**
+ * 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.
+ */
+declare const UNIT_EVIDENCE_CHAR_BUDGET = 240000;
+/** Maximum complete evidence shards placed in one child brief. */
+declare 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.
+ */
+declare const MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS: number;
+/** @deprecated Use `MAX_PATCH_CHARS`; this is now the per-shard bound. */
+declare const MAX_FILE_EVIDENCE_CHARS = 60000;
+/** The merged review never exceeds the `CodeReview` findings bound. */
+declare const MAX_MERGED_FINDINGS = 20;
+declare const ReviewUnitId: Schema.NonEmptyString;
+/** High-risk surfaces that receive an explicit specialist focus label. */
+declare const ReviewRiskCategory: Schema.Literals<readonly ["authentication-authorization", "security-boundary", "persistence-durability", "concurrency", "credential-handling", "external-side-effects"]>;
+type ReviewRiskCategory = typeof ReviewRiskCategory.Type;
+declare const ReviewDiscoveryPerspective: Schema.Literals<readonly ["general", "risk-specialist"]>;
+type ReviewDiscoveryPerspective = typeof ReviewDiscoveryPerspective.Type;
+declare const ReviewPassId: Schema.NonEmptyString;
+declare const ReviewEvidenceShardId: Schema.NonEmptyString;
+declare const ReviewEvidenceShard_base: Schema.Class<ReviewEvidenceShard, Schema.Struct<{
+  readonly shardId: Schema.NonEmptyString;
+  readonly path: Schema.NonEmptyString;
+  readonly ordinal: Schema.Int;
+  readonly total: Schema.Int;
+  readonly evidenceChars: Schema.Int;
+}>, {}>;
+/** One complete bounded slice of a changed path's model-visible evidence. */
+declare class ReviewEvidenceShard extends ReviewEvidenceShard_base {}
+declare const ReviewDiscoveryPass_base: Schema.Class<ReviewDiscoveryPass, Schema.Struct<{
+  readonly passId: Schema.NonEmptyString;
+  readonly unitId: Schema.NonEmptyString;
+  readonly paths: Schema.$Array<Schema.NonEmptyString>;
+  readonly evidenceShardIds: Schema.$Array<Schema.NonEmptyString>;
+  readonly perspective: Schema.Literals<readonly ["general", "risk-specialist"]>;
+  /** Empty for the general pass; explicit deterministic focus for specialists. */
+  readonly riskCategories: Schema.$Array<Schema.Literals<readonly ["authentication-authorization", "security-boundary", "persistence-durability", "concurrency", "credential-handling", "external-side-effects"]>>;
+}>, {}>;
+/** One required, independently scoped discovery attempt. */
+declare class ReviewDiscoveryPass extends ReviewDiscoveryPass_base {}
+declare const ReviewUnit_base: Schema.Class<ReviewUnit, Schema.Struct<{
+  readonly unitId: Schema.NonEmptyString;
+  readonly paths: Schema.$Array<Schema.NonEmptyString>;
+  readonly evidenceShards: Schema.$Array<typeof ReviewEvidenceShard>;
+  /** additions + deletions across the unit's files, for honest sizing. */
+  readonly changedLines: Schema.Int;
+  /** Complete model-visible diff/content evidence assigned to each child. */
+  readonly evidenceChars: Schema.Int;
+  /** Host-classified focus labels for the unit's redundant specialist pass. */
+  readonly riskCategories: Schema.$Array<Schema.Literals<readonly ["authentication-authorization", "security-boundary", "persistence-durability", "concurrency", "credential-handling", "external-side-effects"]>>;
+}>, {}>;
+/** One bounded slice of the changeset delegated to one child reviewer. */
+declare class ReviewUnit extends ReviewUnit_base {}
+declare const ReviewUnitPlan_base: Schema.Class<ReviewUnitPlan, Schema.Struct<{
+  readonly totalFiles: Schema.Int;
+  /** True when the source returned fewer files than the pull request has. */
+  readonly truncated: Schema.Boolean;
+  readonly units: Schema.$Array<typeof ReviewUnit>;
+  /** Exact discovery calls the coordinator must make. */
+  readonly discoveryPasses: Schema.$Array<typeof ReviewDiscoveryPass>;
+  /** Changed files with neither a textual diff nor bounded base/head text. */
+  readonly undiffablePaths: Schema.$Array<Schema.NonEmptyString>;
+  /** Assigned paths with one or more evidence shards beyond plan capacity. */
+  readonly partialEvidencePaths: Schema.$Array<Schema.NonEmptyString>;
+  /** Exact number of shards beyond the bounded unit capacity. */
+  readonly unassignedEvidenceShardCount: Schema.Int;
+  /** Bounded deterministic prefix of the unassigned shard identifiers. */
+  readonly unassignedEvidenceShardIds: Schema.$Array<Schema.NonEmptyString>;
+  /**
+   * Diffable files beyond the fan-out capacity (MAX_REVIEW_UNITS units of
+   * MAX_UNIT_FILES files). Never silently dropped: the coordinator must name
+   * them as unreviewed in its summary.
+   */
+  readonly unassignedPaths: Schema.$Array<Schema.NonEmptyString>;
+}>, {}>;
+/** The complete deterministic fan-out plan over one changeset. */
+declare class ReviewUnitPlan extends ReviewUnitPlan_base {}
+/**
+ * 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.
+ */
+declare const classifyReviewRisks: (file: ChangedFile) => ReadonlyArray<ReviewRiskCategory>;
+/**
+ * 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.
+ */
+declare const findingAnchorInUnitEvidence: (finding: ReviewFinding, unit: ReviewUnit, files: ReadonlyArray<ChangedFile>) => boolean;
+/**
+ * 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 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;
+ * - 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.
+ */
+declare const planReviewUnits: (files: ReadonlyArray<ChangedFile>, options: {
+  readonly totalChangedFiles: number;
+}) => ReviewUnitPlan;
+/**
+ * Merge the children's findings into one bounded, deterministic list: dedupe
+ * findings sharing an anchor (path + line range) keeping the most severe —
+ * and, at equal severity, the first in declaration order — then rank by
+ * severity, path, and line, and cap at the `CodeReview` findings bound.
+ * This is the merge policy the coordinator's instructions state in prose;
+ * pinning it here keeps the policy itself deterministic and testable.
+ */
+declare const rankAndDedupeFindings: (findings: ReadonlyArray<ReviewFinding>) => ReadonlyArray<ReviewFinding>;
+/**
+ * The concern analogue of `rankAndDedupeFindings`: dedupe by exact content
+ * keeping the most severe duplicate, rank by severity, and cap at the
+ * `CodeReview` concerns bound.
+ */
+declare const rankAndDedupeConcerns: (concerns: ReadonlyArray<ReviewConcern>) => ReadonlyArray<ReviewConcern>;
+//#endregion
 //#region src/internal/coverage.d.ts
-declare const ReviewShape: Schema.Literals<readonly ["flat", "fan-out"]>;
-type ReviewShape = typeof ReviewShape.Type;
 declare const FailedReviewUnit_base: Schema.Class<FailedReviewUnit, Schema.Struct<{
   readonly unitId: Schema.NonEmptyString;
   readonly errorTag: Schema.NonEmptyString;
@@ -413,6 +552,14 @@ declare const ReviewInputCoverage_base: Schema.Class<ReviewInputCoverage, Schema
   /** Assigned paths whose model-visible diff was truncated by the evidence bound. */
   readonly partialPaths: Schema.$Array<Schema.NonEmptyString>;
   readonly unassignedPaths: Schema.$Array<Schema.NonEmptyString>;
+  /**
+   * Paths with neither a textual diff nor bounded base/head text (binaries,
+   * oversized files). Fail-closed: they keep the status incomplete for as
+   * long as they are part of the pull request — an unreviewable change must
+   * never authorize a green check. Exclude them deliberately with ignore
+   * globs when that is intended.
+   */
+  readonly undiffablePaths: Schema.$Array<Schema.NonEmptyString>;
   readonly reasons: Schema.$Array<Schema.NonEmptyString>;
 }>, {}>;
 declare class ReviewInputCoverage extends ReviewInputCoverage_base {}
@@ -434,40 +581,56 @@ declare const ReviewAssurance_base: Schema.Class<ReviewAssurance, Schema.Struct<
   readonly confirmedCandidates: Schema.Int;
   readonly rejectedCandidates: Schema.Int;
   readonly unsettledCandidates: Schema.Int;
-  /** Every failure remains visible within the coordinator's 32-call hard bound. */
+  /** Discovery claims discarded for anchors/paths outside their assigned evidence. */
+  readonly discardedInvalidFindings: Schema.Int;
   readonly failedPasses: Schema.$Array<typeof FailedReviewPass>;
   readonly reasons: Schema.$Array<Schema.NonEmptyString>;
 }>, {}>;
+/**
+ * Settlement of scheduled review work. `incomplete` means reviewer-side work
+ * failed after its bounded retry — a machinery gap that is carried forward and
+ * retried on the next run, never a statement about the code under review.
+ * `unverified` is the flat reviewer's honest constant: one pass with no
+ * independent verifier is neither settled assurance nor a failure.
+ */
 declare class ReviewAssurance extends ReviewAssurance_base {}
-interface ReviewPipelineAssessment {
+/** Render a bounded, deterministic "label (n): a, b, … (+k more)" reason line. */
+declare const boundedListReason: (label: string, values: Iterable<string>) => string;
+/** The flat reviewer's honest constant assurance: one pass, no verifier. */
+declare const flatAssurance: () => ReviewAssurance;
+interface FlatReviewAssessment {
   readonly inputCoverage: ReviewInputCoverage;
   readonly assurance: ReviewAssurance;
-  /** Deprecated compatibility aggregate. */
-  readonly coverage: ReviewCoverage;
-  readonly confirmedFindings: ReadonlyArray<ReviewFinding>;
-  readonly confirmedConcerns: ReadonlyArray<ReviewConcern>;
-  readonly walkthrough: ReadonlyArray<WalkthroughEntry>;
+  /** Retryable evidence gaps (failed or missing diff reads), never undiffable paths. */
+  readonly unreviewedPaths: ReadonlyArray<string>;
 }
-/** Assess one settled run without trusting coordinator prose or findings. */
-declare const assessReviewPipeline: (input: {
-  readonly shape: ReviewShape;
+/**
+ * Assess one settled flat run from its Run event trace: which required paths
+ * received successful bounded diff evidence. This observes tool INPUT
+ * assignment only — the host cannot know which evidence the model weighed.
+ */
+declare const assessFlatReview: (input: {
   readonly files: ReadonlyArray<ChangedFile>;
   readonly totalFiles: number;
   readonly anchorFiles: ReadonlyArray<ChangedFile>;
   readonly totalAnchorFiles: number;
   readonly events: ReadonlyArray<RunEvent>;
-}) => ReviewPipelineAssessment;
-/** Compatibility helper; prefer assessReviewPipeline for precise claims. */
-declare const assessReviewCoverage: (input: {
-  readonly shape: ReviewShape;
+}) => FlatReviewAssessment;
+/**
+ * Input coverage of one host-scheduled fan-out plan: which required paths the
+ * bounded plan actually assigned complete evidence for. Capacity overflow and
+ * undiffable paths are both real gaps; the pipeline carries them so the check
+ * stays fail-closed until they are reviewed, removed, or explicitly ignored.
+ */
+declare const fanOutInputCoverage: (input: {
+  readonly plan: ReviewUnitPlan;
   readonly files: ReadonlyArray<ChangedFile>;
   readonly totalFiles: number;
   readonly anchorFiles: ReadonlyArray<ChangedFile>;
   readonly totalAnchorFiles: number;
-  readonly events: ReadonlyArray<RunEvent>;
-}) => ReviewCoverage;
-/** Host-verified summaries from successful general discovery passes only. */
-declare const collectUnitFileSummaries: (events: ReadonlyArray<RunEvent>) => ReadonlyArray<WalkthroughEntry>;
+}) => ReviewInputCoverage;
+/** Compatibility aggregate over the two precise claims. */
+declare const compatibilityCoverage: (inputCoverage: ReviewInputCoverage, assurance: ReviewAssurance) => ReviewCoverage;
 //#endregion
 //#region src/internal/review-state.d.ts
 declare const ReviewMode: Schema.Literals<readonly ["incremental", "final"]>;
@@ -492,8 +655,10 @@ declare const StoredReviewConcern_base: Schema.Class<StoredReviewConcern, Schema
 }>, {}>;
 /** A compact unresolved non-anchored concern carried until a final audit. */
 declare class StoredReviewConcern extends StoredReviewConcern_base {}
+/** The carried-scope bound; a run that cannot fit its leftovers publishes no state. */
+declare const MAX_STORED_UNREVIEWED_PATHS = 100;
 declare const ReviewState_base: Schema.Class<ReviewState, Schema.Struct<{
-  readonly version: Schema.Literal<1>;
+  readonly version: Schema.Literal<2>;
   readonly repository: Schema.NonEmptyString;
   readonly pullRequestNumber: Schema.Int;
   readonly baseRef: Schema.NonEmptyString;
@@ -505,15 +670,26 @@ declare const ReviewState_base: Schema.Class<ReviewState, Schema.Struct<{
   readonly reviewedPathCount: Schema.Int;
   readonly unresolvedFindings: Schema.$Array<typeof StoredReviewFinding>;
   readonly unresolvedConcerns: Schema.$Array<typeof StoredReviewConcern>;
+  /** Retryable review gaps carried into the next incremental run's scope. */
+  readonly unreviewedPaths: Schema.$Array<Schema.NonEmptyString>;
+  /**
+   * True only when the producing run had complete input coverage, no
+   * unsettled pass, and nothing carried. Skip-unchanged authority: an
+   * unchanged patch may skip re-review only over a settled state.
+   */
+  readonly settled: Schema.Boolean;
   readonly lastReviewMode: Schema.Literals<readonly ["incremental", "full"]>;
 }>, {}>;
 /**
- * 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.
+ * Versioned state embedded after EVERY completed run that can be signed. The
+ * head plus full-scope fingerprint forms an incremental baseline; an absent
+ * unresolved item never means the path is defect-free. `unreviewedPaths`
+ * carries retryable review gaps (failed passes) forward so the next
+ * incremental run re-reviews exactly them plus the new delta — the baseline
+ * advances monotonically instead of freezing on one flaky pass and reopening
+ * the whole post-baseline scope. 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.
  */
 declare class ReviewState extends ReviewState_base {}
 declare const toStoredFinding: (finding: ReviewFinding) => StoredReviewFinding;
@@ -677,25 +853,23 @@ declare const planPublication: (review: CodeReview, files: ReadonlyArray<Changed
   readonly modelLabel?: string | undefined;
   /** Workflow-run URL rendered into the footer. */
   readonly runUrl?: string | undefined;
-  /** Observed run usage rendered into the footer. */
+  /** Observed whole-run usage rendered into the footer. */
   readonly usage?: {
     readonly inputTokens: number;
     readonly outputTokens: number;
   } | undefined;
-  /** What the usage observed: the whole run, or the coordinator only. */
-  readonly usageScope?: "run" | "coordinator" | undefined;
   /**
    * Changeset fingerprint embedded invisibly in the review body so a later
    * run can skip re-reviewing an unchanged changeset.
    */
   readonly fingerprint?: string | undefined;
-  /** Host-owned coverage; incomplete coverage is rendered and fails the check. */
-  readonly coverage?: ReviewCoverage | undefined;
   /** Host-owned path/evidence assignment, separate from review assurance. */
   readonly inputCoverage?: ReviewInputCoverage | undefined;
   /** Host-owned discovery/specialist/verification settlement. */
   readonly assurance?: ReviewAssurance | undefined;
-  /** Unchanged unresolved items carried from the prior settled assurance baseline. */
+  /** Retryable scope this run could not settle; carried to the next run. */
+  readonly unreviewedPaths?: ReadonlyArray<string> | undefined;
+  /** Unchanged unresolved items carried from the prior reviewed baseline. */
   readonly carriedFindings?: ReadonlyArray<ReviewFinding> | undefined;
   readonly carriedConcerns?: ReadonlyArray<ReviewConcern> | undefined;
   /** Selected review scope, made visible whenever orchestration chose it. */
@@ -875,141 +1049,6 @@ declare const gitHubPriorReviewsLayer: Layer.Layer<PriorReviews, never, GitHubRe
  */
 declare const fingerprintUnchanged: (current: string) => Effect.Effect<boolean, never, PriorReviews>;
 //#endregion
-//#region src/internal/review-units.d.ts
-/** The delegation fan-out bound: one parent Run spawns at most this many children. */
-declare const MAX_REVIEW_UNITS = 8;
-/** A unit never carries more files than this, regardless of their size. */
-declare const MAX_UNIT_FILES = 12;
-/** Compatibility export; complete evidence chars now own unit packing. */
-declare const UNIT_CHANGED_LINE_BUDGET = 800;
-/**
- * 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.
- */
-declare const UNIT_EVIDENCE_CHAR_BUDGET = 240000;
-/** Maximum complete evidence shards placed in one child brief. */
-declare 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.
- */
-declare const MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS: number;
-/** @deprecated Use `MAX_PATCH_CHARS`; this is now the per-shard bound. */
-declare const MAX_FILE_EVIDENCE_CHARS = 60000;
-/** The merged review never exceeds the `CodeReview` findings bound. */
-declare const MAX_MERGED_FINDINGS = 20;
-declare const ReviewUnitId: Schema.NonEmptyString;
-/** High-risk surfaces that receive an explicit specialist focus label. */
-declare const ReviewRiskCategory: Schema.Literals<readonly ["authentication-authorization", "security-boundary", "persistence-durability", "concurrency", "credential-handling", "external-side-effects"]>;
-type ReviewRiskCategory = typeof ReviewRiskCategory.Type;
-declare const ReviewDiscoveryPerspective: Schema.Literals<readonly ["general", "risk-specialist"]>;
-type ReviewDiscoveryPerspective = typeof ReviewDiscoveryPerspective.Type;
-declare const ReviewPassId: Schema.NonEmptyString;
-declare const ReviewEvidenceShardId: Schema.NonEmptyString;
-declare const ReviewEvidenceShard_base: Schema.Class<ReviewEvidenceShard, Schema.Struct<{
-  readonly shardId: Schema.NonEmptyString;
-  readonly path: Schema.NonEmptyString;
-  readonly ordinal: Schema.Int;
-  readonly total: Schema.Int;
-  readonly evidenceChars: Schema.Int;
-}>, {}>;
-/** One complete bounded slice of a changed path's model-visible evidence. */
-declare class ReviewEvidenceShard extends ReviewEvidenceShard_base {}
-declare const ReviewDiscoveryPass_base: Schema.Class<ReviewDiscoveryPass, Schema.Struct<{
-  readonly passId: Schema.NonEmptyString;
-  readonly unitId: Schema.NonEmptyString;
-  readonly paths: Schema.$Array<Schema.NonEmptyString>;
-  readonly evidenceShardIds: Schema.$Array<Schema.NonEmptyString>;
-  readonly perspective: Schema.Literals<readonly ["general", "risk-specialist"]>;
-  /** Empty for the general pass; explicit deterministic focus for specialists. */
-  readonly riskCategories: Schema.$Array<Schema.Literals<readonly ["authentication-authorization", "security-boundary", "persistence-durability", "concurrency", "credential-handling", "external-side-effects"]>>;
-}>, {}>;
-/** One required, independently scoped discovery attempt. */
-declare class ReviewDiscoveryPass extends ReviewDiscoveryPass_base {}
-declare const ReviewUnit_base: Schema.Class<ReviewUnit, Schema.Struct<{
-  readonly unitId: Schema.NonEmptyString;
-  readonly paths: Schema.$Array<Schema.NonEmptyString>;
-  readonly evidenceShards: Schema.$Array<typeof ReviewEvidenceShard>;
-  /** additions + deletions across the unit's files, for honest sizing. */
-  readonly changedLines: Schema.Int;
-  /** Complete model-visible diff/content evidence assigned to each child. */
-  readonly evidenceChars: Schema.Int;
-  /** Host-classified focus labels for the unit's redundant specialist pass. */
-  readonly riskCategories: Schema.$Array<Schema.Literals<readonly ["authentication-authorization", "security-boundary", "persistence-durability", "concurrency", "credential-handling", "external-side-effects"]>>;
-}>, {}>;
-/** One bounded slice of the changeset delegated to one child reviewer. */
-declare class ReviewUnit extends ReviewUnit_base {}
-declare const ReviewUnitPlan_base: Schema.Class<ReviewUnitPlan, Schema.Struct<{
-  readonly totalFiles: Schema.Int;
-  /** True when the source returned fewer files than the pull request has. */
-  readonly truncated: Schema.Boolean;
-  readonly units: Schema.$Array<typeof ReviewUnit>;
-  /** Exact discovery calls the coordinator must make. */
-  readonly discoveryPasses: Schema.$Array<typeof ReviewDiscoveryPass>;
-  /** Changed files with neither a textual diff nor bounded base/head text. */
-  readonly undiffablePaths: Schema.$Array<Schema.NonEmptyString>;
-  /** Assigned paths with one or more evidence shards beyond plan capacity. */
-  readonly partialEvidencePaths: Schema.$Array<Schema.NonEmptyString>;
-  /** Exact number of shards beyond the bounded unit capacity. */
-  readonly unassignedEvidenceShardCount: Schema.Int;
-  /** Bounded deterministic prefix of the unassigned shard identifiers. */
-  readonly unassignedEvidenceShardIds: Schema.$Array<Schema.NonEmptyString>;
-  /**
-   * Diffable files beyond the fan-out capacity (MAX_REVIEW_UNITS units of
-   * MAX_UNIT_FILES files). Never silently dropped: the coordinator must name
-   * them as unreviewed in its summary.
-   */
-  readonly unassignedPaths: Schema.$Array<Schema.NonEmptyString>;
-}>, {}>;
-/** The complete deterministic fan-out plan over one changeset. */
-declare class ReviewUnitPlan extends ReviewUnitPlan_base {}
-/**
- * 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.
- */
-declare const classifyReviewRisks: (file: ChangedFile) => ReadonlyArray<ReviewRiskCategory>;
-/**
- * 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.
- */
-declare const findingAnchorInUnitEvidence: (finding: ReviewFinding, unit: ReviewUnit, files: ReadonlyArray<ChangedFile>) => boolean;
-/**
- * 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 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;
- * - 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.
- */
-declare const planReviewUnits: (files: ReadonlyArray<ChangedFile>, options: {
-  readonly totalChangedFiles: number;
-}) => ReviewUnitPlan;
-/**
- * Merge the children's findings into one bounded, deterministic list: dedupe
- * findings sharing an anchor (path + line range) keeping the most severe —
- * and, at equal severity, the first in declaration order — then rank by
- * severity, path, and line, and cap at the `CodeReview` findings bound.
- * This is the merge policy the coordinator's instructions state in prose;
- * pinning it here keeps the policy itself deterministic and testable.
- */
-declare const rankAndDedupeFindings: (findings: ReadonlyArray<ReviewFinding>) => ReadonlyArray<ReviewFinding>;
-//#endregion
 //#region src/internal/fan-out.d.ts
 /** One discovery pass returns at most this many anchored candidates. */
 declare const MAX_CHILD_FINDINGS = 6;
@@ -1017,8 +1056,14 @@ declare const MAX_CHILD_FINDINGS = 6;
 declare const MAX_CHILD_CONCERNS = 3;
 /** Every unit receives independent general and specialist discovery passes. */
 declare const MAX_UNIT_CANDIDATES: number;
-/** General + specialist discovery for every unit, then one verifier per unit. */
+/**
+ * General + specialist discovery for every unit, then one verifier per unit.
+ * The one-retry budget doubles the worst-case child Run count, but the
+ * schedule itself never exceeds this bound.
+ */
 declare const MAX_REVIEW_CHILDREN: number;
+/** Bounded structured concurrency across units; passes inside a unit are sequential. */
+declare const REVIEW_UNIT_CONCURRENCY = 4;
 /** Structural minimum for a child that exposes no tools. */
 declare const MAX_FILE_REVIEW_TOOL_CALLS = 1;
 declare const ReviewWorkPhase: Schema.Literals<readonly ["discovery", "verification"]>;
@@ -1049,9 +1094,29 @@ declare const reviewCandidateSubjectKey: (candidate: ReviewCandidate) => string;
 declare const CandidateAssessment_base: Schema.Class<CandidateAssessment, Schema.Struct<{
   readonly candidateId: Schema.NonEmptyString;
   readonly disposition: Schema.Literals<readonly ["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.
+   */
+  readonly suggestion: Schema.optionalKey<Schema.Literals<readonly ["committable", "not-committable"]>>;
   readonly rationale: Schema.NonEmptyString;
 }>, {}>;
 declare class CandidateAssessment extends CandidateAssessment_base {}
+/**
+ * Exact suggestion settlement shape: a carried suggestion must be settled and
+ * nothing else may be. A verification report that violates it is treated as a
+ * misbehaving pass and retried within the pass budget.
+ */
+declare const assessmentSettlesSuggestionExactly: (assessment: CandidateAssessment, candidate: ReviewCandidate) => boolean;
+/**
+ * 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.
+ */
+declare const confirmedFindingForPublication: (assessment: CandidateAssessment, candidate: FindingCandidate) => ReviewFinding;
 declare const DiscoveredConcern_base: Schema.Class<DiscoveredConcern, Schema.Struct<{
   readonly concern: typeof ReviewConcern;
   readonly evidencePaths: Schema.$Array<Schema.NonEmptyString>;
@@ -1063,19 +1128,6 @@ declare const DiscoveredConcern_base: Schema.Class<DiscoveredConcern, Schema.Str
  * remains path-free after the host confirms and projects it.
  */
 declare class DiscoveredConcern extends DiscoveredConcern_base {}
-declare const FileReviewRequest_base: Schema.Class<FileReviewRequest, Schema.Struct<{
-  readonly phase: Schema.Literals<readonly ["discovery", "verification"]>;
-  readonly workId: Schema.NonEmptyString;
-  readonly unitId: Schema.NonEmptyString;
-  readonly paths: Schema.$Array<Schema.NonEmptyString>;
-  readonly evidenceShardIds: Schema.$Array<Schema.NonEmptyString>;
-  readonly perspective: Schema.Literals<readonly ["general", "risk-specialist", "candidate-verification"]>;
-  readonly riskCategories: Schema.$Array<Schema.Literals<readonly ["authentication-authorization", "security-boundary", "persistence-durability", "concurrency", "credential-handling", "external-side-effects"]>>;
-  /** Empty for discovery; the exact discovered set for unit verification. */
-  readonly candidates: Schema.$Array<Schema.Union<readonly [typeof FindingCandidate, typeof ConcernCandidate]>>;
-}>, {}>;
-/** Strict-object coordinator request for either discovery or verification. */
-declare class FileReviewRequest extends FileReviewRequest_base {}
 declare const FileReviewEvidence_base: Schema.Class<FileReviewEvidence, Schema.Struct<{
   readonly shardId: Schema.NonEmptyString;
   readonly path: Schema.NonEmptyString;
@@ -1095,6 +1147,7 @@ declare const FileReviewBrief_base: Schema.Class<FileReviewBrief, Schema.Struct<
   readonly evidenceShardIds: Schema.$Array<Schema.NonEmptyString>;
   readonly perspective: Schema.Literals<readonly ["general", "risk-specialist", "candidate-verification"]>;
   readonly riskCategories: Schema.$Array<Schema.Literals<readonly ["authentication-authorization", "security-boundary", "persistence-durability", "concurrency", "credential-handling", "external-side-effects"]>>;
+  /** Empty for discovery; the exact discovered set for unit verification. */
   readonly candidates: Schema.$Array<Schema.Union<readonly [typeof FindingCandidate, typeof ConcernCandidate]>>;
   readonly evidence: Schema.$Array<typeof FileReviewEvidence>;
 }>, {}>;
@@ -1111,27 +1164,17 @@ declare const FileReviewReport_base: Schema.Class<FileReviewReport, Schema.Struc
 }>, {}>;
 /** Child output; phase-inapplicable collections must be empty. */
 declare class FileReviewReport extends FileReviewReport_base {}
-declare const FileReviewUnitResult_base: Schema.Class<FileReviewUnitResult, Schema.Struct<{
-  readonly phase: Schema.Literals<readonly ["discovery", "verification"]>;
-  readonly workId: Schema.NonEmptyString;
-  readonly unitId: Schema.NonEmptyString;
-  readonly candidates: Schema.$Array<Schema.Union<readonly [typeof FindingCandidate, typeof ConcernCandidate]>>;
-  readonly fileSummaries: Schema.$Array<typeof WalkthroughEntry>;
-  readonly assessments: Schema.$Array<typeof CandidateAssessment>;
-}>, {}>;
-/** Bounded coordinator-visible result with host-assigned candidate IDs. */
-declare class FileReviewUnitResult extends FileReviewUnitResult_base {}
-declare const FileReviewUnitFailed_base: Schema.Class<FileReviewUnitFailed, Schema.TaggedStruct<"FileReviewUnitFailed", {
-  readonly childErrorTag: Schema.NonEmptyString;
-  readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-declare class FileReviewUnitFailed extends FileReviewUnitFailed_base {}
-declare const FileReviewWorkRejected_base: Schema.Class<FileReviewWorkRejected, Schema.TaggedStruct<"FileReviewWorkRejected", {
+declare const ReviewPassMisbehaved_base: Schema.Class<ReviewPassMisbehaved, Schema.TaggedStruct<"ReviewPassMisbehaved", {
   readonly workId: Schema.NonEmptyString;
   readonly reason: Schema.NonEmptyString;
 }>, import("effect/Cause").YieldableError>;
-declare class FileReviewWorkRejected extends FileReviewWorkRejected_base {}
-declare const FileReviewFailure: Schema.Union<readonly [typeof FileReviewUnitFailed, typeof FileReviewWorkRejected]>;
+/**
+ * A structurally valid child report that does not answer the scheduled pass:
+ * wrong identity, phase-inapplicable fields, or an inexact assessment set.
+ * Retried once like any other pass fault, because it is model misbehavior,
+ * not evidence about the code under review.
+ */
+declare class ReviewPassMisbehaved extends ReviewPassMisbehaved_base {}
 interface FanOutInstructionOptions {
   readonly guidance?: string | ReadonlyArray<string> | undefined;
 }
@@ -1139,110 +1182,42 @@ interface FanOutInstructionOptions {
 declare const makeFileReviewerInstructions: (options?: FanOutInstructionOptions) => (brief: FileReviewBrief) => string;
 declare const fileReviewerInstructions: (brief: FileReviewBrief) => string;
 declare const FileReviewToolkit: Toolkit.Toolkit<{}>;
-/** Compatibility export: the evidence-only child has no handler requirements. */
-declare const FileReviewToolkitLayer: Layer.Layer<never, never, never>;
 declare const defaultFileReviewerPolicy: AgentPolicy;
-declare const fileReviewPolicy: SubagentPolicy;
-declare const mapFileReviewChildFailure: (failure: {
-  readonly _tag: string;
-  readonly message?: string;
-}) => FileReviewUnitFailed;
-declare const makeFileReviewDelegation: (child: ReturnType<typeof makeFileReviewerDefinition>) => import("effect-agent").SubagentDelegation<"delegate_file_review", typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, {}, typeof FileReviewRequest, typeof FileReviewUnitResult, Schema.Union<readonly [typeof FileReviewUnitFailed, typeof FileReviewWorkRejected]>, PullRequestSource, PullRequestSource, "return">;
-declare const ListReviewUnitsQuery_base: Schema.Class<ListReviewUnitsQuery, Schema.Struct<{
-  readonly scope: Schema.Literal<"all">;
-}>, {}>;
-declare class ListReviewUnitsQuery extends ListReviewUnitsQuery_base {}
-declare const ListReviewUnits: Tool.Tool<"list_review_units", {
-  readonly parameters: typeof ListReviewUnitsQuery;
-  readonly success: typeof ReviewUnitPlan;
-  readonly failure: typeof PullRequestSourceFailure;
-  readonly failureMode: "error";
-}, PullRequestSource>;
-declare const FanOutCoordinatorToolkit: Toolkit.Toolkit<{
-  readonly list_review_units: Tool.Tool<"list_review_units", {
-    readonly parameters: typeof ListReviewUnitsQuery;
-    readonly success: typeof ReviewUnitPlan;
-    readonly failure: typeof PullRequestSourceFailure;
-    readonly failureMode: "error";
-  }, PullRequestSource>;
-}>;
-declare const FanOutCoordinatorToolkitLayer: Layer.Layer<Tool.Handler<"list_review_units">, never, never>;
-declare const makeFanOutReviewInstructions: (options?: FanOutInstructionOptions & {
-  readonly maxFindings?: number | undefined;
-}) => (mission: ReviewMission) => string;
-declare const fanOutReviewInstructions: (mission: ReviewMission) => string;
-declare const defaultFanOutPolicy: AgentPolicy;
-interface FanOutReviewSuite {
-  readonly child: ReturnType<typeof makeFileReviewerDefinition>;
-  readonly parent: ReturnType<typeof makeFanOutReviewerDefinition>;
-  readonly delegation: ReturnType<typeof makeFileReviewDelegation>;
-}
 declare const makeFileReviewerDefinition: (options?: FanOutInstructionOptions) => import("effect-agent").Definition<typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, Toolkit.Toolkit<{}>, undefined>;
-declare const makeFanOutReviewerDefinition: (options: FanOutInstructionOptions & {
-  readonly maxFindings?: number | undefined;
-}, delegation: ReturnType<typeof makeFileReviewDelegation>) => import("effect-agent").Definition<typeof ReviewMission, typeof CodeReview, (mission: ReviewMission) => string, Toolkit.Toolkit<{
-  readonly delegate_file_review: Tool.Tool<"delegate_file_review", {
-    readonly parameters: typeof FileReviewRequest;
-    readonly success: Schema.Union<readonly [typeof FileReviewUnitResult, import("effect-agent").SubagentContainedFailure<Schema.Union<readonly [typeof FileReviewUnitFailed, typeof FileReviewWorkRejected]>>]>;
-    readonly failure: import("effect-agent").SubagentReturnModeFailure;
-    readonly failureMode: "error";
-  }, import("effect-agent").AgentSpawner | import("effect-agent").IdGenerator | import("effect-agent").RunEventSink | import("effect-agent").SubagentDurability>;
-  readonly list_review_units: Tool.Tool<"list_review_units", {
-    readonly parameters: typeof ListReviewUnitsQuery;
-    readonly success: typeof ReviewUnitPlan;
-    readonly failure: typeof PullRequestSourceFailure;
-    readonly failureMode: "error";
-  }, PullRequestSource>;
-}>, undefined>;
-interface FanOutSuiteOptions extends FanOutInstructionOptions {
+declare const FileReviewer: import("effect-agent").Definition<typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, Toolkit.Toolkit<{}>, undefined>;
+/** The exact child binding shape the host pipeline schedules. */
+type FileReviewerBinding<Provider, ModelProvides, ModelRequires> = RuntimeBinding<typeof FileReviewBrief, typeof FileReviewReport, ReturnType<typeof makeFileReviewerInstructions>, Toolkit.Tools<typeof FileReviewToolkit>, Provider, ModelProvides, ModelRequires>;
+/** Everything one settled fan-out pipeline run produced, before publication. */
+interface FanOutPipelineOutcome {
+  readonly review: CodeReview;
+  readonly assurance: ReviewAssurance;
+  readonly plan: ReviewUnitPlan;
+  /** Paths of units with an unsettled pass — retryable scope for the next run. */
+  readonly unreviewedPaths: ReadonlyArray<string>;
+  /** Total settled child turns across every scheduled pass. */
+  readonly turns: number;
+}
+interface FanOutPipelineInput {
+  readonly files: ReadonlyArray<ChangedFile>;
+  readonly anchorFiles: ReadonlyArray<ChangedFile>;
+  readonly totalChangedFiles: number;
   readonly maxFindings?: number | undefined;
+  /** Shared run budget observed by every child pass. */
+  readonly budget?: RunBudgetHook<BudgetExceeded | BudgetAdapterError> | undefined;
 }
-declare const makeFanOutReviewSuite: (options?: FanOutSuiteOptions) => FanOutReviewSuite;
-declare const FileReviewer: import("effect-agent").Definition<typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, Toolkit.Toolkit<{}>, undefined>;
-declare const FanOutReviewer: import("effect-agent").Definition<typeof ReviewMission, typeof CodeReview, (mission: ReviewMission) => string, Toolkit.Toolkit<{
-  readonly delegate_file_review: Tool.Tool<"delegate_file_review", {
-    readonly parameters: typeof FileReviewRequest;
-    readonly success: Schema.Union<readonly [typeof FileReviewUnitResult, import("effect-agent").SubagentContainedFailure<Schema.Union<readonly [typeof FileReviewUnitFailed, typeof FileReviewWorkRejected]>>]>;
-    readonly failure: import("effect-agent").SubagentReturnModeFailure;
-    readonly failureMode: "error";
-  }, import("effect-agent").AgentSpawner | import("effect-agent").IdGenerator | import("effect-agent").RunEventSink | import("effect-agent").SubagentDurability>;
-  readonly list_review_units: Tool.Tool<"list_review_units", {
-    readonly parameters: typeof ListReviewUnitsQuery;
-    readonly success: typeof ReviewUnitPlan;
-    readonly failure: typeof PullRequestSourceFailure;
-    readonly failureMode: "error";
-  }, PullRequestSource>;
-}>, undefined>;
-declare const fileReviewDelegation: import("effect-agent").SubagentDelegation<"delegate_file_review", typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, {}, typeof FileReviewRequest, typeof FileReviewUnitResult, Schema.Union<readonly [typeof FileReviewUnitFailed, typeof FileReviewWorkRejected]>, PullRequestSource, PullRequestSource, "return">;
-declare const DelegateFileReview: Tool.Tool<"delegate_file_review", {
-  readonly parameters: typeof FileReviewRequest;
-  readonly success: Schema.Union<readonly [typeof FileReviewUnitResult, import("effect-agent").SubagentContainedFailure<Schema.Union<readonly [typeof FileReviewUnitFailed, typeof FileReviewWorkRejected]>>]>;
-  readonly failure: import("effect-agent").SubagentReturnModeFailure;
-  readonly failureMode: "error";
-}, import("effect-agent").AgentSpawner | import("effect-agent").IdGenerator | import("effect-agent").RunEventSink | import("effect-agent").SubagentDurability>;
-declare const FanOutReviewToolkit: Toolkit.Toolkit<{
-  readonly delegate_file_review: Tool.Tool<"delegate_file_review", {
-    readonly parameters: typeof FileReviewRequest;
-    readonly success: Schema.Union<readonly [typeof FileReviewUnitResult, import("effect-agent").SubagentContainedFailure<Schema.Union<readonly [typeof FileReviewUnitFailed, typeof FileReviewWorkRejected]>>]>;
-    readonly failure: import("effect-agent").SubagentReturnModeFailure;
-    readonly failureMode: "error";
-  }, import("effect-agent").AgentSpawner | import("effect-agent").IdGenerator | import("effect-agent").RunEventSink | import("effect-agent").SubagentDurability>;
-  readonly list_review_units: Tool.Tool<"list_review_units", {
-    readonly parameters: typeof ListReviewUnitsQuery;
-    readonly success: typeof ReviewUnitPlan;
-    readonly failure: typeof PullRequestSourceFailure;
-    readonly failureMode: "error";
-  }, PullRequestSource>;
-}>;
-declare const FileReviewDelegationFailure: import("effect-agent").SubagentContainedFailure<Schema.Union<readonly [typeof FileReviewUnitFailed, typeof FileReviewWorkRejected]>>;
-declare const fanOutHandlersLayerFor: (delegation: ReturnType<typeof makeFileReviewDelegation>) => <Provider, ModelProvides, ModelRequires>(childBinding: RuntimeBinding<typeof FileReviewBrief, typeof FileReviewReport, ReturnType<typeof makeFileReviewerInstructions>, Toolkit.Tools<typeof FileReviewToolkit>, Provider, ModelProvides, ModelRequires>) => Layer.Layer<Tool.Handler<"delegate_file_review">, never, import("effect-agent").SubagentLayerRequirements<typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, {}, Provider, ModelProvides, ModelRequires, PullRequestSource, PullRequestSource, never, {
-  readonly _tag: string;
-  readonly message?: string;
-}, never>>;
-declare const fanOutHandlersLayer: <Provider, ModelProvides, ModelRequires>(childBinding: RuntimeBinding<typeof FileReviewBrief, typeof FileReviewReport, ReturnType<typeof makeFileReviewerInstructions>, Toolkit.Tools<typeof FileReviewToolkit>, Provider, ModelProvides, ModelRequires>) => Layer.Layer<Tool.Handler<"delegate_file_review">, never, import("effect-agent").SubagentLayerRequirements<typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, {}, Provider, ModelProvides, ModelRequires, PullRequestSource, PullRequestSource, never, {
-  readonly _tag: string;
-  readonly message?: string;
-}, never>>;
+/**
+ * Run the complete host-scheduled fan-out pipeline over one selected
+ * changeset snapshot: plan, independent discovery, exact verification, and a
+ * deterministic host-composed CodeReview from verifier-confirmed candidates
+ * only. The verdict is derived from confirmed severities, never model prose.
+ */
+declare const runFanOutReview: <Provider, ModelProvides, ModelRequires>(binding: FileReviewerBinding<Provider, ModelProvides, ModelRequires>, input: FanOutPipelineInput) => Effect.Effect<{
+  review: CodeReview;
+  assurance: ReviewAssurance;
+  plan: ReviewUnitPlan;
+  unreviewedPaths: string[];
+  turns: number;
+}, never, import("effect-agent").IdGenerator | Exclude<Exclude<ModelRequires, import("effect-agent").EngineProvidedToolServices>, import("effect/Scope").Scope>>;
 //#endregion
-export { MAX_UNIT_EVIDENCE_SHARDS as $, ReviewInstructionOptions as $n, ReviewSelection as $t, MAX_REVIEW_CHILDREN as A, ChangedFilesView as An, isReviewableFile as Ar, RetirableReviewComment as At, fanOutReviewInstructions as B, ListChangedFilesQuery as Bn, ReviewCommentDraft as Bt, FileReviewer as C, ReviewPipelineAssessment as Cn, ChangedFileStatus as Cr, fingerprintUnchanged as Ct, MAX_CHILD_CONCERNS as D, collectUnitFileSummaries as Dn, annotatePatch as Dr, gitHubReviewRetirementHostLayer as Dt, ListReviewUnitsQuery as E, assessReviewPipeline as En, PatchLine as Er, gitHubReviewPublisherLayer as Et, ReviewWorkPhase as F, FileSlice as Fn, ReviewRetirementReport as Ft, makeFanOutReviewSuite as G, MAX_WALKTHROUGH_SUMMARY_CHARS as Gn, planWalkthrough as Gt, fileReviewPolicy as H, MAX_FINDINGS as Hn, ReviewPublicationPlan as Ht, defaultFanOutPolicy as I, FileSliceQuery as In, decideReviewRetirement as It, reviewCandidateSubjectKey as J, ReadFile as Jn, MAX_REVIEW_STATE_MARKER_CHARS as Jt, makeFileReviewerInstructions as K, PullRequestReviewer as Kn, renderAgentPrompt as Kt, defaultFileReviewerPolicy as L, FindingCategory as Ln, hasReviewMetadataMarker as Lt, ReviewCandidate as M, FileDiffQuery as Mn, renderReviewContent as Mr, ReviewRetirementFailure as Mt, ReviewCandidateId as N, FileDiffView as Nn, ReviewRetirementHost as Nt, MAX_CHILD_FINDINGS as O, anchorViolation as On, commentableLines as Or, parseGitHubSubmittedAt as Ot, ReviewWorkPerspective as P, FileReviewEvidenceChunk as Pn, ReviewRetirementInput as Pt, MAX_REVIEW_UNITS as Q, ReviewGuidance as Qn, ReviewScopeMode as Qt, fanOutHandlersLayer as R, FindingSeverity as Rn, retireStaleReviews as Rt, FileReviewWorkRejected as S, ReviewInputCoverage as Sn, ChangedFile as Sr, ReviewPublisher as St, ListReviewUnits as T, assessReviewCoverage as Tn, MAX_REVIEW_CONTENT_CHARS as Tr, gitHubPullRequestSourceLayer as Tt, fileReviewerInstructions as U, MAX_PATCH_CHARS as Un, estimateReviewEffort as Ut, fileReviewDelegation as V, MAX_CONCERNS as Vn, ReviewEvent as Vt, makeFanOutReviewInstructions as W, MAX_WALKTHROUGH_ENTRIES as Wn, planPublication as Wt, MAX_MERGED_FINDINGS as X, ReviewConcern as Xn, ReviewHeadComparison as Xt, MAX_FILE_EVIDENCE_CHARS as Y, ReadFileDiff as Yn, ReviewExecutionContext as Yt, MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS as Z, ReviewFinding as Zn, ReviewMode as Zt, FileReviewRequest as _, webCryptoReviewStateAuthenticatorLayer as _n, PullRequestMetadata as _r, GitHubApiFailure as _t, FanOutCoordinatorToolkit as a, StoredReviewConcern as an, clampMaxFindings as ar, ReviewPassId as at, FileReviewUnitFailed as b, ReviewAssurance as bn, ReviewInputViolation as br, PriorReviews as bt, FanOutReviewSuite as c, computeProfileFingerprint as cn, fileReviewEvidenceChunks as cr, ReviewUnitId as ct, FanOutSuiteOptions as d, selectReviewRange as dn, readFileDiffHandler as dr, UNIT_EVIDENCE_CHAR_BUDGET as dt, ReviewState as en, ReviewMission as er, MAX_UNIT_FILES as et, FileReviewBrief as f, selectedPullRequestSourceLayer as fn, readFileHandler as fr, classifyReviewRisks as ft, FileReviewReport as g, validateReviewState as gn, MAX_FILE_CHARS as gr, DEFAULT_GITHUB_REVIEW_AUTHOR_LOGIN as gt, FileReviewFailure as h, unavailableReviewStateAuthenticatorLayer as hn, MAX_CHANGED_FILES as hr, rankAndDedupeFindings as ht, DiscoveredConcern as i, ReviewStateMarkerTooLarge as in, WalkthroughEntry as ir, ReviewEvidenceShardId as it, MAX_UNIT_CANDIDATES as j, CodeReview as jn, parsePatch as jr, ReviewRetirementDecision as jt, MAX_FILE_REVIEW_TOOL_CALLS as k, ChangedFileSummary as kn, hasReviewableContent as kr, RetirableReview as kt, FanOutReviewToolkit as l, fromStoredConcern as ln, listChangedFilesHandler as lr, ReviewUnitPlan as lt, FileReviewEvidence as m, toStoredFinding as mn, reviewInstructions as mr, planReviewUnits as mt, ConcernCandidate as n, ReviewStateAuthenticator as nn, ReviewToolkitLayer as nr, ReviewDiscoveryPerspective as nt, FanOutCoordinatorToolkitLayer as o, StoredReviewFinding as on, defaultReviewPolicy as or, ReviewRiskCategory as ot, FileReviewDelegationFailure as p, toStoredConcern as pn, resolveGuidance as pr, findingAnchorInUnitEvidence as pt, mapFileReviewChildFailure as q, REVIEW_TOOL_RESULT_MAX_BYTES as qn, GitCommitSha as qt, DelegateFileReview as r, ReviewStateMarker as rn, ReviewVerdict as rr, ReviewEvidenceShard as rt, FanOutInstructionOptions as s, buildProfileMission as sn, fileDiffView as sr, ReviewUnit as st, CandidateAssessment as t, ReviewStateAuthenticationFailure as tn, ReviewToolkit as tr, ReviewDiscoveryPass as tt, FanOutReviewer as u, fromStoredFinding as un, makeReviewInstructions as ur, UNIT_CHANGED_LINE_BUDGET as ut, FileReviewToolkit as v, FailedReviewPass as vn, PullRequestSource as vr, GitHubReviewTarget as vt, FindingCandidate as w, ReviewShape as wn, ChangedPath as wr, gitHubPriorReviewsLayer as wt, FileReviewUnitResult as x, ReviewCoverage as xn, normalizeRepoRelativePath as xr, PublishedReview as xt, FileReviewToolkitLayer as y, FailedReviewUnit as yn, PullRequestSourceFailure as yr, PriorReviewLookupFailure as yt, fanOutHandlersLayerFor as z, ListChangedFiles as zn, AGENT_PROMPT_PREAMBLE as zt };
-//# sourceMappingURL=fan-out-D5xrmadQ.d.mts.map
+export { decideReviewRetirement as $, readFileHandler as $n, ReviewDiscoveryPass as $t, makeFileReviewerInstructions as A, MAX_PATCH_CHARS as An, selectedPullRequestSourceLayer as At, fingerprintUnchanged as B, ReviewInstructionOptions as Bn, ReviewCoverage as Bt, ReviewWorkPerspective as C, FileSliceQuery as Cn, StoredReviewConcern as Ct, defaultFileReviewerPolicy as D, ListChangedFilesQuery as Dn, fromStoredConcern as Dt, confirmedFindingForPublication as E, ListChangedFiles as En, computeProfileFingerprint as Et, GitHubReviewTarget as F, ReadFile as Fn, webCryptoReviewStateAuthenticatorLayer as Ft, parseGitHubSubmittedAt as G, WalkthroughEntry as Gn, fanOutInputCoverage as Gt, gitHubPullRequestSourceLayer as H, ReviewToolkit as Hn, assessFlatReview as Ht, PriorReviewLookupFailure as I, ReadFileDiff as In, FailedReviewPass as It, ReviewRetirementDecision as J, fileDiffView as Jn, MAX_MERGED_FINDINGS as Jt, RetirableReview as K, clampMaxFindings as Kn, flatAssurance as Kt, PriorReviews as L, ReviewConcern as Ln, FailedReviewUnit as Lt, runFanOutReview as M, MAX_WALKTHROUGH_SUMMARY_CHARS as Mn, toStoredFinding as Mt, DEFAULT_GITHUB_REVIEW_AUTHOR_LOGIN as N, PullRequestReviewer as Nn, unavailableReviewStateAuthenticatorLayer as Nt, fileReviewerInstructions as O, MAX_CONCERNS as On, fromStoredFinding as Ot, GitHubApiFailure as P, REVIEW_TOOL_RESULT_MAX_BYTES as Pn, validateReviewState as Pt, ReviewRetirementReport as Q, readFileDiffHandler as Qn, MAX_UNIT_FILES as Qt, PublishedReview as R, ReviewFinding as Rn, FlatReviewAssessment as Rt, ReviewPassMisbehaved as S, FileSlice as Sn, ReviewStateMarkerTooLarge as St, assessmentSettlesSuggestionExactly as T, FindingSeverity as Tn, buildProfileMission as Tt, gitHubReviewPublisherLayer as U, ReviewToolkitLayer as Un, boundedListReason as Ut, gitHubPriorReviewsLayer as V, ReviewMission as Vn, ReviewInputCoverage as Vt, gitHubReviewRetirementHostLayer as W, ReviewVerdict as Wn, compatibilityCoverage as Wt, ReviewRetirementHost as X, listChangedFilesHandler as Xn, MAX_REVIEW_UNITS as Xt, ReviewRetirementFailure as Y, fileReviewEvidenceChunks as Yn, MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS as Yt, ReviewRetirementInput as Z, makeReviewInstructions as Zn, MAX_UNIT_EVIDENCE_SHARDS as Zt, MAX_REVIEW_CHILDREN as _, ChangedFilesView as _n, isReviewableFile as _r, ReviewSelection as _t, FanOutPipelineInput as a, ReviewUnit as an, PullRequestSource as ar, ReviewPublicationPlan as at, ReviewCandidate as b, FileDiffView as bn, ReviewStateAuthenticator as bt, FileReviewEvidence as c, UNIT_CHANGED_LINE_BUDGET as cn, normalizeRepoRelativePath as cr, planWalkthrough as ct, FileReviewer as d, findingAnchorInUnitEvidence as dn, ChangedPath as dr, MAX_REVIEW_STATE_MARKER_CHARS as dt, ReviewDiscoveryPerspective as en, resolveGuidance as er, hasReviewMetadataMarker as et, FileReviewerBinding as f, planReviewUnits as fn, MAX_REVIEW_CONTENT_CHARS as fr, MAX_STORED_UNREVIEWED_PATHS as ft, MAX_FILE_REVIEW_TOOL_CALLS as g, ChangedFileSummary as gn, hasReviewableContent as gr, ReviewScopeMode as gt, MAX_CHILD_FINDINGS as h, anchorViolation as hn, commentableLines as hr, ReviewMode as ht, FanOutInstructionOptions as i, ReviewRiskCategory as in, PullRequestMetadata as ir, ReviewEvent as it, reviewCandidateSubjectKey as j, MAX_WALKTHROUGH_ENTRIES as jn, toStoredConcern as jt, makeFileReviewerDefinition as k, MAX_FINDINGS as kn, selectReviewRange as kt, FileReviewReport as l, UNIT_EVIDENCE_CHAR_BUDGET as ln, ChangedFile as lr, renderAgentPrompt as lt, MAX_CHILD_CONCERNS as m, rankAndDedupeFindings as mn, annotatePatch as mr, ReviewHeadComparison as mt, ConcernCandidate as n, ReviewEvidenceShardId as nn, MAX_CHANGED_FILES as nr, AGENT_PROMPT_PREAMBLE as nt, FanOutPipelineOutcome as o, ReviewUnitId as on, PullRequestSourceFailure as or, estimateReviewEffort as ot, FindingCandidate as p, rankAndDedupeConcerns as pn, PatchLine as pr, ReviewExecutionContext as pt, RetirableReviewComment as q, defaultReviewPolicy as qn, MAX_FILE_EVIDENCE_CHARS as qt, DiscoveredConcern as r, ReviewPassId as rn, MAX_FILE_CHARS as rr, ReviewCommentDraft as rt, FileReviewBrief as s, ReviewUnitPlan as sn, ReviewInputViolation as sr, planPublication as st, CandidateAssessment as t, ReviewEvidenceShard as tn, reviewInstructions as tr, retireStaleReviews as tt, FileReviewToolkit as u, classifyReviewRisks as un, ChangedFileStatus as ur, GitCommitSha as ut, MAX_UNIT_CANDIDATES as v, CodeReview as vn, parsePatch as vr, ReviewState as vt, ReviewWorkPhase as w, FindingCategory as wn, StoredReviewFinding as wt, ReviewCandidateId as x, FileReviewEvidenceChunk as xn, ReviewStateMarker as xt, REVIEW_UNIT_CONCURRENCY as y, FileDiffQuery as yn, renderReviewContent as yr, ReviewStateAuthenticationFailure as yt, ReviewPublisher as z, ReviewGuidance as zn, ReviewAssurance as zt };
+//# sourceMappingURL=fan-out-BJBTAYuh.d.mts.map