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

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

@@ -281,6 +281,18 @@ declare const ReviewMission_base: Schema.Class<ReviewMission, Schema.Struct<{
   readonly baseRef: Schema.NonEmptyString;
   readonly headRef: Schema.NonEmptyString;
   readonly changedFileCount: Schema.Int;
+  /**
+   * Maintainer-adjudicated identities rendered as bounded context lines; the
+   * reviewer must not re-raise them without materially new evidence. Absent
+   * from fingerprint missions so an adjudication never invalidates the
+   * skip-unchanged authority.
+   */
+  readonly adjudicatedContext: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  /**
+   * Prior-round findings on re-reviewed scope, rendered as bounded context
+   * lines; each must be confirmed, declared fixed, or explicitly withdrawn.
+   */
+  readonly priorFindingContext: Schema.optionalKey<Schema.$Array<Schema.String>>;
 }>, {}>;
 declare class ReviewMission extends ReviewMission_base {}
 declare const FindingSeverity: Schema.Literals<readonly ["blocking", "important", "nit"]>;
@@ -308,6 +320,7 @@ declare class ReviewFinding extends ReviewFinding_base {}
 declare const ReviewVerdict: Schema.Literals<readonly ["approve", "comment", "request-changes"]>;
 type ReviewVerdict = typeof ReviewVerdict.Type;
 declare const ReviewConcern_base: Schema.Class<ReviewConcern, Schema.Struct<{
+  readonly evidencePaths: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
   readonly severity: Schema.Literals<readonly ["blocking", "important", "nit"]>;
   readonly title: Schema.NonEmptyString;
   readonly body: Schema.NonEmptyString;
@@ -316,8 +329,11 @@ declare const ReviewConcern_base: Schema.Class<ReviewConcern, Schema.Struct<{
  * A concern with no diff line to anchor to: a missing deletion or cleanup,
  * rollout or migration sequencing, a coverage gap the diff implies but does
  * not add, or a scope question only the author can answer. Rendered as a
- * review-body section — never as an inline comment, so it needs no anchor and
- * is never demoted.
+ * review-body section instead of an inline comment. `evidencePaths` binds the
+ * concern to changed files so a later incremental review can invalidate and
+ * recheck it when any supporting path changes. It remains optional only for
+ * decoding review output and continuity state written before path binding was
+ * introduced; a pathless concern cannot authorize incremental continuity.
  */
 declare class ReviewConcern extends ReviewConcern_base {}
 /** The per-entry walkthrough summary bound, and the entries bound (the changeset cap). */
@@ -380,6 +396,360 @@ declare const PullRequestReviewer: import("effect-agent").Definition<typeof Revi
   }, PullRequestSource>;
 }>, undefined>;
 //#endregion
+//#region src/internal/review-state.d.ts
+declare const ReviewMode: Schema.Literals<readonly ["incremental", "final"]>;
+type ReviewMode = typeof ReviewMode.Type;
+declare const ReviewScopeMode: Schema.Literals<readonly ["incremental", "full"]>;
+type ReviewScopeMode = typeof ReviewScopeMode.Type;
+declare const GitCommitSha: Schema.NonEmptyString;
+declare const StoredReviewFinding_base: Schema.Class<StoredReviewFinding, Schema.Struct<{
+  readonly path: Schema.NonEmptyString;
+  readonly startLine: Schema.Int;
+  readonly endLine: Schema.Int;
+  readonly severity: Schema.Literals<readonly ["blocking", "important", "nit"]>;
+  readonly title: Schema.NonEmptyString;
+  readonly body: Schema.NonEmptyString;
+}>, {}>;
+/** A compact unresolved finding suitable for the bounded review-body marker. */
+declare class StoredReviewFinding extends StoredReviewFinding_base {}
+declare const StoredReviewConcern_base: Schema.Class<StoredReviewConcern, Schema.Struct<{
+  /** Absent only on legacy state written before concern path binding. */
+  readonly evidencePaths: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly severity: Schema.Literals<readonly ["blocking", "important", "nit"]>;
+  readonly title: Schema.NonEmptyString;
+  readonly body: Schema.NonEmptyString;
+}>, {}>;
+/** A compact unresolved non-anchored concern with its invalidation paths. */
+declare class StoredReviewConcern extends StoredReviewConcern_base {}
+/** How a maintainer settled a previously raised finding or concern. */
+declare const AdjudicationDisposition: Schema.Literals<readonly ["accepted-risk", "refuted", "obsolete"]>;
+type AdjudicationDisposition = typeof AdjudicationDisposition.Type;
+/** The adjudications bound carried by the ReviewState schema. */
+declare const MAX_STORED_ADJUDICATIONS = 20;
+declare const StoredAdjudication_base: Schema.Class<StoredAdjudication, Schema.Struct<{
+  readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly startLine: Schema.optionalKey<Schema.Int>;
+  readonly endLine: Schema.optionalKey<Schema.Int>;
+  readonly title: Schema.NonEmptyString;
+  readonly disposition: Schema.Literals<readonly ["accepted-risk", "refuted", "obsolete"]>;
+  readonly reason: Schema.optionalKey<Schema.NonEmptyString>;
+  /** GitHub login of the maintainer whose comment adjudicated the identity. */
+  readonly actor: Schema.NonEmptyString;
+}>, {}>;
+declare class StoredAdjudication extends StoredAdjudication_base {}
+/**
+ * The one finding-identity composition shared by retirement, adjudication,
+ * and settlement. A tagged JSON tuple keeps anchored findings in a namespace
+ * disjoint from title-only concerns and remains unambiguous even when
+ * untrusted path or title text contains delimiter characters.
+ */
+declare const findingIdentity: (finding: {
+  readonly path: string;
+  readonly startLine: number;
+  readonly endLine: number;
+  readonly title: string;
+}) => string;
+/** The disjoint title-only identity namespace for unanchored concerns. */
+declare const concernIdentity: (concern: {
+  readonly title: string;
+}) => string;
+/**
+ * An adjudication's identity: the shared finding identity when anchored, the
+ * disjoint concern identity when unanchored.
+ */
+declare const adjudicationIdentity: (adjudication: StoredAdjudication) => string;
+/** 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 repository: Schema.NonEmptyString;
+  readonly pullRequestNumber: Schema.Int;
+  readonly baseRef: Schema.NonEmptyString;
+  readonly baseSha: Schema.NonEmptyString;
+  readonly headRef: Schema.NonEmptyString;
+  readonly reviewedHeadSha: Schema.NonEmptyString;
+  readonly profileFingerprint: Schema.String;
+  readonly settledScopeFingerprint: Schema.String;
+  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. */
+  readonly unreviewedPasses: 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"]>;
+  /**
+   * Maintainer adjudications standing against this pull request. optionalKey
+   * so state markers signed before the field existed still decode.
+   */
+  readonly adjudications: Schema.optionalKey<Schema.$Array<typeof StoredAdjudication>>;
+}>, {}>;
+/**
+ * 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. 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;
+declare const fromStoredFinding: (finding: StoredReviewFinding) => ReviewFinding;
+declare const toStoredConcern: (concern: ReviewConcern) => StoredReviewConcern;
+declare const fromStoredConcern: (concern: StoredReviewConcern) => ReviewConcern;
+declare const MAX_REVIEW_STATE_MARKER_CHARS = 24000;
+declare const ReviewStateMarker: Schema.brand<Schema.NonEmptyString, "@effect-agent/pr-review/ReviewStateMarker">;
+type ReviewStateMarker = typeof ReviewStateMarker.Type;
+declare const ReviewStateAuthenticationFailure_base: Schema.Class<ReviewStateAuthenticationFailure, Schema.TaggedStruct<"ReviewStateAuthenticationFailure", {
+  readonly operation: Schema.Literals<readonly ["sign", "verify"]>;
+  readonly reason: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+declare class ReviewStateAuthenticationFailure extends ReviewStateAuthenticationFailure_base {}
+declare const ReviewStateMarkerTooLarge_base: Schema.Class<ReviewStateMarkerTooLarge, Schema.TaggedStruct<"ReviewStateMarkerTooLarge", {
+  readonly observedChars: Schema.Int;
+  readonly maximumChars: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class ReviewStateMarkerTooLarge extends ReviewStateMarkerTooLarge_base {}
+declare const ReviewStateAuthenticator_base: Context.ServiceClass<ReviewStateAuthenticator, "@effect-agent/pr-review/ReviewStateAuthenticator", {
+  readonly status: "available" | "unavailable";
+  readonly unavailableReason: string | undefined;
+  readonly render: (state: ReviewState) => Effect.Effect<ReviewStateMarker, ReviewStateAuthenticationFailure | ReviewStateMarkerTooLarge>;
+  readonly extract: (body: string) => Effect.Effect<Option.Option<ReviewState>, ReviewStateAuthenticationFailure>;
+}>;
+declare class ReviewStateAuthenticator extends ReviewStateAuthenticator_base {}
+/** Validated WebCrypto adapter selected at the Action composition root. */
+declare const webCryptoReviewStateAuthenticatorLayer: (secret: Redacted.Redacted<string>) => Layer.Layer<ReviewStateAuthenticator>;
+/** Explicit no-state implementation for hosts without a stable authentication secret. */
+declare const unavailableReviewStateAuthenticatorLayer: (reason: string) => Layer.Layer<ReviewStateAuthenticator>;
+declare const ReviewHeadComparison_base: Schema.Class<ReviewHeadComparison, Schema.Struct<{
+  readonly status: Schema.Literals<readonly ["ahead", "behind", "diverged", "identical"]>;
+  readonly baseSha: Schema.NonEmptyString;
+  readonly headSha: Schema.NonEmptyString;
+  readonly mergeBaseSha: Schema.NonEmptyString;
+  readonly files: Schema.$Array<typeof ChangedFile>;
+  /** GitHub caps compare-file payloads at 300; equality is conservatively truncated. */
+  readonly truncated: Schema.Boolean;
+}>, {}>;
+/** The bounded result of GitHub's previous-head...current-head comparison. */
+declare class ReviewHeadComparison extends ReviewHeadComparison_base {}
+/** Internal review selection applied as a decorator over the full PR source. */
+interface ReviewSelection {
+  readonly mode: ReviewScopeMode;
+  readonly reason: string;
+  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;
+  /** Absent only for an explicit full review with no continuity profile. */
+  readonly profileFingerprint: string | undefined;
+  /** Action-owned authentication capability, constructed at the composition root. */
+  readonly stateAuthenticator?: ReviewStateAuthenticator["Service"] | undefined;
+}
+declare const fullReviewSelection: (input: {
+  readonly reason: string;
+  readonly files: ReadonlyArray<ChangedFile>;
+  readonly totalFiles: number;
+  readonly profileFingerprint?: string | undefined;
+}) => ReviewSelection;
+/** 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
+ * silently suppresses review work.
+ */
+declare const validateReviewState: (state: ReviewState, current: PullRequestMetadata, profileFingerprint: string) => string | undefined;
+/** Pure, deterministic range selection with conservative full-review fallbacks. */
+declare const selectReviewRange: (input: {
+  readonly requestedMode: ReviewMode;
+  readonly current: PullRequestMetadata;
+  readonly fullFiles: ReadonlyArray<ChangedFile>;
+  readonly profileFingerprint: string;
+  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>;
+/** Per-run context consumed by orchestration and publication, not by the model. */
+declare class ReviewExecutionContext extends ReviewExecutionContext_base {}
+/**
+ * Explicit direct-run adapter for callers that intentionally review the full
+ * source without authenticated incremental continuity.
+ */
+declare const fullReviewExecutionContextLayer: (reason: string) => Layer.Layer<ReviewExecutionContext, PullRequestSourceFailure, PullRequestSource>;
+/**
+ * Decorate the full source with the selected review range. Full anchor files
+ * remain available to host-side publication validation; model tools see only
+ * the selected delta and may read head context only for that delta's paths.
+ */
+declare const selectedPullRequestSourceLayer: (selection: ReviewSelection) => Layer.Layer<PullRequestSource, never, PullRequestSource>;
+/** Build the full-surface mission used only to resolve profile guidance. */
+declare const buildProfileMission: (metadata: PullRequestMetadata, files: ReadonlyArray<ChangedFile>) => ReviewMission;
+//#endregion
+//#region src/internal/adjudication.d.ts
+/** Maximum authorized command candidates retained for one inline thread. */
+declare const MAX_THREAD_ADJUDICATION_COMMANDS = 100;
+declare const AdjudicationComment_base: Schema.Class<AdjudicationComment, Schema.Struct<{
+  readonly body: Schema.String;
+  /** GitHub's author_association for the comment author, verbatim. */
+  readonly authorAssociation: Schema.String;
+  readonly authorLogin: Schema.NonEmptyString;
+  /** Creation time; a comment without one loses every later-wins tie. */
+  readonly createdAt: Schema.NullOr<Schema.DateTimeUtc>;
+  /** Stable zero-based order in the source listing, before thread grouping. */
+  readonly sourceOrder: Schema.Int;
+}>, {}>;
+/** One reply or top-level comment observed through the adjudication host. */
+declare class AdjudicationComment extends AdjudicationComment_base {}
+declare const AdjudicableThread_base: Schema.Class<AdjudicableThread, Schema.Struct<{
+  readonly path: Schema.NonEmptyString;
+  readonly startLine: Schema.NullOr<Schema.Int>;
+  readonly endLine: Schema.NullOr<Schema.Int>;
+  /** The root comment's body; its first line carries the finding title. */
+  readonly rootBody: Schema.String;
+  readonly replies: Schema.$Array<typeof AdjudicationComment>;
+}>, {}>;
+/** One of the action's own inline finding threads, replies in creation order. */
+declare class AdjudicableThread extends AdjudicableThread_base {}
+declare const ReviewAdjudicationFailure_base: Schema.Class<ReviewAdjudicationFailure, Schema.TaggedStruct<"ReviewAdjudicationFailure", {
+  readonly operation: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A GitHub adjudication read failed. */
+declare class ReviewAdjudicationFailure extends ReviewAdjudicationFailure_base {
+  get message(): string;
+}
+declare const ReviewAdjudicationHost_base: Context.ServiceClass<ReviewAdjudicationHost, "@effect-agent/pr-review/ReviewAdjudicationHost", {
+  /** This action's own inline finding threads with their replies. */
+  readonly listFindingThreads: Effect.Effect<ReadonlyArray<AdjudicableThread>, ReviewAdjudicationFailure>;
+  /** Top-level pull-request conversation comments. */
+  readonly listIssueComments: Effect.Effect<ReadonlyArray<AdjudicationComment>, ReviewAdjudicationFailure>;
+}>;
+/**
+ * Host-side GitHub reads used by adjudication. Domain code never reaches into
+ * REST directly, and deterministic tests substitute this port. Both listings
+ * return comments in creation order.
+ */
+declare class ReviewAdjudicationHost extends ReviewAdjudicationHost_base {}
+/** Explicit program-edge adapter for runs that intentionally perform no host reads. */
+declare const noReviewAdjudicationHost: {
+  /** This action's own inline finding threads with their replies. */
+  readonly listFindingThreads: Effect.Effect<ReadonlyArray<AdjudicableThread>, ReviewAdjudicationFailure>;
+  /** Top-level pull-request conversation comments. */
+  readonly listIssueComments: Effect.Effect<ReadonlyArray<AdjudicationComment>, ReviewAdjudicationFailure>;
+};
+/** Layer form of {@link noReviewAdjudicationHost}. */
+declare const noReviewAdjudicationHostLayer: Layer.Layer<ReviewAdjudicationHost, never, never>;
+/** author_associations allowed to adjudicate; everything else is ignored. */
+declare const AUTHORIZED_ADJUDICATION_ASSOCIATIONS: ReadonlySet<string>;
+interface ParsedAdjudicationCommand {
+  readonly disposition: AdjudicationDisposition;
+  /** Present only for the issue-comment grammar's quoted target title. */
+  readonly title?: string | undefined;
+  readonly reason?: string | undefined;
+}
+/**
+ * Parse one inline-thread reply: `/adjudicate <disposition>(: <reason>)?`.
+ * The thread itself names the target identity. Returns undefined for a
+ * non-command body and "malformed" for a command that fails the grammar.
+ */
+declare const parseThreadAdjudication: (body: string) => ParsedAdjudicationCommand | "malformed" | undefined;
+/**
+ * Parse one top-level PR comment:
+ * `/adjudicate <disposition> "<exact title>"(: <reason>)?`. The quoted title
+ * is required because the conversation names no finding thread; it targets
+ * the title-alone identity of an unanchored concern.
+ */
+declare const parseIssueAdjudication: (body: string) => ParsedAdjudicationCommand | "malformed" | undefined;
+/** The finding identity an inline thread names, or undefined when unparsable. */
+declare const threadFindingTarget: (thread: AdjudicableThread) => {
+  readonly path: string;
+  readonly startLine: number;
+  readonly endLine: number;
+  readonly title: string;
+} | undefined;
+interface DerivedAdjudications {
+  readonly adjudications: ReadonlyArray<StoredAdjudication>;
+  /** Commands ignored fail-closed: unauthorized authors and malformed bodies. */
+  readonly ignored: ReadonlyArray<string>;
+  /** Later-wins winners dropped oldest-first at the storage bound. */
+  readonly droppedOldest: number;
+}
+/**
+ * Derive the standing adjudications from the host's listings. Every command
+ * is screened fail-closed (authorization, grammar, a parsable target); later
+ * adjudications of the same identity win by comment creation order; the
+ * result is capped at the ReviewState bound dropping the oldest winners.
+ */
+declare const deriveAdjudications: (input: {
+  readonly threads: ReadonlyArray<AdjudicableThread>;
+  readonly issueComments: ReadonlyArray<AdjudicationComment>;
+}) => DerivedAdjudications;
+/** Later-wins merge of stored prior adjudications with freshly derived ones. */
+declare const mergeAdjudications: (prior: ReadonlyArray<StoredAdjudication>, fresh: ReadonlyArray<StoredAdjudication>) => ReadonlyArray<StoredAdjudication>;
+/**
+ * Collect the standing maintainer adjudications: freshly derived through the
+ * host, merged later-wins over the prior state's stored set. The host is a
+ * visible Effect requirement; program edges that intentionally perform no
+ * reads provide {@link noReviewAdjudicationHost}. Fail-open — any listing
+ * fault keeps the complete prior set and never fails the review, because NOT
+ * suppressing a finding is the conservative direction.
+ */
+declare const collectReviewAdjudications: (prior: readonly StoredAdjudication[]) => Effect.Effect<readonly StoredAdjudication[], never, ReviewAdjudicationHost>;
+/** One adjudication as a bounded reviewer-prompt context line. */
+declare const renderAdjudicationContextLine: (adjudication: StoredAdjudication) => string;
+/** One prior-round finding as a bounded reviewer-prompt context line. */
+declare const renderPriorFindingContextLine: (finding: StoredReviewFinding) => string;
+/** Prior-review context threaded into fan-out discovery briefs, per path. */
+interface PriorReviewContext {
+  /** Adjudicated identities; path-free entries apply to every unit. */
+  readonly adjudicated: ReadonlyArray<{
+    readonly path: string | undefined;
+    readonly line: string;
+  }>;
+  /** Prior-round findings whose paths are being re-reviewed. */
+  readonly priorFindings: ReadonlyArray<{
+    readonly path: string;
+    readonly line: string;
+  }>;
+}
+/** Build the fan-out prior-review context from the resolved continuity data. */
+declare const buildPriorReviewContext: (adjudications: ReadonlyArray<StoredAdjudication>, priorFindingsOnScope: ReadonlyArray<StoredReviewFinding>) => PriorReviewContext;
+//#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;
@@ -389,8 +759,6 @@ declare const anchorViolation: (finding: ReviewFinding, files: ReadonlyArray<Cha
 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,
@@ -406,8 +774,6 @@ declare const MAX_UNIT_EVIDENCE_SHARDS = 12;
  * 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;
@@ -519,32 +885,18 @@ declare const planReviewUnits: (files: ReadonlyArray<ChangedFile>, options: {
  */
 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
+ * Stable identity for one concern. The paths are part of the claim: identical
+ * prose about two independent files must not collapse into one item.
+ */
+declare const reviewConcernKey: (concern: ReviewConcern) => string;
+/**
+ * The concern analogue of `rankAndDedupeFindings`: dedupe by exact scoped
+ * 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 FailedReviewUnit_base: Schema.Class<FailedReviewUnit, Schema.Struct<{
-  readonly unitId: Schema.NonEmptyString;
-  readonly errorTag: Schema.NonEmptyString;
-}>, {}>;
-declare class FailedReviewUnit extends FailedReviewUnit_base {}
-declare const ReviewCoverage_base: Schema.Class<ReviewCoverage, Schema.Struct<{
-  readonly status: Schema.Literals<readonly ["complete", "incomplete"]>;
-  readonly requiredPaths: Schema.$Array<Schema.NonEmptyString>;
-  readonly reviewedPaths: Schema.$Array<Schema.NonEmptyString>;
-  readonly unreviewedPaths: Schema.$Array<Schema.NonEmptyString>;
-  readonly failedUnits: Schema.$Array<typeof FailedReviewUnit>;
-  readonly reasons: Schema.$Array<Schema.NonEmptyString>;
-}>, {}>;
-/**
- * Compatibility diagnostic retained for callers that consumed the original
- * `coverage` field. New UI and state decisions use ReviewInputCoverage and
- * ReviewAssurance directly.
- */
-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>;
@@ -596,6 +948,26 @@ declare const ReviewAssurance_base: Schema.Class<ReviewAssurance, Schema.Struct<
 declare class ReviewAssurance extends ReviewAssurance_base {}
 /** Render a bounded, deterministic "label (n): a, b, … (+k more)" reason line. */
 declare const boundedListReason: (label: string, values: Iterable<string>) => string;
+interface CarriedScope {
+  /** Carried paths a retry can actually settle (failed passes, overflow). */
+  readonly retryablePaths: ReadonlyArray<string>;
+  /** Carried paths no retry can settle (binaries, oversized files). */
+  readonly undiffablePaths: ReadonlyArray<string>;
+  /** Whether any incompleteness beyond the undiffable files exists. */
+  readonly retryableGap: boolean;
+}
+/**
+ * Split carried scope into paths a retry can settle and paths it never can.
+ * Undiffable files are a property of the pull request, not a transient
+ * reviewer-side failure: gate reasons and rendered callouts must never promise
+ * they are "retried automatically" — the honest instruction is to remove them
+ * from the pull request or exclude them with ignore globs.
+ */
+declare const splitCarriedScope: (input: {
+  readonly inputCoverage?: ReviewInputCoverage | undefined;
+  readonly assurance?: ReviewAssurance | undefined;
+  readonly unreviewedPaths?: ReadonlyArray<string> | undefined;
+}) => CarriedScope;
 /** The flat reviewer's honest constant assurance: one pass, no verifier. */
 declare const flatAssurance: () => ReviewAssurance;
 interface FlatReviewAssessment {
@@ -629,152 +1001,6 @@ declare const fanOutInputCoverage: (input: {
   readonly anchorFiles: ReadonlyArray<ChangedFile>;
   readonly totalAnchorFiles: number;
 }) => 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"]>;
-type ReviewMode = typeof ReviewMode.Type;
-declare const ReviewScopeMode: Schema.Literals<readonly ["incremental", "full"]>;
-type ReviewScopeMode = typeof ReviewScopeMode.Type;
-declare const GitCommitSha: Schema.NonEmptyString;
-declare const StoredReviewFinding_base: Schema.Class<StoredReviewFinding, Schema.Struct<{
-  readonly path: Schema.NonEmptyString;
-  readonly startLine: Schema.Int;
-  readonly endLine: Schema.Int;
-  readonly severity: Schema.Literals<readonly ["blocking", "important", "nit"]>;
-  readonly title: Schema.NonEmptyString;
-  readonly body: Schema.NonEmptyString;
-}>, {}>;
-/** A compact unresolved finding suitable for the bounded review-body marker. */
-declare class StoredReviewFinding extends StoredReviewFinding_base {}
-declare const StoredReviewConcern_base: Schema.Class<StoredReviewConcern, Schema.Struct<{
-  readonly severity: Schema.Literals<readonly ["blocking", "important", "nit"]>;
-  readonly title: Schema.NonEmptyString;
-  readonly body: Schema.NonEmptyString;
-}>, {}>;
-/** A compact unresolved non-anchored concern carried until a final audit. */
-declare class StoredReviewConcern extends StoredReviewConcern_base {}
-/** The carried-scope bound; a run that cannot fit its leftovers publishes no state. */
-declare const MAX_STORED_UNREVIEWED_PATHS = 100;
-declare const ReviewState_base: Schema.Class<ReviewState, Schema.Struct<{
-  readonly version: Schema.Literal<2>;
-  readonly repository: Schema.NonEmptyString;
-  readonly pullRequestNumber: Schema.Int;
-  readonly baseRef: Schema.NonEmptyString;
-  readonly baseSha: Schema.NonEmptyString;
-  readonly headRef: Schema.NonEmptyString;
-  readonly reviewedHeadSha: Schema.NonEmptyString;
-  readonly profileFingerprint: Schema.String;
-  readonly acceptedScopeFingerprint: Schema.String;
-  readonly reviewedPathCount: Schema.Int;
-  readonly unresolvedFindings: Schema.$Array<typeof StoredReviewFinding>;
-  readonly unresolvedConcerns: Schema.$Array<typeof StoredReviewConcern>;
-  /** Retryable review gaps carried into the next incremental run's scope. */
-  readonly unreviewedPaths: Schema.$Array<Schema.NonEmptyString>;
-  /**
-   * True only when the producing run had complete input coverage, no
-   * unsettled pass, and nothing carried. Skip-unchanged authority: an
-   * unchanged patch may skip re-review only over a settled state.
-   */
-  readonly settled: Schema.Boolean;
-  readonly lastReviewMode: Schema.Literals<readonly ["incremental", "full"]>;
-}>, {}>;
-/**
- * Versioned state embedded 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;
-declare const fromStoredFinding: (finding: StoredReviewFinding) => ReviewFinding;
-declare const toStoredConcern: (concern: ReviewConcern) => StoredReviewConcern;
-declare const fromStoredConcern: (concern: StoredReviewConcern) => ReviewConcern;
-declare const MAX_REVIEW_STATE_MARKER_CHARS = 24000;
-declare const ReviewStateMarker: Schema.brand<Schema.NonEmptyString, "@effect-agent/pr-review/ReviewStateMarker">;
-type ReviewStateMarker = typeof ReviewStateMarker.Type;
-declare const ReviewStateAuthenticationFailure_base: Schema.Class<ReviewStateAuthenticationFailure, Schema.TaggedStruct<"ReviewStateAuthenticationFailure", {
-  readonly operation: Schema.Literals<readonly ["sign", "verify"]>;
-  readonly reason: Schema.NonEmptyString;
-}>, import("effect/Cause").YieldableError>;
-declare class ReviewStateAuthenticationFailure extends ReviewStateAuthenticationFailure_base {}
-declare const ReviewStateMarkerTooLarge_base: Schema.Class<ReviewStateMarkerTooLarge, Schema.TaggedStruct<"ReviewStateMarkerTooLarge", {
-  readonly observedChars: Schema.Int;
-  readonly maximumChars: Schema.Int;
-}>, import("effect/Cause").YieldableError>;
-declare class ReviewStateMarkerTooLarge extends ReviewStateMarkerTooLarge_base {}
-declare const ReviewStateAuthenticator_base: Context.ServiceClass<ReviewStateAuthenticator, "@effect-agent/pr-review/ReviewStateAuthenticator", {
-  readonly status: "available" | "unavailable";
-  readonly unavailableReason: string | undefined;
-  readonly render: (state: ReviewState) => Effect.Effect<ReviewStateMarker, ReviewStateAuthenticationFailure | ReviewStateMarkerTooLarge>;
-  readonly extract: (body: string) => Effect.Effect<Option.Option<ReviewState>, ReviewStateAuthenticationFailure>;
-}>;
-declare class ReviewStateAuthenticator extends ReviewStateAuthenticator_base {}
-/** Validated WebCrypto adapter selected at the Action composition root. */
-declare const webCryptoReviewStateAuthenticatorLayer: (secret: Redacted.Redacted<string>) => Layer.Layer<ReviewStateAuthenticator>;
-/** Explicit no-state implementation for hosts without a stable authentication secret. */
-declare const unavailableReviewStateAuthenticatorLayer: (reason: string) => Layer.Layer<ReviewStateAuthenticator>;
-declare const ReviewHeadComparison_base: Schema.Class<ReviewHeadComparison, Schema.Struct<{
-  readonly status: Schema.Literals<readonly ["ahead", "behind", "diverged", "identical"]>;
-  readonly baseSha: Schema.NonEmptyString;
-  readonly headSha: Schema.NonEmptyString;
-  readonly mergeBaseSha: Schema.NonEmptyString;
-  readonly files: Schema.$Array<typeof ChangedFile>;
-  /** GitHub caps compare-file payloads at 300; equality is conservatively truncated. */
-  readonly truncated: Schema.Boolean;
-}>, {}>;
-/** The bounded result of GitHub's previous-head...current-head comparison. */
-declare class ReviewHeadComparison extends ReviewHeadComparison_base {}
-/** Internal review selection applied as a decorator over the full PR source. */
-interface ReviewSelection {
-  readonly mode: ReviewScopeMode;
-  readonly reason: string;
-  readonly files: ReadonlyArray<ChangedFile>;
-  /** Paths whose changes invalidate prior findings, including paths reverted out of the PR. */
-  readonly affectedPaths: ReadonlyArray<string>;
-  readonly totalFiles: number;
-  readonly baselineSha: string | undefined;
-  readonly priorState: ReviewState | undefined;
-  readonly profileFingerprint: string;
-  /** Action-owned authentication capability, constructed at the composition root. */
-  readonly stateAuthenticator?: ReviewStateAuthenticator["Service"] | undefined;
-}
-/**
- * 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
- * silently suppresses review work.
- */
-declare const validateReviewState: (state: ReviewState, current: PullRequestMetadata, profileFingerprint: string) => string | undefined;
-/** Pure, deterministic range selection with conservative full-review fallbacks. */
-declare const selectReviewRange: (input: {
-  readonly requestedMode: ReviewMode;
-  readonly current: PullRequestMetadata;
-  readonly fullFiles: ReadonlyArray<ChangedFile>;
-  readonly profileFingerprint: string;
-  readonly priorState: ReviewState | undefined;
-  readonly comparison: ReviewHeadComparison | undefined;
-  readonly baseComparison?: ReviewHeadComparison | undefined;
-  readonly lookupFailure?: string | undefined;
-}) => ReviewSelection;
-declare const ReviewExecutionContext_base: Context.ServiceClass<ReviewExecutionContext, "@effect-agent/pr-review/ReviewExecutionContext", ReviewSelection>;
-/** Per-run context consumed by orchestration and publication, not by the model. */
-declare class ReviewExecutionContext extends ReviewExecutionContext_base {}
-/**
- * Decorate the full source with the selected review range. Full anchor files
- * remain available to host-side publication validation; model tools see only
- * 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
 //#region src/internal/render.d.ts
 declare const ReviewEvent: Schema.Literals<readonly ["COMMENT", "APPROVE", "REQUEST_CHANGES"]>;
@@ -872,6 +1098,12 @@ declare const planPublication: (review: CodeReview, files: ReadonlyArray<Changed
   /** Unchanged unresolved items carried from the prior reviewed baseline. */
   readonly carriedFindings?: ReadonlyArray<ReviewFinding> | undefined;
   readonly carriedConcerns?: ReadonlyArray<ReviewConcern> | undefined;
+  /**
+   * Standing maintainer adjudications. The caller excludes their identities
+   * from the review, the carried items, and every severity count; this
+   * planner only renders them as the collapsed adjudicated section.
+   */
+  readonly adjudications?: ReadonlyArray<StoredAdjudication> | undefined;
   /** Selected review scope, made visible whenever orchestration chose it. */
   readonly reviewMode?: ReviewScopeMode | undefined;
   readonly reviewReason?: string | undefined;
@@ -942,6 +1174,11 @@ interface ReviewRetirementDecision {
   readonly resolvedFindings: ReadonlyArray<StoredReviewFinding>;
   readonly priorFindingCount: number;
 }
+/**
+ * The first line of every inline finding comment this package posts. Shared
+ * with adjudication so both parse the identical title shape.
+ */
+declare const INLINE_FINDING_TITLE_PATTERN: RegExp;
 /** The host-authored metadata marker is the authority gate for any edit. */
 declare const hasReviewMetadataMarker: (body: string) => boolean;
 /** Compute one prior review's resolved subset and deterministic retired body. */
@@ -1020,6 +1257,14 @@ declare const gitHubPullRequestSourceLayer: Layer.Layer<PullRequestSource, never
 declare const gitHubReviewPublisherLayer: Layer.Layer<ReviewPublisher, never, GitHubReviewTarget | HttpClient.HttpClient>;
 /** GitHub-backed host operations for cosmetic retirement after publication. */
 declare const gitHubReviewRetirementHostLayer: Layer.Layer<ReviewRetirementHost, never, GitHubReviewTarget | HttpClient.HttpClient>;
+/**
+ * GitHub-backed host reads for maintainer adjudication, installed by
+ * `gitHubReviewLayers` in `github-env.ts` at the public composition root: this action's own
+ * inline finding threads (roots authored by the configured review author)
+ * with their replies, and the pull request's top-level conversation comments.
+ * Both listings are creation-ordered.
+ */
+declare const gitHubReviewAdjudicationHostLayer: Layer.Layer<ReviewAdjudicationHost, never, GitHubReviewTarget | HttpClient.HttpClient>;
 declare const PriorReviewLookupFailure_base: Schema.Class<PriorReviewLookupFailure, Schema.TaggedStruct<"PriorReviewLookupFailure", {
   readonly reason: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -1034,6 +1279,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
@@ -1124,8 +1375,8 @@ declare const DiscoveredConcern_base: Schema.Class<DiscoveredConcern, Schema.Str
 /**
  * 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.
+ * can use neighboring evidence to falsify the claim. The host copies these
+ * validated paths onto a confirmed public concern for incremental continuity.
  */
 declare class DiscoveredConcern extends DiscoveredConcern_base {}
 declare const FileReviewEvidence_base: Schema.Class<FileReviewEvidence, Schema.Struct<{
@@ -1150,6 +1401,10 @@ declare const FileReviewBrief_base: Schema.Class<FileReviewBrief, Schema.Struct<
   /** 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>;
+  /** Maintainer-adjudicated identities on this unit; do not re-raise. */
+  readonly adjudicatedContext: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  /** Prior-round findings on this unit's re-reviewed paths. */
+  readonly priorFindingContext: Schema.optionalKey<Schema.$Array<Schema.String>>;
 }>, {}>;
 /** Host-prepared child input with complete bounded diff/content evidence. */
 declare class FileReviewBrief extends FileReviewBrief_base {}
@@ -1194,6 +1449,11 @@ interface FanOutPipelineOutcome {
   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;
 }
@@ -1204,6 +1464,20 @@ interface FanOutPipelineInput {
   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;
+  /**
+   * Adjudicated identities and prior-round findings injected as discovery
+   * context on the units whose paths they touch. Context only — they never
+   * enter candidates or publication.
+   */
+  readonly priorContext?: PriorReviewContext | undefined;
 }
 /**
  * Run the complete host-scheduled fan-out pipeline over one selected
@@ -1216,8 +1490,12 @@ declare const runFanOutReview: <Provider, ModelProvides, ModelRequires>(binding:
   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 { decideReviewRetirement as $, readFileHandler as $n, ReviewDiscoveryPass as $t, makeFileReviewerInstructions as A, MAX_PATCH_CHARS as An, selectedPullRequestSourceLayer as At, fingerprintUnchanged as B, ReviewInstructionOptions as Bn, ReviewCoverage as Bt, ReviewWorkPerspective as C, FileSliceQuery as Cn, StoredReviewConcern as Ct, defaultFileReviewerPolicy as D, ListChangedFilesQuery as Dn, fromStoredConcern as Dt, confirmedFindingForPublication as E, ListChangedFiles as En, computeProfileFingerprint as Et, GitHubReviewTarget as F, ReadFile as Fn, webCryptoReviewStateAuthenticatorLayer as Ft, parseGitHubSubmittedAt as G, WalkthroughEntry as Gn, fanOutInputCoverage as Gt, gitHubPullRequestSourceLayer as H, ReviewToolkit as Hn, assessFlatReview as Ht, PriorReviewLookupFailure as I, ReadFileDiff as In, FailedReviewPass as It, ReviewRetirementDecision as J, fileDiffView as Jn, MAX_MERGED_FINDINGS as Jt, RetirableReview as K, clampMaxFindings as Kn, flatAssurance as Kt, PriorReviews as L, ReviewConcern as Ln, FailedReviewUnit as Lt, runFanOutReview as M, MAX_WALKTHROUGH_SUMMARY_CHARS as Mn, toStoredFinding as Mt, DEFAULT_GITHUB_REVIEW_AUTHOR_LOGIN as N, PullRequestReviewer as Nn, unavailableReviewStateAuthenticatorLayer as Nt, fileReviewerInstructions as O, MAX_CONCERNS as On, fromStoredFinding as Ot, GitHubApiFailure as P, REVIEW_TOOL_RESULT_MAX_BYTES as Pn, validateReviewState as Pt, ReviewRetirementReport as Q, readFileDiffHandler as Qn, MAX_UNIT_FILES as Qt, PublishedReview as R, ReviewFinding as Rn, FlatReviewAssessment as Rt, ReviewPassMisbehaved as S, FileSlice as Sn, ReviewStateMarkerTooLarge as St, assessmentSettlesSuggestionExactly as T, FindingSeverity as Tn, buildProfileMission as Tt, gitHubReviewPublisherLayer as U, ReviewToolkitLayer as Un, boundedListReason as Ut, gitHubPriorReviewsLayer as V, ReviewMission as Vn, ReviewInputCoverage as Vt, gitHubReviewRetirementHostLayer as W, ReviewVerdict as Wn, compatibilityCoverage as Wt, ReviewRetirementHost as X, listChangedFilesHandler as Xn, MAX_REVIEW_UNITS as Xt, ReviewRetirementFailure as Y, fileReviewEvidenceChunks as Yn, MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS as Yt, ReviewRetirementInput as Z, makeReviewInstructions as Zn, MAX_UNIT_EVIDENCE_SHARDS as Zt, MAX_REVIEW_CHILDREN as _, ChangedFilesView as _n, isReviewableFile as _r, ReviewSelection as _t, FanOutPipelineInput as a, ReviewUnit as an, PullRequestSource as ar, ReviewPublicationPlan as at, ReviewCandidate as b, FileDiffView as bn, ReviewStateAuthenticator as bt, FileReviewEvidence as c, UNIT_CHANGED_LINE_BUDGET as cn, normalizeRepoRelativePath as cr, planWalkthrough as ct, FileReviewer as d, findingAnchorInUnitEvidence as dn, ChangedPath as dr, MAX_REVIEW_STATE_MARKER_CHARS as dt, ReviewDiscoveryPerspective as en, resolveGuidance as er, hasReviewMetadataMarker as et, FileReviewerBinding as f, planReviewUnits as fn, MAX_REVIEW_CONTENT_CHARS as fr, MAX_STORED_UNREVIEWED_PATHS as ft, MAX_FILE_REVIEW_TOOL_CALLS as g, ChangedFileSummary as gn, hasReviewableContent as gr, ReviewScopeMode as gt, MAX_CHILD_FINDINGS as h, anchorViolation as hn, commentableLines as hr, ReviewMode as ht, FanOutInstructionOptions as i, ReviewRiskCategory as in, PullRequestMetadata as ir, ReviewEvent as it, reviewCandidateSubjectKey as j, MAX_WALKTHROUGH_ENTRIES as jn, toStoredConcern as jt, makeFileReviewerDefinition as k, MAX_FINDINGS as kn, selectReviewRange as kt, FileReviewReport as l, UNIT_EVIDENCE_CHAR_BUDGET as ln, ChangedFile as lr, renderAgentPrompt as lt, MAX_CHILD_CONCERNS as m, rankAndDedupeFindings as mn, annotatePatch as mr, ReviewHeadComparison as mt, ConcernCandidate as n, ReviewEvidenceShardId as nn, MAX_CHANGED_FILES as nr, AGENT_PROMPT_PREAMBLE as nt, FanOutPipelineOutcome as o, ReviewUnitId as on, PullRequestSourceFailure as or, estimateReviewEffort as ot, FindingCandidate as p, rankAndDedupeConcerns as pn, PatchLine as pr, ReviewExecutionContext as pt, RetirableReviewComment as q, defaultReviewPolicy as qn, MAX_FILE_EVIDENCE_CHARS as qt, DiscoveredConcern as r, ReviewPassId as rn, MAX_FILE_CHARS as rr, ReviewCommentDraft as rt, FileReviewBrief as s, ReviewUnitPlan as sn, ReviewInputViolation as sr, planPublication as st, CandidateAssessment as t, ReviewEvidenceShard as tn, reviewInstructions as tr, retireStaleReviews as tt, FileReviewToolkit as u, classifyReviewRisks as un, ChangedFileStatus as ur, GitCommitSha as ut, MAX_UNIT_CANDIDATES as v, CodeReview as vn, parsePatch as vr, ReviewState as vt, ReviewWorkPhase as w, FindingCategory as wn, StoredReviewFinding as wt, ReviewCandidateId as x, FileReviewEvidenceChunk as xn, ReviewStateMarker as xt, REVIEW_UNIT_CONCURRENCY as y, FileDiffQuery as yn, renderReviewContent as yr, ReviewStateAuthenticationFailure as yt, ReviewPublisher as z, ReviewGuidance as zn, ReviewAssurance as zt };
-//# sourceMappingURL=fan-out-BJBTAYuh.d.mts.map
+export { ReviewRetirementInput as $, FileSlice as $n, buildPriorReviewContext as $t, makeFileReviewerInstructions as A, UnreviewedStage as An, readFileHandler as Ar, ReviewEvidenceShardId as At, fingerprintUnchanged as B, selectReviewRange as Bn, ChangedFile as Br, rankAndDedupeConcerns as Bt, ReviewWorkPerspective as C, ReviewStateAuthenticator as Cn, clampMaxFindings as Cr, MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS as Ct, defaultFileReviewerPolicy as D, StoredReviewConcern as Dn, listChangedFilesHandler as Dr, ReviewDiscoveryPass as Dt, confirmedFindingForPublication as E, StoredAdjudication as En, fileReviewEvidenceChunks as Er, MAX_UNIT_FILES as Et, GitHubReviewTarget as F, fromStoredConcern as Fn, PullRequestMetadata as Fr, ReviewUnitPlan as Ft, gitHubReviewRetirementHostLayer as G, validateReviewState as Gn, annotatePatch as Gr, AdjudicableThread as Gt, gitHubPullRequestSourceLayer as H, toStoredConcern as Hn, ChangedPath as Hr, reviewConcernKey as Ht, PriorReviewLookupFailure as I, fromStoredFinding as In, PullRequestSource as Ir, UNIT_EVIDENCE_CHAR_BUDGET as It, RetirableReview as J, ChangedFilesView as Jn, isReviewableFile as Jr, MAX_THREAD_ADJUDICATION_COMMANDS as Jt, parseGitHubSubmittedAt as K, webCryptoReviewStateAuthenticatorLayer as Kn, commentableLines as Kr, AdjudicationComment as Kt, PriorReviews as L, fullReviewExecutionContextLayer as Ln, PullRequestSourceFailure as Lr, classifyReviewRisks as Lt, runFanOutReview as M, buildProfileMission as Mn, reviewInstructions as Mr, ReviewRiskCategory as Mt, DEFAULT_GITHUB_REVIEW_AUTHOR_LOGIN as N, concernIdentity as Nn, MAX_CHANGED_FILES as Nr, ReviewUnit as Nt, fileReviewerInstructions as O, StoredReviewFinding as On, makeReviewInstructions as Or, ReviewDiscoveryPerspective as Ot, GitHubApiFailure as P, findingIdentity as Pn, MAX_FILE_CHARS as Pr, ReviewUnitId as Pt, ReviewRetirementHost as Q, FileReviewEvidenceChunk as Qn, ReviewAdjudicationHost as Qt, PublishedReview as R, fullReviewSelection as Rn, ReviewInputViolation as Rr, findingAnchorInUnitEvidence as Rt, ReviewPassMisbehaved as S, ReviewStateAuthenticationFailure as Sn, WalkthroughEntry as Sr, MAX_MERGED_FINDINGS as St, assessmentSettlesSuggestionExactly as T, ReviewStateMarkerTooLarge as Tn, fileDiffView as Tr, MAX_UNIT_EVIDENCE_SHARDS as Tt, gitHubReviewAdjudicationHostLayer as U, toStoredFinding as Un, MAX_REVIEW_CONTENT_CHARS as Ur, anchorViolation as Ut, gitHubPriorReviewsLayer as V, selectedPullRequestSourceLayer as Vn, ChangedFileStatus as Vr, rankAndDedupeFindings as Vt, gitHubReviewPublisherLayer as W, unavailableReviewStateAuthenticatorLayer as Wn, PatchLine as Wr, AUTHORIZED_ADJUDICATION_ASSOCIATIONS as Wt, ReviewRetirementDecision as X, FileDiffQuery as Xn, renderReviewContent as Xr, PriorReviewContext as Xt, RetirableReviewComment as Y, CodeReview as Yn, parsePatch as Yr, ParsedAdjudicationCommand as Yt, ReviewRetirementFailure as Z, FileDiffView as Zn, ReviewAdjudicationFailure as Zt, MAX_REVIEW_CHILDREN as _, ReviewHeadComparison as _n, ReviewInstructionOptions as _r, assessFlatReview as _t, FanOutPipelineInput as a, parseIssueAdjudication as an, MAX_CONCERNS as ar, ReviewCommentDraft as at, ReviewCandidate as b, ReviewSelection as bn, ReviewToolkitLayer as br, flatAssurance as bt, FileReviewEvidence as c, renderPriorFindingContextLine as cn, MAX_WALKTHROUGH_ENTRIES as cr, estimateReviewEffort as ct, FileReviewer as d, GitCommitSha as dn, REVIEW_TOOL_RESULT_MAX_BYTES as dr, renderAgentPrompt as dt, collectReviewAdjudications as en, FileSliceQuery as er, ReviewRetirementReport as et, FileReviewerBinding as f, MAX_REVIEW_STATE_MARKER_CHARS as fn, ReadFile as fr, CarriedScope as ft, MAX_FILE_REVIEW_TOOL_CALLS as g, ReviewExecutionContext as gn, ReviewGuidance as gr, ReviewInputCoverage as gt, MAX_CHILD_FINDINGS as h, MAX_STORED_UNREVIEWED_PATHS as hn, ReviewFinding as hr, ReviewAssurance as ht, FanOutInstructionOptions as i, noReviewAdjudicationHostLayer as in, ListChangedFilesQuery as ir, AGENT_PROMPT_PREAMBLE as it, reviewCandidateSubjectKey as j, adjudicationIdentity as jn, resolveGuidance as jr, ReviewPassId as jt, makeFileReviewerDefinition as k, StoredUnreviewedPass as kn, readFileDiffHandler as kr, ReviewEvidenceShard as kt, FileReviewReport as l, threadFindingTarget as ln, MAX_WALKTHROUGH_SUMMARY_CHARS as lr, planPublication as lt, MAX_CHILD_CONCERNS as m, MAX_STORED_UNREVIEWED_PASSES as mn, ReviewConcern as mr, FlatReviewAssessment as mt, ConcernCandidate as n, mergeAdjudications as nn, FindingSeverity as nr, hasReviewMetadataMarker as nt, FanOutPipelineOutcome as o, parseThreadAdjudication as on, MAX_FINDINGS as or, ReviewEvent as ot, FindingCandidate as p, MAX_STORED_ADJUDICATIONS as pn, ReadFileDiff as pr, FailedReviewPass as pt, INLINE_FINDING_TITLE_PATTERN as q, ChangedFileSummary as qn, hasReviewableContent as qr, DerivedAdjudications as qt, DiscoveredConcern as r, noReviewAdjudicationHost as rn, ListChangedFiles as rr, retireStaleReviews as rt, FileReviewBrief as s, renderAdjudicationContextLine as sn, MAX_PATCH_CHARS as sr, ReviewPublicationPlan as st, CandidateAssessment as t, deriveAdjudications as tn, FindingCategory as tr, decideReviewRetirement as tt, FileReviewToolkit as u, AdjudicationDisposition as un, PullRequestReviewer as ur, planWalkthrough as ut, MAX_UNIT_CANDIDATES as v, ReviewMode as vn, ReviewMission as vr, boundedListReason as vt, ReviewWorkPhase as w, ReviewStateMarker as wn, defaultReviewPolicy as wr, MAX_REVIEW_UNITS as wt, ReviewCandidateId as x, ReviewState as xn, ReviewVerdict as xr, splitCarriedScope as xt, REVIEW_UNIT_CONCURRENCY as y, ReviewScopeMode as yn, ReviewToolkit as yr, fanOutInputCoverage as yt, ReviewPublisher as z, isLineageAncestor as zn, normalizeRepoRelativePath as zr, planReviewUnits as zt };
+//# sourceMappingURL=fan-out-CMEsbFLk.d.mts.map