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

package/dist/{fan-out-CQFA-o0v.d.mts → fan-out-n-00ppWr.d.mts}

@@ -130,6 +130,8 @@ declare class PullRequestSource extends PullRequestSource_base {}
 declare const MAX_FINDINGS = 20;
 /** The hard non-anchored-concerns bound carried by the CodeReview schema. */
 declare const MAX_CONCERNS = 10;
+/** Maximum characters in one deterministic model-visible evidence chunk. */
+declare const MAX_PATCH_CHARS = 60000;
 /** The encoded Tool result must retain one complete bounded content fallback. */
 declare const REVIEW_TOOL_RESULT_MAX_BYTES: number;
 declare const ChangedFileSummary_base: Schema.Class<ChangedFileSummary, Schema.Struct<{
@@ -179,6 +181,14 @@ declare const FileDiffView_base: Schema.Class<FileDiffView, Schema.Struct<{
   readonly truncated: Schema.Boolean;
 }>, {}>;
 declare class FileDiffView extends FileDiffView_base {}
+interface FileReviewEvidenceChunk {
+  readonly reviewMode: "diff" | "content" | "unavailable";
+  readonly annotatedPatch: string;
+}
+/** Complete bounded evidence chunks used by deterministic fan-out planning. */
+declare const fileReviewEvidenceChunks: (file: ChangedFile) => ReadonlyArray<FileReviewEvidenceChunk>;
+/** Host-owned rendering of one changed file's bounded review evidence. */
+declare const fileDiffView: (file: ChangedFile) => FileDiffView;
 declare const ReadFileDiff: Tool.Tool<"read_file_diff", {
   readonly parameters: typeof FileDiffQuery;
   readonly success: typeof FileDiffView;
@@ -370,6 +380,10 @@ declare const PullRequestReviewer: import("effect-agent").Definition<typeof Revi
   }, PullRequestSource>;
 }>, undefined>;
 //#endregion
+//#region src/internal/anchors.d.ts
+/** 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/coverage.d.ts
 declare const ReviewShape: Schema.Literals<readonly ["flat", "fan-out"]>;
 type ReviewShape = typeof ReviewShape.Type;
@@ -386,18 +400,64 @@ declare const ReviewCoverage_base: Schema.Class<ReviewCoverage, Schema.Struct<{
   readonly failedUnits: Schema.$Array<typeof FailedReviewUnit>;
   readonly reasons: Schema.$Array<Schema.NonEmptyString>;
 }>, {}>;
-declare class ReviewCoverage extends ReviewCoverage_base {}
 /**
- * Host-verified per-file summaries from the fan-out run's Tool events: for
- * every successfully settled delegation, the child-reported `fileSummaries`
- * whose paths belong to that invocation's requested unit. This is the
- * declassification check `projectResult` cannot perform itself (it never sees
- * the request): a child assigned file A cannot smuggle a summary for changed
- * file B into the merged walkthrough, and a coordinator cannot invent or edit
- * entries — only exact child-reported, in-unit summaries survive.
+ * Compatibility diagnostic retained for callers that consumed the original
+ * `coverage` field. New UI and state decisions use ReviewInputCoverage and
+ * ReviewAssurance directly.
  */
-declare const collectUnitFileSummaries: (events: ReadonlyArray<RunEvent>) => ReadonlyArray<WalkthroughEntry>;
-/** Assess one settled run without trusting its prose summary or verdict. */
+declare class ReviewCoverage extends ReviewCoverage_base {}
+declare const ReviewInputCoverage_base: Schema.Class<ReviewInputCoverage, Schema.Struct<{
+  readonly status: Schema.Literals<readonly ["complete", "incomplete"]>;
+  readonly requiredPaths: Schema.$Array<Schema.NonEmptyString>;
+  readonly assignedPaths: Schema.$Array<Schema.NonEmptyString>;
+  /** Assigned paths whose model-visible diff was truncated by the evidence bound. */
+  readonly partialPaths: Schema.$Array<Schema.NonEmptyString>;
+  readonly unassignedPaths: Schema.$Array<Schema.NonEmptyString>;
+  readonly reasons: Schema.$Array<Schema.NonEmptyString>;
+}>, {}>;
+declare class ReviewInputCoverage extends ReviewInputCoverage_base {}
+declare const FailedReviewPass_base: Schema.Class<FailedReviewPass, Schema.Struct<{
+  readonly workId: Schema.NonEmptyString;
+  readonly stage: Schema.Literals<readonly ["discovery", "specialist", "verification"]>;
+  readonly errorTag: Schema.NonEmptyString;
+}>, {}>;
+declare class FailedReviewPass extends FailedReviewPass_base {}
+declare const ReviewAssurance_base: Schema.Class<ReviewAssurance, Schema.Struct<{
+  readonly status: Schema.Literals<readonly ["settled", "incomplete", "unverified"]>;
+  readonly requiredGeneralDiscoveryPasses: Schema.Int;
+  readonly completedGeneralDiscoveryPasses: Schema.Int;
+  readonly requiredSpecialistPasses: Schema.Int;
+  readonly completedSpecialistPasses: Schema.Int;
+  readonly requiredVerificationPasses: Schema.Int;
+  readonly completedVerificationPasses: Schema.Int;
+  readonly discoveredCandidates: Schema.Int;
+  readonly confirmedCandidates: Schema.Int;
+  readonly rejectedCandidates: Schema.Int;
+  readonly unsettledCandidates: Schema.Int;
+  /** Every failure remains visible within the coordinator's 32-call hard bound. */
+  readonly failedPasses: Schema.$Array<typeof FailedReviewPass>;
+  readonly reasons: Schema.$Array<Schema.NonEmptyString>;
+}>, {}>;
+declare class ReviewAssurance extends ReviewAssurance_base {}
+interface ReviewPipelineAssessment {
+  readonly inputCoverage: ReviewInputCoverage;
+  readonly assurance: ReviewAssurance;
+  /** Deprecated compatibility aggregate. */
+  readonly coverage: ReviewCoverage;
+  readonly confirmedFindings: ReadonlyArray<ReviewFinding>;
+  readonly confirmedConcerns: ReadonlyArray<ReviewConcern>;
+  readonly walkthrough: ReadonlyArray<WalkthroughEntry>;
+}
+/** Assess one settled run without trusting coordinator prose or findings. */
+declare const assessReviewPipeline: (input: {
+  readonly shape: ReviewShape;
+  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;
   readonly files: ReadonlyArray<ChangedFile>;
@@ -406,6 +466,8 @@ declare const assessReviewCoverage: (input: {
   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>;
 //#endregion
 //#region src/internal/review-state.d.ts
 declare const ReviewMode: Schema.Literals<readonly ["incremental", "final"]>;
@@ -446,10 +508,12 @@ declare const ReviewState_base: Schema.Class<ReviewState, Schema.Struct<{
   readonly lastReviewMode: Schema.Literals<readonly ["incremental", "full"]>;
 }>, {}>;
 /**
- * Versioned state embedded in one successfully covered review. The reviewed
- * head plus the full-scope fingerprint means every path not represented by an
- * unresolved item is accepted at that head; storing hundreds of path strings
- * separately would not fit GitHub's bounded review body in the worst case.
+ * Versioned state embedded only after complete input assignment and settled
+ * configured review assurance. The head plus full-scope fingerprint forms an
+ * incremental baseline; an absent unresolved item never means the path is
+ * defect-free. The `acceptedScopeFingerprint` name is retained for wire
+ * compatibility. Storing hundreds of path strings separately would not fit
+ * GitHub's bounded review body in the worst case.
  */
 declare class ReviewState extends ReviewState_base {}
 declare const toStoredFinding: (finding: ReviewFinding) => StoredReviewFinding;
@@ -595,7 +659,6 @@ declare const estimateReviewEffort: (files: ReadonlyArray<ChangedFile>) => {
  * Why one finding cannot become an inline comment, or undefined when it can.
  * Exported so tests can pin each rule individually.
  */
-declare const anchorViolation: (finding: ReviewFinding, files: ReadonlyArray<ChangedFile>) => string | undefined;
 /**
  * Turn one validated review into the exact GitHub publication payload.
  * `applyVerdict: false` (the safe default) always posts a COMMENT review;
@@ -628,7 +691,11 @@ declare const planPublication: (review: CodeReview, files: ReadonlyArray<Changed
   readonly fingerprint?: string | undefined;
   /** Host-owned coverage; incomplete coverage is rendered and fails the check. */
   readonly coverage?: ReviewCoverage | undefined;
-  /** Unchanged unresolved items carried from the prior successfully reviewed head. */
+  /** 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. */
   readonly carriedFindings?: ReadonlyArray<ReviewFinding> | undefined;
   readonly carriedConcerns?: ReadonlyArray<ReviewConcern> | undefined;
   /** Selected review scope, made visible whenever orchestration chose it. */
@@ -813,16 +880,65 @@ declare const fingerprintUnchanged: (current: string) => Effect.Effect<boolean,
 declare const MAX_REVIEW_UNITS = 8;
 /** A unit never carries more files than this, regardless of their size. */
 declare const MAX_UNIT_FILES = 12;
-/** Soft changed-line budget per unit; a single oversized file still gets its own unit. */
+/** Compatibility export; complete evidence chars now own unit packing. */
 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 {}
@@ -831,8 +947,16 @@ declare const ReviewUnitPlan_base: Schema.Class<ReviewUnitPlan, Schema.Struct<{
   /** 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
@@ -842,22 +966,36 @@ declare const ReviewUnitPlan_base: Schema.Class<ReviewUnitPlan, Schema.Struct<{
 }>, {}>;
 /** 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 packed greedily in that order under the soft changed-line budget and
- * the hard per-unit file bound. Capacity is finite and explicit:
+ * then split into complete line-bounded evidence shards and packed greedily
+ * under the hard evidence and per-unit shard bounds. Capacity is finite and
+ * explicit:
  *
  * - files without a textual diff are still delegated when the source
  *   recovered complete bounded UTF-8 base/head content. Findings from that
  *   evidence cannot anchor inline and are reported as concerns;
  * - files with neither form of textual evidence surface in
  *   `undiffablePaths` instead of laundering missing coverage;
- * - reviewable files beyond `MAX_REVIEW_UNITS` full units surface in
- *   `unassignedPaths` so the review can report them as unreviewed, never
- *   silently truncated.
+ * - an oversized path spans as many deterministic shards and units as needed;
+ * - shards beyond `MAX_REVIEW_UNITS` full units surface explicitly, so a path
+ *   is partial only when finite plan capacity is genuinely exhausted.
  */
 declare const planReviewUnits: (files: ReadonlyArray<ChangedFile>, options: {
   readonly totalChangedFiles: number;
@@ -873,116 +1011,164 @@ declare const planReviewUnits: (files: ReadonlyArray<ChangedFile>, options: {
 declare const rankAndDedupeFindings: (findings: ReadonlyArray<ReviewFinding>) => ReadonlyArray<ReviewFinding>;
 //#endregion
 //#region src/internal/fan-out.d.ts
-/** One child returns at most this many findings; the merge caps the total. */
-declare const MAX_CHILD_FINDINGS = 8;
-/** One child returns at most this many non-anchored concerns. */
+/** One discovery pass returns at most this many anchored candidates. */
+declare const MAX_CHILD_FINDINGS = 6;
+/** One discovery pass returns at most this many non-anchored candidates. */
 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. */
+declare const MAX_REVIEW_CHILDREN: number;
+/** 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"]>;
+type ReviewWorkPhase = typeof ReviewWorkPhase.Type;
+declare const ReviewWorkPerspective: Schema.Literals<readonly ["general", "risk-specialist", "candidate-verification"]>;
+type ReviewWorkPerspective = typeof ReviewWorkPerspective.Type;
+declare const ReviewCandidateId: Schema.NonEmptyString;
+declare const FindingCandidate_base: Schema.Class<FindingCandidate, Schema.TaggedStruct<"FindingCandidate", {
+  readonly candidateId: Schema.NonEmptyString;
+  readonly workId: Schema.NonEmptyString;
+  readonly unitId: Schema.NonEmptyString;
+  readonly finding: typeof ReviewFinding;
+  readonly evidencePaths: Schema.$Array<Schema.NonEmptyString>;
+}>, {}>;
+declare class FindingCandidate extends FindingCandidate_base {}
+declare const ConcernCandidate_base: Schema.Class<ConcernCandidate, Schema.TaggedStruct<"ConcernCandidate", {
+  readonly candidateId: Schema.NonEmptyString;
+  readonly workId: Schema.NonEmptyString;
+  readonly unitId: Schema.NonEmptyString;
+  readonly concern: typeof ReviewConcern;
+  readonly evidencePaths: Schema.$Array<Schema.NonEmptyString>;
+}>, {}>;
+declare class ConcernCandidate extends ConcernCandidate_base {}
+declare const ReviewCandidate: Schema.Union<readonly [typeof FindingCandidate, typeof ConcernCandidate]>;
+type ReviewCandidate = typeof ReviewCandidate.Type;
+/** Deterministic host equivalence for claims repeated across discovery passes. */
+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 {}
 /**
- * One mandatory diff read plus one bounded context read for every path in a
- * maximum-size unit. Keep the child and delegation reservation aligned.
+ * Exact suggestion settlement shape: a carried suggestion must be settled and
+ * nothing else may be. Enforced identically by the live delegation projection
+ * and the independent host coverage fold.
  */
-declare const MAX_FILE_REVIEW_TOOL_CALLS: number;
-declare const FileReviewToolkit: Toolkit.Toolkit<{
-  readonly read_file: Tool.Tool<"read_file", {
-    readonly parameters: typeof FileSliceQuery;
-    readonly success: typeof FileSlice;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-  readonly read_file_diff: Tool.Tool<"read_file_diff", {
-    readonly parameters: typeof FileDiffQuery;
-    readonly success: typeof FileDiffView;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-}>;
-declare const FileReviewToolkitLayer: import("effect/Layer").Layer<Tool.HandlersFor<{
-  readonly read_file: Tool.Tool<"read_file", {
-    readonly parameters: typeof FileSliceQuery;
-    readonly success: typeof FileSlice;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-  readonly read_file_diff: Tool.Tool<"read_file_diff", {
-    readonly parameters: typeof FileDiffQuery;
-    readonly success: typeof FileDiffView;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-}>, never, never>;
+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>;
+}>, {}>;
+/**
+ * Concern candidates need explicit paths internally to bind the claim to
+ * scheduled evidence. The verifier receives the complete bounded unit so it
+ * can use neighboring evidence to falsify the claim. The public ReviewConcern
+ * remains path-free after the host confirms and projects it.
+ */
+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;
+  readonly status: Schema.Literals<readonly ["added", "removed", "modified", "renamed", "copied", "changed", "unchanged"]>;
+  readonly reviewMode: Schema.Literals<readonly ["diff", "content", "unavailable"]>;
+  readonly ordinal: Schema.Int;
+  readonly total: Schema.Int;
+  readonly annotatedPatch: Schema.String;
+}>, {}>;
+/** One complete host-selected evidence shard supplied to a review child. */
+declare class FileReviewEvidence extends FileReviewEvidence_base {}
 declare const FileReviewBrief_base: Schema.Class<FileReviewBrief, Schema.Struct<{
+  readonly phase: Schema.Literals<readonly ["discovery", "verification"]>;
+  readonly workId: Schema.NonEmptyString;
   readonly unitId: Schema.NonEmptyString;
   readonly paths: Schema.$Array<Schema.NonEmptyString>;
-  readonly focus: 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"]>>;
+  readonly candidates: Schema.$Array<Schema.Union<readonly [typeof FindingCandidate, typeof ConcernCandidate]>>;
+  readonly evidence: Schema.$Array<typeof FileReviewEvidence>;
 }>, {}>;
-/** The child Agent input: one briefed unit of the changeset. */
+/** Host-prepared child input with complete bounded diff/content evidence. */
 declare class FileReviewBrief extends FileReviewBrief_base {}
 declare const FileReviewReport_base: Schema.Class<FileReviewReport, Schema.Struct<{
+  readonly phase: Schema.Literals<readonly ["discovery", "verification"]>;
+  readonly workId: Schema.NonEmptyString;
   readonly unitId: Schema.NonEmptyString;
   readonly findings: Schema.$Array<typeof ReviewFinding>;
-  /** Unit-scoped concerns with no diff line to anchor to. */
-  readonly concerns: Schema.optionalKey<Schema.$Array<typeof ReviewConcern>>;
-  /** One-sentence per-file change summaries for the merged walkthrough. */
-  readonly fileSummaries: Schema.optionalKey<Schema.$Array<typeof WalkthroughEntry>>;
+  readonly concerns: Schema.$Array<typeof DiscoveredConcern>;
+  readonly fileSummaries: Schema.$Array<typeof WalkthroughEntry>;
+  readonly assessments: Schema.$Array<typeof CandidateAssessment>;
 }>, {}>;
-/** The child Agent output: the briefed unit's bounded findings and concerns. */
+/** Child output; phase-inapplicable collections must be empty. */
 declare class FileReviewReport extends FileReviewReport_base {}
-/**
- * Guidance for delegated children must be static: child instructions are a
- * pure function of the brief, and the coordinator's mission never crosses the
- * delegation boundary (context isolation), so mission-dependent guidance
- * cannot be resolved for a child.
- */
-interface FanOutInstructionOptions {
-  readonly guidance?: string | ReadonlyArray<string> | undefined;
-}
-/** Build the child file-reviewer instructions with optional static guidance. */
-declare const makeFileReviewerInstructions: (options?: FanOutInstructionOptions) => (brief: FileReviewBrief) => string;
-declare const fileReviewerInstructions: (brief: FileReviewBrief) => string;
-/** The default per-unit child execution bounds. */
-declare const defaultFileReviewerPolicy: AgentPolicy;
-declare const FileReviewRequest_base: Schema.Class<FileReviewRequest, Schema.Struct<{
-  readonly unitId: Schema.NonEmptyString;
-  readonly paths: Schema.$Array<Schema.NonEmptyString>;
-}>, {}>;
-/** The model-decoded delegation parameters: which unit to review. */
-declare class FileReviewRequest extends FileReviewRequest_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 findings: Schema.$Array<typeof ReviewFinding>;
-  /** Unit-scoped concerns with no diff line to anchor to. */
-  readonly concerns: Schema.optionalKey<Schema.$Array<typeof ReviewConcern>>;
-  /** One-sentence per-file change summaries for the merged walkthrough. */
-  readonly fileSummaries: Schema.optionalKey<Schema.$Array<typeof WalkthroughEntry>>;
+  readonly candidates: Schema.$Array<Schema.Union<readonly [typeof FindingCandidate, typeof ConcernCandidate]>>;
+  readonly fileSummaries: Schema.$Array<typeof WalkthroughEntry>;
+  readonly assessments: Schema.$Array<typeof CandidateAssessment>;
 }>, {}>;
-/** The bounded parent-visible result of one delegated unit review. */
+/** 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>;
-/**
- * One unit's review failed: the child Run ended in a typed failure (policy
- * bound, output violation, model fault). The marker is bounded and carries no
- * child transcript content beyond the failure tag and message.
- */
 declare class FileReviewUnitFailed extends FileReviewUnitFailed_base {}
-/**
- * Finite per-invocation bounds (SUB-009), aligned with the child's own
- * AgentPolicy: the child's policy is the limit that trips typed; the
- * reservation mirrors it so parent-side accounting stays honest.
- */
+declare const FileReviewWorkRejected_base: Schema.Class<FileReviewWorkRejected, Schema.TaggedStruct<"FileReviewWorkRejected", {
+  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]>;
+interface FanOutInstructionOptions {
+  readonly guidance?: string | ReadonlyArray<string> | undefined;
+}
+/** Discovery and verification instructions share one child definition. */
+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;
-/**
- * Total mapping from every expected child Run failure to the declared unit
- * failure (SUB-028): the tag plus a bounded message, nothing else crosses.
- */
 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<{
-  /** Explicit constant keeps the zero-choice operation compatible with strict provider schemas. */
   readonly scope: Schema.Literal<"all">;
 }>, {}>;
 declare class ListReviewUnitsQuery extends ListReviewUnitsQuery_base {}
@@ -1000,63 +1186,24 @@ declare const FanOutCoordinatorToolkit: Toolkit.Toolkit<{
     readonly failureMode: "error";
   }, PullRequestSource>;
 }>;
-declare const FanOutCoordinatorToolkitLayer: import("effect/Layer").Layer<Tool.Handler<"list_review_units">, never, never>;
-/**
- * Build the coordinator's instructions. The same consumer guidance the
- * children receive is injected between the mission framing and the procedure
- * so the merged summary and verdict are shaped by the same review profile,
- * and the configured findings bound reaches the merge step instead of only
- * the host-side trim.
- */
+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;
-/** The default fan-out coordinator execution bounds. */
 declare const defaultFanOutPolicy: AgentPolicy;
-/** Everything one fan-out configuration is made of, built as one unit so the
- * delegation always targets exactly the child definition that will run. */
 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<{
-  readonly read_file: Tool.Tool<"read_file", {
-    readonly parameters: typeof FileSliceQuery;
-    readonly success: typeof FileSlice;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-  readonly read_file_diff: Tool.Tool<"read_file_diff", {
-    readonly parameters: typeof FileDiffQuery;
-    readonly success: typeof FileDiffView;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-}>, undefined>;
-/** Options for one coherent fan-out suite: shared guidance plus the merge bound. */
-interface FanOutSuiteOptions extends FanOutInstructionOptions {
+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;
-}
-declare const makeFileReviewDelegation: (child: ReturnType<typeof makeFileReviewerDefinition>) => import("effect-agent").SubagentDelegation<"delegate_file_review", typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, {
-  readonly read_file: Tool.Tool<"read_file", {
-    readonly parameters: typeof FileSliceQuery;
-    readonly success: typeof FileSlice;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-  readonly read_file_diff: Tool.Tool<"read_file_diff", {
-    readonly parameters: typeof FileDiffQuery;
-    readonly success: typeof FileDiffView;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-}, typeof FileReviewRequest, typeof FileReviewUnitResult, typeof FileReviewUnitFailed, never, never, "return">;
-declare const makeFanOutReviewerDefinition: (options: FanOutSuiteOptions, delegation: ReturnType<typeof makeFileReviewDelegation>) => import("effect-agent").Definition<typeof ReviewMission, typeof CodeReview, (mission: ReviewMission) => string, Toolkit.Toolkit<{
+}, 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<typeof FileReviewUnitFailed>]>;
+    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>;
@@ -1067,28 +1214,15 @@ declare const makeFanOutReviewerDefinition: (options: FanOutSuiteOptions, delega
     readonly failureMode: "error";
   }, PullRequestSource>;
 }>, undefined>;
-/** Build one coherent fan-out suite: child, coordinator, and delegation. */
+interface FanOutSuiteOptions extends FanOutInstructionOptions {
+  readonly maxFindings?: number | undefined;
+}
 declare const makeFanOutReviewSuite: (options?: FanOutSuiteOptions) => FanOutReviewSuite;
-/** The default child Agent Definition. */
-declare const FileReviewer: import("effect-agent").Definition<typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, Toolkit.Toolkit<{
-  readonly read_file: Tool.Tool<"read_file", {
-    readonly parameters: typeof FileSliceQuery;
-    readonly success: typeof FileSlice;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-  readonly read_file_diff: Tool.Tool<"read_file_diff", {
-    readonly parameters: typeof FileDiffQuery;
-    readonly success: typeof FileDiffView;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-}>, undefined>;
-/** The default coordinator Agent Definition. */
+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<typeof FileReviewUnitFailed>]>;
+    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>;
@@ -1099,33 +1233,17 @@ declare const FanOutReviewer: import("effect-agent").Definition<typeof ReviewMis
     readonly failureMode: "error";
   }, PullRequestSource>;
 }>, undefined>;
-/** The default delegation over the default child. */
-declare const fileReviewDelegation: import("effect-agent").SubagentDelegation<"delegate_file_review", typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, {
-  readonly read_file: Tool.Tool<"read_file", {
-    readonly parameters: typeof FileSliceQuery;
-    readonly success: typeof FileSlice;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-  readonly read_file_diff: Tool.Tool<"read_file_diff", {
-    readonly parameters: typeof FileDiffQuery;
-    readonly success: typeof FileDiffView;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-}, typeof FileReviewRequest, typeof FileReviewUnitResult, typeof FileReviewUnitFailed, never, never, "return">;
-/** The default coordinator-facing delegation Tool (first-party contained mode). */
+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<typeof FileReviewUnitFailed>]>;
+  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>;
-/** The default coordinator Toolkit. */
 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<typeof FileReviewUnitFailed>]>;
+    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>;
@@ -1136,48 +1254,15 @@ declare const FanOutReviewToolkit: Toolkit.Toolkit<{
     readonly failureMode: "error";
   }, PullRequestSource>;
 }>;
-/**
- * The contained failure family the delegation can surface as result data
- * (SUB-033), derived from the delegation itself so the coverage decoder can
- * never diverge from what the runtime actually contains.
- */
-declare const FileReviewDelegationFailure: import("effect-agent").SubagentContainedFailure<typeof FileReviewUnitFailed>;
-/** Runtime wiring: one delegation plus one explicit child Binding. */
-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>) => import("effect/Layer").Layer<Tool.Handler<"delegate_file_review">, never, import("effect-agent").SubagentLayerRequirements<typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, {
-  readonly read_file: Tool.Tool<"read_file", {
-    readonly parameters: typeof FileSliceQuery;
-    readonly success: typeof FileSlice;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-  readonly read_file_diff: Tool.Tool<"read_file_diff", {
-    readonly parameters: typeof FileDiffQuery;
-    readonly success: typeof FileDiffView;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-}, Provider, ModelProvides, ModelRequires, never, never, never, {
+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>>;
-/** Runtime wiring over the default delegation, mirroring the leaf example. */
-declare const fanOutHandlersLayer: <Provider, ModelProvides, ModelRequires>(childBinding: RuntimeBinding<typeof FileReviewBrief, typeof FileReviewReport, ReturnType<typeof makeFileReviewerInstructions>, Toolkit.Tools<typeof FileReviewToolkit>, Provider, ModelProvides, ModelRequires>) => import("effect/Layer").Layer<Tool.Handler<"delegate_file_review">, never, import("effect-agent").SubagentLayerRequirements<typeof FileReviewBrief, typeof FileReviewReport, (brief: FileReviewBrief) => string, {
-  readonly read_file: Tool.Tool<"read_file", {
-    readonly parameters: typeof FileSliceQuery;
-    readonly success: typeof FileSlice;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-  readonly read_file_diff: Tool.Tool<"read_file_diff", {
-    readonly parameters: typeof FileDiffQuery;
-    readonly success: typeof FileDiffView;
-    readonly failure: Schema.Union<readonly [typeof PullRequestSourceFailure, typeof ReviewInputViolation]>;
-    readonly failureMode: "return";
-  }, PullRequestSource>;
-}, Provider, ModelProvides, ModelRequires, never, never, 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>>;
 //#endregion
-export { gitHubPullRequestSourceLayer as $, ChangedFilesView as $t, fileReviewerInstructions as A, readFileDiffHandler as An, ReviewStateAuthenticationFailure as At, ReviewUnitPlan as B, normalizeRepoRelativePath as Bn, selectReviewRange as Bt, defaultFanOutPolicy as C, ReviewToolkitLayer as Cn, MAX_REVIEW_STATE_MARKER_CHARS as Ct, fanOutReviewInstructions as D, defaultReviewPolicy as Dn, ReviewScopeMode as Dt, fanOutHandlersLayerFor as E, clampMaxFindings as En, ReviewMode as Et, MAX_MERGED_FINDINGS as F, MAX_FILE_CHARS as Fn, StoredReviewFinding as Ft, GitHubApiFailure as G, PatchLine as Gn, validateReviewState as Gt, planReviewUnits as H, ChangedFileStatus as Hn, toStoredConcern as Ht, MAX_REVIEW_UNITS as I, PullRequestMetadata as In, buildProfileMission as It, PriorReviews as J, hasReviewableContent as Jn, ReviewCoverage as Jt, GitHubReviewTarget as K, annotatePatch as Kn, webCryptoReviewStateAuthenticatorLayer as Kt, MAX_UNIT_FILES as L, PullRequestSource as Ln, computeProfileFingerprint as Lt, makeFanOutReviewSuite as M, resolveGuidance as Mn, ReviewStateMarker as Mt, makeFileReviewerInstructions as N, reviewInstructions as Nn, ReviewStateMarkerTooLarge as Nt, fileReviewDelegation as O, listChangedFilesHandler as On, ReviewSelection as Ot, mapFileReviewChildFailure as P, MAX_CHANGED_FILES as Pn, StoredReviewConcern as Pt, gitHubPriorReviewsLayer as Q, ChangedFileSummary as Qt, ReviewUnit as R, PullRequestSourceFailure as Rn, fromStoredConcern as Rt, MAX_FILE_REVIEW_TOOL_CALLS as S, ReviewToolkit as Sn, GitCommitSha as St, fanOutHandlersLayer as T, WalkthroughEntry as Tn, ReviewHeadComparison as Tt, rankAndDedupeFindings as U, ChangedPath as Un, toStoredFinding as Ut, UNIT_CHANGED_LINE_BUDGET as V, ChangedFile as Vn, selectedPullRequestSourceLayer as Vt, DEFAULT_GITHUB_REVIEW_AUTHOR_LOGIN as W, MAX_REVIEW_CONTENT_CHARS as Wn, unavailableReviewStateAuthenticatorLayer as Wt, ReviewPublisher as X, parsePatch as Xn, assessReviewCoverage as Xt, PublishedReview as Y, isReviewableFile as Yn, ReviewShape as Yt, fingerprintUnchanged as Z, renderReviewContent as Zn, collectUnitFileSummaries as Zt, FileReviewer as _, ReviewConcern as _n, anchorViolation as _t, FanOutReviewSuite as a, FindingCategory as an, ReviewRetirementDecision as at, MAX_CHILD_CONCERNS as b, ReviewInstructionOptions as bn, planWalkthrough as bt, FanOutSuiteOptions as c, ListChangedFilesQuery as cn, ReviewRetirementInput as ct, FileReviewReport as d, MAX_WALKTHROUGH_ENTRIES as dn, hasReviewMetadataMarker as dt, CodeReview as en, gitHubReviewPublisherLayer as et, FileReviewRequest as f, MAX_WALKTHROUGH_SUMMARY_CHARS as fn, retireStaleReviews as ft, FileReviewUnitResult as g, ReadFileDiff as gn, ReviewPublicationPlan as gt, FileReviewUnitFailed as h, ReadFile as hn, ReviewEvent as ht, FanOutInstructionOptions as i, FileSliceQuery as in, RetirableReviewComment as it, makeFanOutReviewInstructions as j, readFileHandler as jn, ReviewStateAuthenticator as jt, fileReviewPolicy as k, makeReviewInstructions as kn, ReviewState as kt, FileReviewBrief as l, MAX_CONCERNS as ln, ReviewRetirementReport as lt, FileReviewToolkitLayer as m, REVIEW_TOOL_RESULT_MAX_BYTES as mn, ReviewCommentDraft as mt, FanOutCoordinatorToolkit as n, FileDiffView as nn, parseGitHubSubmittedAt as nt, FanOutReviewToolkit as o, FindingSeverity as on, ReviewRetirementFailure as ot, FileReviewToolkit as p, PullRequestReviewer as pn, AGENT_PROMPT_PREAMBLE as pt, PriorReviewLookupFailure as q, commentableLines as qn, FailedReviewUnit as qt, FanOutCoordinatorToolkitLayer as r, FileSlice as rn, RetirableReview as rt, FanOutReviewer as s, ListChangedFiles as sn, ReviewRetirementHost as st, DelegateFileReview as t, FileDiffQuery as tn, gitHubReviewRetirementHostLayer as tt, FileReviewDelegationFailure as u, MAX_FINDINGS as un, decideReviewRetirement as ut, ListReviewUnits as v, ReviewFinding as vn, estimateReviewEffort as vt, defaultFileReviewerPolicy as w, ReviewVerdict as wn, ReviewExecutionContext as wt, MAX_CHILD_FINDINGS as x, ReviewMission as xn, renderAgentPrompt as xt, ListReviewUnitsQuery as y, ReviewGuidance as yn, planPublication as yt, ReviewUnitId as z, ReviewInputViolation as zn, fromStoredFinding as zt };
-//# sourceMappingURL=fan-out-CQFA-o0v.d.mts.map
+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