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

package/dist/{fan-out-n-00ppWr.d.mts → fan-out-Bi1v0VaU.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,21 @@ 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;
+/** Failed-pass records stored beside the leftover paths; one per unit stage. */
+declare const MAX_STORED_UNREVIEWED_PASSES = 24;
+/** Stages a leftover path may need retried without a second general discovery. */
+declare const UnreviewedStage: Schema.Literals<readonly ["discovery", "specialist", "verification"]>;
+type UnreviewedStage = typeof UnreviewedStage.Type;
+declare const StoredUnreviewedPass_base: Schema.Class<StoredUnreviewedPass, Schema.Struct<{
+  readonly stage: Schema.Literals<readonly ["discovery", "specialist", "verification"]>;
+  readonly paths: Schema.$Array<Schema.NonEmptyString>;
+}>, {}>;
+/** One failed fan-out pass whose paths should be retried, not rediscovered. */
+declare class StoredUnreviewedPass extends StoredUnreviewedPass_base {}
 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 +681,32 @@ 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>;
+  /**
+   * Which failed pass produced those leftovers. Absent on state-v2 markers
+   * written before this field existed; those leftovers still re-enter scope
+   * but cannot skip rediscovery. Present (including empty) on new markers.
+   */
+  readonly unreviewedPasses: Schema.optionalKey<Schema.$Array<typeof StoredUnreviewedPass>>;
+  /**
+   * 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;
@@ -562,6 +755,12 @@ interface ReviewSelection {
   readonly files: ReadonlyArray<ChangedFile>;
   /** Paths whose changes invalidate prior findings, including paths reverted out of the PR. */
   readonly affectedPaths: ReadonlyArray<string>;
+  /**
+   * Leftover paths whose contents did not change. Fan-out retries only the
+   * recorded failed stages on these paths and keeps their stored findings.
+   */
+  readonly retryPaths: ReadonlyArray<string>;
+  readonly retryStages: ReadonlyArray<UnreviewedStage>;
   readonly totalFiles: number;
   readonly baselineSha: string | undefined;
   readonly priorState: ReviewState | undefined;
@@ -569,6 +768,8 @@ interface ReviewSelection {
   /** Action-owned authentication capability, constructed at the composition root. */
   readonly stateAuthenticator?: ReviewStateAuthenticator["Service"] | undefined;
 }
+/** Three-dot lineage from the reviewed head to the current head is usable. */
+declare const isLineageAncestor: (comparison: ReviewHeadComparison, priorState: ReviewState, currentHeadSha: string) => boolean;
 /**
  * Validate that persisted state belongs to this exact PR/base lineage and the
  * same review profile. A mismatch is a full-review reason, never an error that
@@ -584,6 +785,12 @@ declare const selectReviewRange: (input: {
   readonly priorState: ReviewState | undefined;
   readonly comparison: ReviewHeadComparison | undefined;
   readonly baseComparison?: ReviewHeadComparison | undefined;
+  /**
+   * Two-dot tree comparison used when the reviewed head is not a git ancestor
+   * (rebase, amend, force-push). Intersected with the current PR path set so
+   * main-drift outside the pull request never re-enters scope.
+   */
+  readonly contentComparison?: ReviewHeadComparison | undefined;
   readonly lookupFailure?: string | undefined;
 }) => ReviewSelection;
 declare const ReviewExecutionContext_base: Context.ServiceClass<ReviewExecutionContext, "@effect-agent/pr-review/ReviewExecutionContext", ReviewSelection>;
@@ -595,8 +802,6 @@ declare class ReviewExecutionContext extends ReviewExecutionContext_base {}
  * the selected delta and may read head context only for that delta's paths.
  */
 declare const selectedPullRequestSourceLayer: (selection: ReviewSelection) => Layer.Layer<PullRequestSource, never, PullRequestSource>;
-/** Profile fingerprints are SHA-256 over configuration-only signatures. */
-declare const computeProfileFingerprint: (signature: string) => Effect.Effect<string>;
 /** Build the full-surface mission used only to resolve profile guidance. */
 declare const buildProfileMission: (metadata: PullRequestMetadata, files: ReadonlyArray<ChangedFile>) => ReviewMission;
 //#endregion
@@ -677,25 +882,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. */
@@ -860,6 +1063,12 @@ declare const PriorReviews_base: Context.ServiceClass<PriorReviews, "@effect-age
   readonly latestState: Effect.Effect<Option.Option<ReviewState>, PriorReviewLookupFailure, ReviewStateAuthenticator>;
   /** Compare a previously reviewed head to the live current head. */
   readonly compareHeads: (baseSha: string, headSha: string) => Effect.Effect<ReviewHeadComparison, PriorReviewLookupFailure>;
+  /**
+   * Two-dot tree comparison (`base..head`). Used when the reviewed head is
+   * not a git ancestor so a rebase or amend can still name the paths whose
+   * blob contents actually changed.
+   */
+  readonly compareTrees: (baseSha: string, headSha: string) => Effect.Effect<ReviewHeadComparison, PriorReviewLookupFailure>;
 }>;
 /**
  * Read-only view of this package's previously posted reviews on the target
@@ -875,141 +1084,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 +1091,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"]>;
@@ -1061,8 +1141,8 @@ declare const CandidateAssessment_base: Schema.Class<CandidateAssessment, Schema
 declare class CandidateAssessment extends CandidateAssessment_base {}
 /**
  * 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.
+ * 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;
 /**
@@ -1083,19 +1163,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;
@@ -1115,6 +1182,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>;
 }>, {}>;
@@ -1131,27 +1199,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;
 }
@@ -1159,110 +1217,59 @@ 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>;
+  /** Failed stages paired with the leftover paths they still own. */
+  readonly unreviewedPasses: ReadonlyArray<{
+    readonly stage: FailedReviewPass["stage"];
+    readonly paths: 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;
+  /**
+   * Unchanged leftover paths from a prior failed pass. Those units retry only
+   * the recorded stages — no second general discovery on files nobody touched.
+   */
+  readonly retry?: {
+    readonly paths: ReadonlyArray<string>;
+    readonly stages: ReadonlyArray<FailedReviewPass["stage"]>;
+  } | 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[];
+  unreviewedPasses: {
+    stage: "discovery" | "specialist" | "verification";
+    paths: readonly string[];
+  }[];
+  turns: number;
+}, never, import("effect-agent").IdGenerator | Exclude<Exclude<ModelRequires, import("effect-agent").EngineProvidedToolServices>, import("effect/Scope").Scope>>;
 //#endregion
-export { MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS as $, ReviewFinding as $n, ReviewMode as $t, MAX_REVIEW_CHILDREN as A, anchorViolation as An, commentableLines as Ar, parseGitHubSubmittedAt as At, fanOutHandlersLayer as B, FindingSeverity as Bn, retireStaleReviews as Bt, FileReviewer as C, ReviewCoverage as Cn, normalizeRepoRelativePath as Cr, PublishedReview as Ct, MAX_CHILD_CONCERNS as D, assessReviewCoverage as Dn, MAX_REVIEW_CONTENT_CHARS as Dr, gitHubPullRequestSourceLayer as Dt, ListReviewUnitsQuery as E, ReviewShape as En, ChangedPath as Er, gitHubPriorReviewsLayer as Et, ReviewWorkPhase as F, FileDiffView as Fn, ReviewRetirementHost as Ft, fileReviewerInstructions as G, MAX_PATCH_CHARS as Gn, estimateReviewEffort as Gt, fanOutReviewInstructions as H, ListChangedFilesQuery as Hn, ReviewCommentDraft as Ht, assessmentSettlesSuggestionExactly as I, FileReviewEvidenceChunk as In, ReviewRetirementInput as It, makeFileReviewerInstructions as J, PullRequestReviewer as Jn, renderAgentPrompt as Jt, makeFanOutReviewInstructions as K, MAX_WALKTHROUGH_ENTRIES as Kn, planPublication as Kt, confirmedFindingForPublication as L, FileSlice as Ln, ReviewRetirementReport as Lt, ReviewCandidate as M, ChangedFilesView as Mn, isReviewableFile as Mr, RetirableReviewComment as Mt, ReviewCandidateId as N, CodeReview as Nn, parsePatch as Nr, ReviewRetirementDecision as Nt, MAX_CHILD_FINDINGS as O, assessReviewPipeline as On, PatchLine as Or, gitHubReviewPublisherLayer as Ot, ReviewWorkPerspective as P, FileDiffQuery as Pn, renderReviewContent as Pr, ReviewRetirementFailure as Pt, MAX_MERGED_FINDINGS as Q, ReviewConcern as Qn, ReviewHeadComparison as Qt, defaultFanOutPolicy as R, FileSliceQuery as Rn, decideReviewRetirement as Rt, FileReviewWorkRejected as S, ReviewAssurance as Sn, ReviewInputViolation as Sr, PriorReviews as St, ListReviewUnits as T, ReviewPipelineAssessment as Tn, ChangedFileStatus as Tr, fingerprintUnchanged as Tt, fileReviewDelegation as U, MAX_CONCERNS as Un, ReviewEvent as Ut, fanOutHandlersLayerFor as V, ListChangedFiles as Vn, AGENT_PROMPT_PREAMBLE as Vt, fileReviewPolicy as W, MAX_FINDINGS as Wn, ReviewPublicationPlan as Wt, reviewCandidateSubjectKey as X, ReadFile as Xn, MAX_REVIEW_STATE_MARKER_CHARS as Xt, mapFileReviewChildFailure as Y, REVIEW_TOOL_RESULT_MAX_BYTES as Yn, GitCommitSha as Yt, MAX_FILE_EVIDENCE_CHARS as Z, ReadFileDiff as Zn, ReviewExecutionContext as Zt, FileReviewRequest as _, unavailableReviewStateAuthenticatorLayer as _n, MAX_CHANGED_FILES as _r, rankAndDedupeFindings as _t, FanOutCoordinatorToolkit as a, ReviewStateMarker as an, ReviewVerdict as ar, ReviewEvidenceShard as at, FileReviewUnitFailed as b, FailedReviewPass as bn, PullRequestSource as br, GitHubReviewTarget as bt, FanOutReviewSuite as c, StoredReviewFinding as cn, defaultReviewPolicy as cr, ReviewRiskCategory as ct, FanOutSuiteOptions as d, fromStoredConcern as dn, listChangedFilesHandler as dr, ReviewUnitPlan as dt, ReviewScopeMode as en, ReviewGuidance as er, MAX_REVIEW_UNITS as et, FileReviewBrief as f, fromStoredFinding as fn, makeReviewInstructions as fr, UNIT_CHANGED_LINE_BUDGET as ft, FileReviewReport as g, toStoredFinding as gn, reviewInstructions as gr, planReviewUnits as gt, FileReviewFailure as h, toStoredConcern as hn, resolveGuidance as hr, findingAnchorInUnitEvidence as ht, DiscoveredConcern as i, ReviewStateAuthenticator as in, ReviewToolkitLayer as ir, ReviewDiscoveryPerspective as it, MAX_UNIT_CANDIDATES as j, ChangedFileSummary as jn, hasReviewableContent as jr, RetirableReview as jt, MAX_FILE_REVIEW_TOOL_CALLS as k, collectUnitFileSummaries as kn, annotatePatch as kr, gitHubReviewRetirementHostLayer as kt, FanOutReviewToolkit as l, buildProfileMission as ln, fileDiffView as lr, ReviewUnit as lt, FileReviewEvidence as m, selectedPullRequestSourceLayer as mn, readFileHandler as mr, classifyReviewRisks as mt, ConcernCandidate as n, ReviewState as nn, ReviewMission as nr, MAX_UNIT_FILES as nt, FanOutCoordinatorToolkitLayer as o, ReviewStateMarkerTooLarge as on, WalkthroughEntry as or, ReviewEvidenceShardId as ot, FileReviewDelegationFailure as p, selectReviewRange as pn, readFileDiffHandler as pr, UNIT_EVIDENCE_CHAR_BUDGET as pt, makeFanOutReviewSuite as q, MAX_WALKTHROUGH_SUMMARY_CHARS as qn, planWalkthrough as qt, DelegateFileReview as r, ReviewStateAuthenticationFailure as rn, ReviewToolkit as rr, ReviewDiscoveryPass as rt, FanOutInstructionOptions as s, StoredReviewConcern as sn, clampMaxFindings as sr, ReviewPassId as st, CandidateAssessment as t, ReviewSelection as tn, ReviewInstructionOptions as tr, MAX_UNIT_EVIDENCE_SHARDS as tt, FanOutReviewer as u, computeProfileFingerprint as un, fileReviewEvidenceChunks as ur, ReviewUnitId as ut, FileReviewToolkit as v, validateReviewState as vn, MAX_FILE_CHARS as vr, DEFAULT_GITHUB_REVIEW_AUTHOR_LOGIN as vt, FindingCandidate as w, ReviewInputCoverage as wn, ChangedFile as wr, ReviewPublisher as wt, FileReviewUnitResult as x, FailedReviewUnit as xn, PullRequestSourceFailure as xr, PriorReviewLookupFailure as xt, FileReviewToolkitLayer as y, webCryptoReviewStateAuthenticatorLayer as yn, PullRequestMetadata as yr, GitHubApiFailure as yt, defaultFileReviewerPolicy as z, FindingCategory as zn, hasReviewMetadataMarker as zt };
-//# sourceMappingURL=fan-out-n-00ppWr.d.mts.map
+export { decideReviewRetirement as $, listChangedFilesHandler as $n, MAX_REVIEW_UNITS as $t, makeFileReviewerInstructions as A, ListChangedFilesQuery as An, fromStoredFinding as At, fingerprintUnchanged as B, ReviewConcern as Bn, FailedReviewUnit as Bt, ReviewWorkPerspective as C, FileDiffView as Cn, ReviewStateMarkerTooLarge as Ct, defaultFileReviewerPolicy as D, FindingCategory as Dn, UnreviewedStage as Dt, confirmedFindingForPublication as E, FileSliceQuery as En, StoredUnreviewedPass as Et, GitHubReviewTarget as F, MAX_WALKTHROUGH_SUMMARY_CHARS as Fn, toStoredFinding as Ft, parseGitHubSubmittedAt as G, ReviewToolkit as Gn, assessFlatReview as Gt, gitHubPullRequestSourceLayer as H, ReviewGuidance as Hn, ReviewAssurance as Ht, PriorReviewLookupFailure as I, PullRequestReviewer as In, unavailableReviewStateAuthenticatorLayer as It, ReviewRetirementDecision as J, WalkthroughEntry as Jn, fanOutInputCoverage as Jt, RetirableReview as K, ReviewToolkitLayer as Kn, boundedListReason as Kt, PriorReviews as L, REVIEW_TOOL_RESULT_MAX_BYTES as Ln, validateReviewState as Lt, runFanOutReview as M, MAX_FINDINGS as Mn, selectReviewRange as Mt, DEFAULT_GITHUB_REVIEW_AUTHOR_LOGIN as N, MAX_PATCH_CHARS as Nn, selectedPullRequestSourceLayer as Nt, fileReviewerInstructions as O, FindingSeverity as On, buildProfileMission as Ot, GitHubApiFailure as P, MAX_WALKTHROUGH_ENTRIES as Pn, toStoredConcern as Pt, ReviewRetirementReport as Q, fileReviewEvidenceChunks as Qn, MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS as Qt, PublishedReview as R, ReadFile as Rn, webCryptoReviewStateAuthenticatorLayer as Rt, ReviewPassMisbehaved as S, FileDiffQuery as Sn, renderReviewContent as Sr, ReviewStateMarker as St, assessmentSettlesSuggestionExactly as T, FileSlice as Tn, StoredReviewFinding as Tt, gitHubReviewPublisherLayer as U, ReviewInstructionOptions as Un, ReviewCoverage as Ut, gitHubPriorReviewsLayer as V, ReviewFinding as Vn, FlatReviewAssessment as Vt, gitHubReviewRetirementHostLayer as W, ReviewMission as Wn, ReviewInputCoverage as Wt, ReviewRetirementHost as X, defaultReviewPolicy as Xn, MAX_FILE_EVIDENCE_CHARS as Xt, ReviewRetirementFailure as Y, clampMaxFindings as Yn, flatAssurance as Yt, ReviewRetirementInput as Z, fileDiffView as Zn, MAX_MERGED_FINDINGS as Zt, MAX_REVIEW_CHILDREN as _, rankAndDedupeFindings as _n, annotatePatch as _r, ReviewScopeMode as _t, FanOutPipelineInput as a, ReviewEvidenceShardId as an, MAX_CHANGED_FILES as ar, ReviewPublicationPlan as at, ReviewCandidate as b, ChangedFilesView as bn, isReviewableFile as br, ReviewStateAuthenticationFailure as bt, FileReviewEvidence as c, ReviewUnit as cn, PullRequestSource as cr, planWalkthrough as ct, FileReviewer as d, UNIT_CHANGED_LINE_BUDGET as dn, normalizeRepoRelativePath as dr, MAX_REVIEW_STATE_MARKER_CHARS as dt, MAX_UNIT_EVIDENCE_SHARDS as en, makeReviewInstructions as er, hasReviewMetadataMarker as et, FileReviewerBinding as f, UNIT_EVIDENCE_CHAR_BUDGET as fn, ChangedFile as fr, MAX_STORED_UNREVIEWED_PASSES as ft, MAX_FILE_REVIEW_TOOL_CALLS as g, rankAndDedupeConcerns as gn, PatchLine as gr, ReviewMode as gt, MAX_CHILD_FINDINGS as h, planReviewUnits as hn, MAX_REVIEW_CONTENT_CHARS as hr, ReviewHeadComparison as ht, FanOutInstructionOptions as i, ReviewEvidenceShard as in, reviewInstructions as ir, ReviewEvent as it, reviewCandidateSubjectKey as j, MAX_CONCERNS as jn, isLineageAncestor as jt, makeFileReviewerDefinition as k, ListChangedFiles as kn, fromStoredConcern as kt, FileReviewReport as l, ReviewUnitId as ln, PullRequestSourceFailure as lr, renderAgentPrompt as lt, MAX_CHILD_CONCERNS as m, findingAnchorInUnitEvidence as mn, ChangedPath as mr, ReviewExecutionContext as mt, ConcernCandidate as n, ReviewDiscoveryPass as nn, readFileHandler as nr, AGENT_PROMPT_PREAMBLE as nt, FanOutPipelineOutcome as o, ReviewPassId as on, MAX_FILE_CHARS as or, estimateReviewEffort as ot, FindingCandidate as p, classifyReviewRisks as pn, ChangedFileStatus as pr, MAX_STORED_UNREVIEWED_PATHS as pt, RetirableReviewComment as q, ReviewVerdict as qn, compatibilityCoverage as qt, DiscoveredConcern as r, ReviewDiscoveryPerspective as rn, resolveGuidance as rr, ReviewCommentDraft as rt, FileReviewBrief as s, ReviewRiskCategory as sn, PullRequestMetadata as sr, planPublication as st, CandidateAssessment as t, MAX_UNIT_FILES as tn, readFileDiffHandler as tr, retireStaleReviews as tt, FileReviewToolkit as u, ReviewUnitPlan as un, ReviewInputViolation as ur, GitCommitSha as ut, MAX_UNIT_CANDIDATES as v, anchorViolation as vn, commentableLines as vr, ReviewSelection as vt, ReviewWorkPhase as w, FileReviewEvidenceChunk as wn, StoredReviewConcern as wt, ReviewCandidateId as x, CodeReview as xn, parsePatch as xr, ReviewStateAuthenticator as xt, REVIEW_UNIT_CONCURRENCY as y, ChangedFileSummary as yn, hasReviewableContent as yr, ReviewState as yt, ReviewPublisher as z, ReadFileDiff as zn, FailedReviewPass as zt };
+//# sourceMappingURL=fan-out-Bi1v0VaU.d.mts.map