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

package/README.md

@@ -1,7 +1,7 @@
 # @effect-agent/pr-review
 
-A bounded, fail-closed GitHub pull-request reviewer built on the effect-agent
-public surface. Read-only Agents review host-partitioned pull-request evidence
+A bounded, fail-closed GitHub pull-request reviewer built on effect-agent's public APIs. Read-only
+Agents review host-partitioned pull-request evidence
 through typed ports; the host validates every finding anchor against the real
 diff and posts one review after the run settles.
 
@@ -15,6 +15,7 @@ truncated run posts nothing.
 import { Effect, Layer } from "effect";
 import {
   PrReview,
+  fullReviewExecutionContextLayer,
   gitHubReviewLayers,
   resolveReviewTarget,
   makeOpenAiReviewModel,
@@ -27,13 +28,22 @@ const program = Effect.gen(function* () {
   const target = yield* resolveReviewTarget({ repository: "acme/api", number: 123 });
   return yield* reviewer
     .run({ post: true })
-    .pipe(Effect.provide(Layer.merge(gitHubReviewLayers(target), openAiClientLayer)));
+    .pipe(
+      Effect.provide(
+        fullReviewExecutionContextLayer("explicit direct full review").pipe(
+          Layer.provideMerge(Layer.merge(gitHubReviewLayers(target), openAiClientLayer)),
+        ),
+      ),
+    );
 });
 ```
 
 The run's requirement channel keeps every real dependency visible: the
-`PullRequestSource` and `ReviewPublisher` ports, the provider client, and the
-handler Layer of any extra tool you add. Anthropic is equally supported
+`PullRequestSource`, `ReviewPublisher`, `ReviewAdjudicationHost`, and
+`ReviewExecutionContext` ports, the provider client, and the handler Layer of
+any extra tool you add. Direct callers provide an explicit full-review context
+as above; the packaged action supplies its selected incremental or full range.
+Anthropic is equally supported
 (`makeAnthropicReviewModel`, `anthropicClientLayer`), and the factory accepts
 any Effect AI Model.
 
@@ -53,44 +63,20 @@ const reviewer = PrReview.make({
 });
 ```
 
-Every knob widens what goes INTO the review. What leaves it is not
-configurable: model output is untrusted input, so finding anchors are
-re-validated against the parsed unified diff (invalid ones are demoted into
-the review body with the reason named, never trusted), the findings bound is
-enforced host-side, and publication happens only through the
-`ReviewPublisher` port after the run settles. `PrReview.makeFanOut` builds the
-assured host-scheduled variant. The host deterministically partitions bounded
-evidence, classifies high-risk units, requires a general discovery pass for
-every unit, adds a fresh specialist discovery pass for every unit, and uses
-deterministic host-classified risk categories as explicit focus labels. A
-fresh verifier must confirm or reject every discovered candidate. Every pass
-runs as a bounded evidence-only child dispatched directly by host code with
-Effect structured concurrency — there is no coordinator model and no
-delegation tool, so nothing depends on a model copying the plan correctly. A
-pass that fails (child fault, malformed or misdirected output) is retried
-once; a pass that stays failed is reported and its unit's paths carry forward
-as retryable scope. Verifiers receive the exact candidate claims and the
-complete bounded unit, including neighboring evidence that can falsify a
-locally plausible claim; they do not receive discovery reasoning.
-The host builds publishable findings and concerns from exact confirmed
-candidate IDs and deduplicates byte-identical cross-pass claims in
-deterministic plan order; a discovery claim anchored outside its assigned
-evidence is discarded and counted, never published and never pass-fatal. The
-summary and verdict are composed deterministically from the confirmed
-severities. Shared `guidance` reaches both discovery and verification;
-`maxFindings` remains a host-enforced publication cap.
-
-GitHub may omit the `patch` field for large textual files as well as binary
-files. The GitHub source recovers a missing patch by reading bounded, strict
-UTF-8 base/head content: additions require the head, deletions require the
-base, and other changes require both. Reviewers receive that content through
-the ordinary diff-read tool with non-anchorable `B`/`H` line labels and must
-report defects as review-body concerns. Invalid UTF-8, binary NUL content,
-missing sides, and files beyond the per-side read bound leave a path with no
-reviewable textual evidence. Such paths keep input coverage incomplete and are
-carried for as long as they are part of the pull request — an unreviewable
-change must never authorize a green check; exclude them deliberately with
-ignore globs when that is intended.
+Model output is untrusted. The host revalidates anchors, enforces `maxFindings`, and publishes only
+after the run settles. `PrReview.makeFanOut` partitions bounded evidence and schedules general and
+specialist discovery for every unit, followed by independent candidate verification. Verifiers
+receive the exact claims and enough neighboring evidence to reject a plausible mistake, but no
+discovery reasoning.
+
+Each failed pass retries once, then carries its unit forward. The host accepts only confirmed
+candidate IDs, discards anchors outside assigned evidence, deduplicates claims in plan order, and
+derives the verdict from validated severities. Shared `guidance` reaches discovery and verification.
+
+When GitHub omits a textual patch, the source reads bounded, strict UTF-8 base/head content and
+labels it with non-anchorable `B`/`H` lines. Invalid UTF-8, binary NUL content, missing sides, and
+oversized files remain unreviewable and keep input coverage incomplete. Exclude them with ignore
+globs only when that is intentional.
 
 ## Assurance model
 
@@ -117,51 +103,52 @@ favors redundant work, but it cannot recognize every semantically risky
 change. The specialist pass is context-independent redundancy, not a claim of
 provider or model diversity. Running it for every unit prevents classifier
 silence from suppressing scrutiny; the category labels still cannot prove
-that every semantic risk was recognized. The legacy aggregate `coverage` field remains
-for compatibility; new hosts and UI use `inputCoverage` and `assurance`.
+that every semantic risk was recognized. Hosts and UI use `inputCoverage` and `assurance`.
 The flat reviewer has path-input accounting but no independent verifier, so
 its assurance is `unverified` and the Action check cannot report success from
 that shape.
 
+## Maintainer adjudication
+
+A maintainer can settle a finding without changing code, from the pull request itself:
+
+- On a finding's inline thread, reply `/adjudicate accepted-risk|refuted|obsolete[: reason]`.
+  The thread names the target, so the verb alone suffices.
+- For an unanchored concern, comment
+  `/adjudicate <disposition> "<exact concern title>"[: reason]` in the PR conversation. The quoted
+  title is required and must match exactly.
+
+An adjudicated identity leaves active findings, verdict counts, and the check conclusion; it
+renders in a collapsed "Adjudicated" section instead, and the final audit distinguishes fixed,
+adjudicated, and still-open items. The reviewer prompt names each adjudication so the model does
+not re-raise it without materially new evidence. Identity is exact — path, line range, and title
+for findings, title alone for concerns — so a materially different finding at the same location is
+untouched. Adjudications persist in the signed review state, and the skip-unchanged path re-reads
+them, so an adjudication lifts a blocking check without a new commit.
+
+**Authorization is fail-closed**: only comments whose `author_association` is OWNER, MEMBER, or
+COLLABORATOR adjudicate. Anything else — third parties, bots, malformed commands — is ignored
+(logged at debug). Later adjudications of the same identity win by comment creation order, bounded
+at 20 stored entries (oldest dropped with a logged notice). If either GitHub listing surface fails,
+or one thread exceeds the bounded authorized-command history, fresh collection is discarded and
+the stored set stands unchanged.
+
+**Rejected alternative — parsing free-text rebuttals** ("this is fine because …" replies): only an
+explicit, authorized verb is auditable and fail-closed. Inferring intent from prose would let model
+output or third-party comments silently suppress findings, and nobody could later say which comment
+dismissed what.
+
 ## What a posted review looks like
 
-The body opens with a host-derived callout tier — `[!CAUTION]` when any
-finding is blocking, `[!IMPORTANT]` for important findings, an ℹ️ blockquote
-for nits, `✅` for a clean approval — computed from the validated severities,
-never from model prose. Directly under it, one host-derived stats line names
-the changeset size (`N files (+adds / −dels)`), the severity tally, and a
-deterministic 1–5 review-effort estimate computed from the changeset shape
-alone. Fan-out reviews add a second host-derived line naming input assignment,
-discovery/specialist/verification settlement, and candidate dispositions.
-Below the summary, a collapsed **📝 Walkthrough** table carries the
-model's one-sentence per-file change summaries — walkthrough paths are
-validated like finding anchors, so entries naming files outside the changeset
-are dropped. Under fan-out only summaries a
-successfully settled general pass actually reported for its own unit's paths
-survive, so a child cannot smuggle or invent entries. Non-anchored `concerns`
-(deletion plans, rollout sequencing,
-coverage gaps, scope questions — things with no diff line to point at) render
-as severity-tagged sections; demoted findings and findings carried from
-unchanged scope collapse into counted `<details>` sections.
-
-Each inline comment is headed by its severity plus an optional model-claimed
-category chip (`**[⚠️ important · security] …**`), carries a committable
-GitHub `suggestion` fence when independent verification settled the model's
-suggestion as committable replacement source, and ends with a
-collapsed **🤖 Prompt for AI agents** — a copy-paste instruction derived
-host-side from the validated finding, opening with a fixed preamble telling
-the receiving agent to treat the finding content as untrusted review data.
-The review body repeats every finding — anchored, demoted, and carried — in
-one consolidated prompt block so nothing needs to be collected by hand. The
-footer names the model binding, the observed token usage, and links to the
-workflow run; an invisible metadata comment pins the reviewed head commit so
-later readers know when line callouts have gone stale.
+The host derives callouts, statistics, walkthroughs, inline comments, and the final prompt from
+validated findings. Model prose cannot choose the verdict or smuggle paths outside the changeset.
+The [Action guide](../../action/README.md) documents the rendered review and workflow outputs.
 
 ## Swap a port
 
 Tools observe the pull request only through `PullRequestSource`; publication
 happens only through `ReviewPublisher`. Provide your own Layers to review
-anything diff-shaped or publish anywhere else — the GitHub REST adapters are
+any diff-shaped input or publish elsewhere. The GitHub REST adapters are
 one implementation, not the contract.
 
 ## Test what you adapted
@@ -176,131 +163,25 @@ import {
 ```
 
 Deterministic in-memory adapters for both ports plus prompt-keyed scripted
-models that walk the real tool surface — no network, no credentials, every
-ordinary gate.
-
-## Incremental Action reviews
-
-Every completed Action review that can be signed carries bounded, versioned,
-HMAC-authenticated continuity state: the exact PR/base/head lineage, profile
-and settled-scope fingerprints, the still-unresolved findings and concerns,
-any retryable unreviewed paths, and whether the run fully settled. The
-baseline is monotone by design — a flaky or failed pass carries exactly its
-own scope forward instead of freezing the baseline and reopening everything
-reviewed since (the non-converging loop of issue #131). A later Action run
-validates the state and reviews the GitHub comparison from that reviewed head
-to the current head plus the carried unreviewed paths, not the complete
-base...HEAD diff. When that head is not a git ancestor — a rebase, amend, or
-force-push — the host falls back to a two-dot tree comparison and reviews only
-the current PR paths whose contents actually changed, plus leftovers. Unchanged
-settled scope is not sent back to the model; unchanged unresolved findings
-remain active; changed or reverted paths invalidate their prior findings and
-receive fresh discovery and verification. An unchanged leftover from a failed
-pass retries only that failed stage and keeps its stored findings — it does
-not run a second general discovery.
-Whole overflow files are reviewed in bounded installments across pushes
-through the same carry; a single file beyond total plan capacity and
-undiffable paths stay explicitly incomplete instead — an unreviewable tail
-never moves behind a green check. Non-anchored concerns are carried conservatively
-until a full audit because they cannot be mapped safely to one path.
-
-The state marker must be terminal, signed with the configured stable
-`PR_REVIEW_STATE_SECRET`, authored by the configured review-posting bot, and
-pinned to the reviewed commit. The expected author defaults to
-`github-actions[bot]`; set `PR_REVIEW_AUTHOR_LOGIN` (or the Action's
-`review-author` input) to `<app-slug>[bot]` when posting with a custom GitHub
-App token. State lookup, authentication, schema, identity, ancestry, profile,
-and comparison checks are fail-closed for scope selection: missing, stale,
-incompatible, or truncated state/comparisons produce a visible full-diff
-fallback unless a two-dot content comparison can still name the changed PR
-paths. An ancestor base advance remains incremental and adds overlapping
-PR paths as affected context; a materially changed base lineage falls back to
-full unless the authenticated settled-scope fingerprint still matches or the
-content comparison intersects the current PR path set. The
-schema field retains the compatibility name `acceptedScopeFingerprint`. That
-fingerprint hashes the ignore-filtered effective diff, patchless base/head
-evidence, PR framing, and review-shaping profile while excluding commit IDs,
-base ancestry, and unified-diff hunk coordinates. Re-running the same head or a
-patch-equivalent rebase skips model execution by default ONLY when the stored
-state fully settled — a state carrying unreviewed scope is always retried.
-The preserved skip keeps its stored blocking/success conclusion and posts no
-duplicate review comments. Missing/corrupt state and any fingerprint or
-profile mismatch review conservatively.
-
-After a new state-bearing Action review posts, prior marker-bearing bot reviews
-are retired by default: their bodies become collapsed, superseded history,
-resolved findings are struck through, and matching inline comments are
-minimized as outdated. Only strictly older reviews from the same GitHub actor
-are eligible, so copied markers and newer concurrent reviews are untouched.
-The machine-state comments remain byte-identical and terminal, so an edited
-body still participates in incremental state recovery.
-This cosmetic pass is fail-open and can be disabled with the Action input
-`retire-stale-reviews: "false"`.
-
-Authentication is an explicit Effect service supplied by the Action host;
-WebCrypto import/sign/verify failures stay typed. The terminal marker is
-schema-branded and capped at 24,000 characters. If signing fails or state
-exceeds that bound, the completed review is posted without continuity state
-and with a bounded warning, so the next run safely performs a full review.
-
-`review-mode: final` is the explicit bounded merge-readiness audit. It ignores
-prior assurance state, plans fresh discovery over the full current PR
-diff, verifies new candidates, and resets the incremental baseline; normal
-`synchronize` events use `incremental` and do not perform this audit.
-Because equivalence is based on the textual review surface, a base change that
-alters runtime meaning without changing the diff/context is not detectable;
-request `final` mode (or disable unchanged skipping) for that case.
-
-## Hosts
-
-- **GitHub Actions**: the repository ships a prebuilt node-runtime action
-  supporting a committed review-profile document via `guidance-file` (this
-  repository's own profile lives at `.github/review-guidance.md`)
-  (`action/` at the repo root) — `uses` it with an API-key secret and nothing
-  else. Fan-out is the Action default because the flat compatibility shape
-  has no independent verifier and cannot settle review assurance. While a run executes it maintains one sticky, fail-open "review in
-  progress" comment updated in place with the settled outcome
-  (`progress-comment` input, default on; at-least-once with generation-fenced
-  writes and best-effort duplicate cleanup — strict single-comment behavior
-  comes from a per-PR workflow concurrency group), and its logs render one
-  compact line per event (`log-level` input, default `Info`). For custom reviewers in
-  CI, `@effect-agent/pr-review/action` exports `runReviewAction` (event
-  resolution, typed draft/non-PR skips, bounded range selection, step
-  outputs, and conservative check gate) to harness your own `reviewer.run`;
-  pass `progressComment: true` to opt a custom harness into the sticky
-  progress comment. A custom fingerprint-only harness remains source-compatible
-  but cannot skip model work: unchanged skipping requires the profile fingerprint
-  and authenticated state that prove the prior configured work settled.
-- **CLI**: `bun src/cli.ts --repo owner/name --pr 123 [--post] [--provider anthropic] [--fan-out]`
-  (also exported as the `./cli` entry).
-
-Environment: `OPENAI_API_KEY` or `ANTHROPIC_API_KEY` for the model,
-`PR_REVIEW_STATE_SECRET` to authenticate incremental state,
-`PR_REVIEW_AUTHOR_LOGIN` to match a custom review-posting bot (defaults to
-`github-actions[bot]`),
-`GITHUB_TOKEN` to post (optional for public-repository reads), and the
-standard `GITHUB_REPOSITORY` / `GITHUB_EVENT_PATH` / `GITHUB_API_URL`
-variables inside Actions.
+models that call the real Tools. Tests need no network or credentials and exercise every ordinary
+gate.
+
+## Action and CLI
+
+The prebuilt GitHub Action handles signed incremental state, fail-closed scope selection, sticky
+progress, stale-review retirement, and final audits. See its [setup and behavior guide](../../action/README.md)
+and [input reference](../../action/action.yml). Custom hosts can import `runReviewAction` from
+`@effect-agent/pr-review/action`.
+
+Run the CLI with
+`bun src/cli.ts --repo owner/name --pr 123 [--post] [--provider anthropic] [--fan-out]`.
 
 ## Bounds, spelled out
 
-Finite `AgentPolicy` on every definition plus run-level `UsageBudgetLimits`
-(tokens, tool calls, cost, duration). Reading either file version beyond 200k
-bytes or characters is refused typed; patchless content is reviewable only
-when its complete B/H rendering fits 220k characters. The changeset surface is
-bounded at 300 files:
-files beyond the bound are not fetched, and the review body reports
-`Input exposed N of M changed files` instead of claiming completeness.
-Fan-out capacity overflow is reported, never dropped. Every fan-out unit has
-at most 12 files, 12 complete evidence shards, and 240,000 evidence characters;
-one path may span multiple shards or units when necessary. If the eight-unit
-plan capacity is exhausted, every affected path and the exact shard count are
-reported, with a deterministic identifier sample bounded to one plan's capacity;
-at most eight units produce at most 24 attached children (general and
-specialist discovery plus one verification batch per unit), with child
-concurrency capped at four. Any blocking active finding fails the Action
-check. Any input gap—including an unassigned evidence shard—failed or
-exhausted configured pass, mismatched candidate batch, or unsettled
-verification is non-success rather than green. A settled
-clean result is evidence that these bounded passes completed, not proof that
-no defect exists.
+Every definition has a finite `AgentPolicy` and run-level `UsageBudgetLimits`. The reviewer rejects
+file versions beyond 200k bytes or characters and patchless B/H renderings beyond 220k characters.
+It reads at most 300 changed files. Each fan-out unit holds at most 12 files, 12 complete evidence
+shards, and 240,000 evidence characters. At most eight units produce 24 attached children with
+child concurrency capped at four. The result reports every capacity overflow. Any blocking
+finding, input gap, failed pass, exhausted pass, mismatched candidate batch, or unsettled
+verification prevents a green check.

package/dist/action.d.mts

@@ -1,4 +1,4 @@
-import { L as PriorReviews, P as GitHubApiFailure, X as ReviewRetirementHost, cr as PullRequestSource, fr as ChangedFile, gt as ReviewMode, lr as PullRequestSourceFailure, sr as PullRequestMetadata, xt as ReviewStateAuthenticator, z as ReviewPublisher } from "./fan-out-Bi1v0VaU.mjs";
+import { Br as ChangedFile, Cn as ReviewStateAuthenticator, Fr as PullRequestMetadata, Ir as PullRequestSource, L as PriorReviews, Lr as PullRequestSourceFailure, P as GitHubApiFailure, Q as ReviewRetirementHost, Qt as ReviewAdjudicationHost, gn as ReviewExecutionContext, vn as ReviewMode, z as ReviewPublisher } from "./fan-out-CMEsbFLk.mjs";
 import { EffortPosition, InvalidEffortInput, ReviewProgressReporter, ReviewProvider, ReviewRunOutcome, ReviewTargetUnresolved, RunReviewOptions } from "./index.mjs";
 import { Config, Effect, FileSystem, Schema } from "effect";
 import { BudgetExceeded } from "effect-agent";
@@ -92,29 +92,38 @@ type ReviewActionResult = {
  * The reviewer surface the action harness drives. `PrReview.make` and
  * `PrReview.makeFanOut` provide the state-selection effects. A fingerprint is
  * skip authority only when a profile fingerprint and authenticated review
- * state bind it to settled assurance; a fingerprint-only custom harness
- * remains source-compatible but deliberately runs instead of claiming green
- * assurance from unauthenticated prior-review text.
+ * state bind it to settled assurance.
  */
-interface HarnessedReviewer<E, R, FingerprintE, FingerprintR> {
-  readonly run: (runOptions?: RunReviewOptions) => Effect.Effect<ReviewRunOutcome, E, R>;
+interface HarnessedReviewerBase<E, R> {
+  /** The action composition root always supplies the selected run context. */
+  readonly run: (runOptions?: RunReviewOptions) => Effect.Effect<ReviewRunOutcome, E, R | ReviewExecutionContext>;
+}
+type HarnessedReviewer<E, R, FingerprintE, FingerprintR> = HarnessedReviewerBase<E, R> & ({
+  readonly fingerprint?: undefined;
+  readonly profileFingerprint?: undefined;
+  readonly snapshot?: undefined;
+  readonly filterFiles?: undefined;
+} | {
   /** Current effective changeset fingerprint; not standalone skip authority. */
-  readonly fingerprint?: Effect.Effect<string, FingerprintE, FingerprintR> | undefined;
-  readonly profileFingerprint?: Effect.Effect<string, FingerprintE, FingerprintR> | undefined;
-  readonly snapshot?: Effect.Effect<{
+  readonly fingerprint: Effect.Effect<string, FingerprintE, FingerprintR>;
+  readonly profileFingerprint: Effect.Effect<string, FingerprintE, FingerprintR>;
+  readonly snapshot: Effect.Effect<{
     readonly metadata: PullRequestMetadata;
     readonly files: ReadonlyArray<ChangedFile>;
-  }, FingerprintE, FingerprintR> | undefined;
+  }, FingerprintE, FingerprintR>;
   readonly filterFiles?: ((files: ReadonlyArray<ChangedFile>) => ReadonlyArray<ChangedFile>) | undefined;
-}
+});
 /**
  * Host-derived check conclusion; model verdict prose cannot weaken it.
  *
  * Blocking code findings outrank machinery gaps — they are the actionable
- * signal. A machinery gap (incomplete input, unsettled passes) concludes
- * `incomplete` with reasons that explicitly say the failure is reviewer-side
- * uncertainty carried forward for retry, never an invitation to change code.
- * The flat reviewer's constant `unverified` assurance is not a gap.
+ * signal. A retryable machinery gap (failed passes, capacity overflow)
+ * concludes `incomplete` with reasons that explicitly say the failure is
+ * reviewer-side uncertainty carried forward for retry, never an invitation to
+ * change code. Undiffable files are the deliberate exception: no retry can
+ * settle them, so their reason instructs removal or ignore globs instead of
+ * promising an automatic retry. The flat reviewer's constant `unverified`
+ * assurance is not a gap.
  */
 declare const concludeReviewOutcome: (outcome: ReviewRunOutcome) => {
   readonly conclusion: ReviewCheckConclusion;
@@ -154,7 +163,7 @@ declare const runReviewAction: <E, R, FingerprintE = never, FingerprintR = never
 } | {
   _tag: "Completed";
   outcome: ReviewRunOutcome;
-}, E | FingerprintE | Config.ConfigError | import("effect/PlatformError").PlatformError | PullRequestSourceFailure | ReviewGateFailed | ReviewTargetUnresolved, FileSystem.FileSystem | import("effect/unstable/http/HttpClient").HttpClient | ReviewStateAuthenticator | Exclude<FingerprintR, PriorReviews | PullRequestSource | ReviewProgressReporter | ReviewPublisher | ReviewRetirementHost> | Exclude<R, PriorReviews | PullRequestSource | ReviewProgressReporter | ReviewPublisher | ReviewRetirementHost>>;
+}, E | FingerprintE | Config.ConfigError | import("effect/PlatformError").PlatformError | PullRequestSourceFailure | ReviewGateFailed | ReviewTargetUnresolved, FileSystem.FileSystem | import("effect/unstable/http/HttpClient").HttpClient | ReviewStateAuthenticator | Exclude<FingerprintR, PriorReviews | PullRequestSource | ReviewAdjudicationHost | ReviewProgressReporter | ReviewPublisher | ReviewRetirementHost> | Exclude<Exclude<R, PullRequestSource | ReviewExecutionContext>, PriorReviews | PullRequestSource | ReviewAdjudicationHost | ReviewProgressReporter | ReviewPublisher | ReviewRetirementHost>>;
 /**
  * The packaged, environment-driven action program: inputs from PR_REVIEW_*,
  * reviewer built from the packaged factory, provider client from the

package/dist/action.mjs

@@ -1,5 +1,5 @@
-import { D as ReviewHeadComparison, E as ReviewExecutionContext, H as isLineageAncestor, J as validateReviewState, M as ReviewStateAuthenticator, U as selectReviewRange, W as selectedPullRequestSourceLayer, Xn as normalizeRepoRelativePath, Y as webCryptoReviewStateAuthenticatorLayer, a as PriorReviews, q as unavailableReviewStateAuthenticatorLayer, qn as PullRequestSource, x as retireStaleReviews } from "./github-C6jrBLA2.mjs";
-import { A as reviewBudgetLimits, C as PrReview, H as InvalidEffortInput, W as parseEffortPosition, a as anthropicClientLayer, c as makeOpenAiReviewModel, f as gitHubReviewLayers, g as ReviewProgressReporter, k as fanOutReviewBudgetLimits, l as openAiClientLayer, m as resolveReviewTarget, n as DEFAULT_PROVIDER, o as describeReviewModel, p as readGitHubEvent, s as makeAnthropicReviewModel } from "./providers-2Jao2ZAX.mjs";
+import { An as validateReviewState, Cn as fullReviewSelection, En as selectedPullRequestSourceLayer, St as splitCarriedScope, Tn as selectReviewRange, Yt as retireStaleReviews, a as PriorReviews, cn as ReviewStateAuthenticator, gn as adjudicationIdentity, jn as webCryptoReviewStateAuthenticatorLayer, jt as collectReviewAdjudications, kn as unavailableReviewStateAuthenticatorLayer, nn as ReviewExecutionContext, rn as ReviewHeadComparison, vn as concernIdentity, vr as PullRequestSource, wn as isLineageAncestor, xr as normalizeRepoRelativePath, yn as findingIdentity } from "./github-NjgxGqwM.mjs";
+import { A as reviewBudgetLimits, C as PrReview, H as InvalidEffortInput, W as parseEffortPosition, a as anthropicClientLayer, c as makeOpenAiReviewModel, f as gitHubReviewLayers, g as ReviewProgressReporter, k as fanOutReviewBudgetLimits, l as openAiClientLayer, m as resolveReviewTarget, n as DEFAULT_PROVIDER, o as describeReviewModel, p as readGitHubEvent, s as makeAnthropicReviewModel } from "./providers-CODZQCmL.mjs";
 import { n as compactReviewLoggingLayer } from "./logging-Q4j0oub-.mjs";
 import { Config, Console, Effect, FileSystem, Layer, Option, Redacted, Schema } from "effect";
 import { BudgetExceeded, UsageBudgetLimits } from "effect-agent";
@@ -127,7 +127,6 @@ const outcomeOutputs = (outcome, conclusion) => [
 	["verdict", outcome.review.verdict],
 	["input-coverage", outcome.inputCoverage.status],
 	["review-assurance", outcome.assurance.status],
-	["coverage", outcome.coverage.status],
 	["review-mode", outcome.reviewMode ?? "full"],
 	["review-reason", outcome.reviewReason ?? "direct full review"],
 	["inline-comments", String(outcome.plan.comments.length)],
@@ -137,18 +136,22 @@ const outcomeOutputs = (outcome, conclusion) => [
 	...outcome.usage === void 0 ? [] : [["input-tokens", String(outcome.usage.inputTokens)], ["output-tokens", String(outcome.usage.outputTokens)]],
 	["review-url", outcome.published?.url ?? ""]
 ];
-const outcomeSummary = (outcome, modelLabel, conclusion) => [
-	"### Pull-request review",
-	`- Check conclusion: **${conclusion}**`,
-	`- Verdict: **${outcome.review.verdict}**`,
-	`- Input coverage: **${outcome.inputCoverage.status}** · scope: ${outcome.reviewMode ?? "full"}`,
-	`- Review assurance: **${outcome.assurance.status}** · general discovery ${outcome.assurance.completedGeneralDiscoveryPasses}/${outcome.assurance.requiredGeneralDiscoveryPasses} · specialist ${outcome.assurance.completedSpecialistPasses}/${outcome.assurance.requiredSpecialistPasses} · verification ${outcome.assurance.completedVerificationPasses}/${outcome.assurance.requiredVerificationPasses}`,
-	`- Inline comments: ${outcome.plan.comments.length} · demoted findings: ${outcome.plan.demoted.length} · concerns: ${outcome.review.concerns?.length ?? 0}`,
-	...outcome.unreviewedPaths.length === 0 ? [] : [`- Carried forward: ${outcome.unreviewedPaths.length} unreviewed path(s) retried automatically on the next run (reviewer-side gap, not a code defect)`],
-	...modelLabel === void 0 ? [] : [`- Model: \`${modelLabel}\``],
-	...outcome.usage === void 0 ? [] : [`- Tokens: ${outcome.usage.inputTokens} in / ${outcome.usage.outputTokens} out`],
-	...outcome.published === void 0 ? ["- Dry run: nothing posted"] : [`- Posted: ${outcome.published.url}`]
-];
+const outcomeSummary = (outcome, modelLabel, conclusion) => {
+	const scope = splitCarriedScope(outcome);
+	return [
+		"### Pull-request review",
+		`- Check conclusion: **${conclusion}**`,
+		`- Verdict: **${outcome.review.verdict}**`,
+		`- Input coverage: **${outcome.inputCoverage.status}** · scope: ${outcome.reviewMode ?? "full"}`,
+		`- Review assurance: **${outcome.assurance.status}** · general discovery ${outcome.assurance.completedGeneralDiscoveryPasses}/${outcome.assurance.requiredGeneralDiscoveryPasses} · specialist ${outcome.assurance.completedSpecialistPasses}/${outcome.assurance.requiredSpecialistPasses} · verification ${outcome.assurance.completedVerificationPasses}/${outcome.assurance.requiredVerificationPasses}`,
+		`- Inline comments: ${outcome.plan.comments.length} · demoted findings: ${outcome.plan.demoted.length} · concerns: ${outcome.review.concerns?.length ?? 0}`,
+		...scope.retryablePaths.length === 0 ? [] : [`- Carried forward: ${scope.retryablePaths.length} unreviewed path(s) retried automatically on the next run (reviewer-side gap, not a code defect)`],
+		...scope.undiffablePaths.length === 0 ? [] : [`- Unreviewable: ${scope.undiffablePaths.length} path(s) with no reviewable diff (binary or oversized) — remove them from the pull request or exclude them with ignore globs`],
+		...modelLabel === void 0 ? [] : [`- Model: \`${modelLabel}\``],
+		...outcome.usage === void 0 ? [] : [`- Tokens: ${outcome.usage.inputTokens} in / ${outcome.usage.outputTokens} out`],
+		...outcome.published === void 0 ? ["- Dry run: nothing posted"] : [`- Posted: ${outcome.published.url}`]
+	];
+};
 const skip = (reason) => Effect.gen(function* () {
 	yield* Console.log(`Skipping review: ${reason}`);
 	yield* writeActionOutputs([["skipped", "true"], ["skip-reason", reason]]);
@@ -170,15 +173,20 @@ const blockingReasons = (input) => [...input.findings.filter((finding) => findin
 * Host-derived check conclusion; model verdict prose cannot weaken it.
 *
 * Blocking code findings outrank machinery gaps — they are the actionable
-* signal. A machinery gap (incomplete input, unsettled passes) concludes
-* `incomplete` with reasons that explicitly say the failure is reviewer-side
-* uncertainty carried forward for retry, never an invitation to change code.
-* The flat reviewer's constant `unverified` assurance is not a gap.
+* signal. A retryable machinery gap (failed passes, capacity overflow)
+* concludes `incomplete` with reasons that explicitly say the failure is
+* reviewer-side uncertainty carried forward for retry, never an invitation to
+* change code. Undiffable files are the deliberate exception: no retry can
+* settle them, so their reason instructs removal or ignore globs instead of
+* promising an automatic retry. The flat reviewer's constant `unverified`
+* assurance is not a gap.
 */
 const concludeReviewOutcome = (outcome) => {
 	const machinery = [];
 	if (outcome.inputCoverage.status === "incomplete" || outcome.assurance.status === "incomplete") {
-		machinery.push(outcome.unreviewedPaths.length > 0 ? `review infrastructure did not settle — a reviewer-side gap, not a code defect; ${outcome.unreviewedPaths.length} path(s) are carried forward and retried automatically on the next run` : "review infrastructure did not settle — a reviewer-side gap, not a code defect");
+		const scope = splitCarriedScope(outcome);
+		if (scope.retryableGap) machinery.push(scope.retryablePaths.length > 0 ? `review infrastructure did not settle — a reviewer-side gap, not a code defect; ${scope.retryablePaths.length} path(s) are carried forward and retried automatically on the next run` : "review infrastructure did not settle — a reviewer-side gap, not a code defect");
+		if (scope.undiffablePaths.length > 0) machinery.push(`${scope.undiffablePaths.length} path(s) have no reviewable diff (binary or oversized) and no retry can settle them — remove them from the pull request or exclude them with ignore globs`);
 		if (outcome.inputCoverage.status === "incomplete") machinery.push(...outcome.inputCoverage.reasons);
 		if (outcome.assurance.status === "incomplete") machinery.push(...outcome.assurance.reasons);
 	}
@@ -199,10 +207,10 @@ const concludeReviewOutcome = (outcome) => {
 		reasons: []
 	};
 };
-const concludeReviewState = (state) => {
+const concludeReviewState = (state, adjudicated) => {
 	const reasons = blockingReasons({
-		findings: state.unresolvedFindings,
-		concerns: state.unresolvedConcerns
+		findings: state.unresolvedFindings.filter((finding) => !adjudicated.has(findingIdentity(finding))),
+		concerns: state.unresolvedConcerns.filter((concern) => !adjudicated.has(concernIdentity(concern)))
 	});
 	return reasons.length > 0 ? {
 		conclusion: "blocking",
@@ -213,16 +221,15 @@ const concludeReviewState = (state) => {
 	};
 };
 const skipCoveredReview = Effect.fn("skipCoveredReview")(function* (input) {
-	const result = concludeReviewState(input.state);
+	const adjudications = yield* collectReviewAdjudications(input.state.adjudications ?? []);
+	const result = concludeReviewState(input.state, new Set(adjudications.map(adjudicationIdentity)));
 	yield* Console.log(`Skipping review of ${input.repository}#${input.pullRequestNumber}: ${input.reason}.`);
 	yield* writeActionOutputs([
 		["skipped", "true"],
 		["skip-reason", input.reason],
-		...input.fingerprint === void 0 ? [] : [["fingerprint", input.fingerprint]],
 		["conclusion", result.conclusion],
 		["input-coverage", "complete"],
 		["review-assurance", "settled"],
-		["coverage", "complete"],
 		["review-mode", "incremental"]
 	]);
 	yield* writeStepSummary([
@@ -258,14 +265,10 @@ const runReviewAction = (reviewer, options = {}) => Effect.gen(function* () {
 	return yield* Effect.gen(function* () {
 		let selection;
 		if (reviewer.profileFingerprint !== void 0) {
-			const source = yield* PullRequestSource;
 			const [snapshot, profileFingerprint, currentFingerprint] = yield* Effect.all([
-				reviewer.snapshot ?? Effect.all({
-					metadata: source.metadata,
-					files: source.anchorFiles
-				}),
+				reviewer.snapshot,
 				reviewer.profileFingerprint,
-				reviewer.fingerprint === void 0 ? Effect.succeed(void 0) : reviewer.fingerprint.pipe(Effect.map((fingerprint) => fingerprint), Effect.orElseSucceed(() => void 0))
+				reviewer.fingerprint.pipe(Effect.map((fingerprint) => fingerprint), Effect.orElseSucceed(() => void 0))
 			]);
 			const { metadata, files: fullFiles } = snapshot;
 			const history = options.priorReviews ?? (yield* PriorReviews);
@@ -283,13 +286,12 @@ const runReviewAction = (reviewer, options = {}) => Effect.gen(function* () {
 					failure: void 0
 				})
 			}));
-			const equivalentPatchState = (options.reviewMode ?? "incremental") === "incremental" && options.skipUnchanged !== false && recovered.state !== void 0 && recovered.state.settled && currentFingerprint !== void 0 && validateReviewState(recovered.state, metadata, profileFingerprint) === void 0 && recovered.state.acceptedScopeFingerprint === currentFingerprint ? recovered.state : void 0;
+			const equivalentPatchState = (options.reviewMode ?? "incremental") === "incremental" && options.skipUnchanged !== false && recovered.state !== void 0 && recovered.state.settled && currentFingerprint !== void 0 && validateReviewState(recovered.state, metadata, profileFingerprint) === void 0 && recovered.state.settledScopeFingerprint === currentFingerprint ? recovered.state : void 0;
 			if (equivalentPatchState !== void 0) return yield* skipCoveredReview({
 				repository: target.repository,
 				pullRequestNumber: target.number,
 				reason: equivalentPatchState.reviewedHeadSha === metadata.headSha ? "the current head already has settled stored review assurance" : "the effective pull-request patch is unchanged since the last settled review",
-				state: equivalentPatchState,
-				fingerprint: currentFingerprint
+				state: equivalentPatchState
 			});
 			let comparison;
 			let baseComparison;
@@ -346,6 +348,15 @@ const runReviewAction = (reviewer, options = {}) => Effect.gen(function* () {
 				state: selection.priorState
 			});
 		}
+		const executionContext = selection ?? (yield* Effect.gen(function* () {
+			const source = yield* PullRequestSource;
+			const [metadata, files] = yield* Effect.all([source.metadata, source.changedFiles]);
+			return fullReviewSelection({
+				reason: "explicit custom-reviewer full review without continuity selection",
+				files,
+				totalFiles: metadata.totalChangedFiles
+			});
+		}));
 		yield* Console.log(`Reviewing ${target.repository}#${target.number} (${options.post === false ? "dry run" : "posting"})...`);
 		const runUrl = yield* resolveRunUrl();
 		const progress = options.progressComment === true && options.post !== false ? Option.some(yield* ReviewProgressReporter) : Option.none();
@@ -353,9 +364,9 @@ const runReviewAction = (reviewer, options = {}) => Effect.gen(function* () {
 			const headMetadata = yield* (yield* PullRequestSource).metadata.pipe(Effect.orElseSucceed(() => void 0));
 			yield* progress.value.begin({
 				headSha: headMetadata?.headSha,
-				reviewMode: selection?.mode,
-				reviewReason: selection?.reason,
-				filesInScope: selection?.files.length,
+				reviewMode: executionContext.mode,
+				reviewReason: executionContext.reason,
+				filesInScope: executionContext.files.length,
 				modelLabel: options.modelLabel,
 				runUrl
 			});
@@ -369,7 +380,8 @@ const runReviewAction = (reviewer, options = {}) => Effect.gen(function* () {
 			runUrl,
 			modelLabel: options.modelLabel
 		}))) : runReview;
-		const outcome = yield* selection === void 0 ? reviewEffect : reviewEffect.pipe(Effect.provide(selectedPullRequestSourceLayer(selection)), Effect.provideService(ReviewExecutionContext, selection));
+		const executionLayer = Layer.merge(Layer.succeed(ReviewExecutionContext)(executionContext), selectedPullRequestSourceLayer(executionContext));
+		const outcome = yield* reviewEffect.pipe(Effect.provide(executionLayer));
 		yield* Console.log(`Review finished in ${outcome.turns} turn(s): verdict ${outcome.review.verdict}, ${outcome.plan.comments.length} inline comment(s), ${outcome.plan.demoted.length} demoted finding(s).`);
 		if (outcome.published !== void 0) {
 			yield* Console.log(`Posted ${outcome.published.event} review: ${outcome.published.url}`);