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

package/src/internal/github.ts

@@ -11,7 +11,7 @@ import {
   ReviewAdjudicationFailure,
   ReviewAdjudicationHost,
 } from "./adjudication.ts";
-import { ChangedFile } from "./diff.ts";
+import { ChangedFile, ChangedPath } from "./diff.ts";
 import { extractFingerprint } from "./fingerprint.ts";
 import type { ReviewPublicationPlan } from "./render.ts";
 import {
@@ -21,8 +21,11 @@ import {
   ReviewRetirementHost,
 } from "./retirement.ts";
 import {
+  GitCommitSha,
+  MAX_TREE_COMPARISON_PATHS,
   ReviewHeadComparison,
   ReviewStateAuthenticator,
+  ReviewTreeComparison,
   type ReviewState,
 } from "./review-state.ts";
 import {
@@ -884,14 +887,15 @@ export class PriorReviews extends Context.Service<
       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.
+     * Compare complete commit tree snapshots for a bounded path allowlist.
+     * Used when the reviewed head is not a git ancestor after a rebase,
+     * amend, or force-push.
      */
     readonly compareTrees: (
       baseSha: string,
       headSha: string,
-    ) => Effect.Effect<ReviewHeadComparison, PriorReviewLookupFailure>;
+      paths: ReadonlyArray<string>,
+    ) => Effect.Effect<ReviewTreeComparison, PriorReviewLookupFailure>;
   }
 >()("@effect-agent/pr-review/PriorReviews") {}
 
@@ -916,6 +920,45 @@ const GitHubCompareWire = Schema.Struct({
   files: GitHubFilesPageWire,
 });
 
+const GitHubGitCommitWire = Schema.Struct({
+  sha: GitCommitSha,
+  tree: Schema.Struct({ sha: GitCommitSha }),
+});
+
+const GitHubTreeEntryFields = {
+  path: Schema.String.check(Schema.isMaxLength(4_096)),
+  sha: GitCommitSha,
+} as const;
+
+const GitHubTreeEntryWire = Schema.Union([
+  Schema.Struct({
+    ...GitHubTreeEntryFields,
+    mode: Schema.Literals(["100644", "100755", "120000"]),
+    type: Schema.Literal("blob"),
+  }),
+  Schema.Struct({
+    ...GitHubTreeEntryFields,
+    mode: Schema.Literal("040000"),
+    type: Schema.Literal("tree"),
+  }),
+  Schema.Struct({
+    ...GitHubTreeEntryFields,
+    mode: Schema.Literal("160000"),
+    type: Schema.Literal("commit"),
+  }),
+]);
+
+const MAX_RECURSIVE_TREE_ENTRIES = 100_000;
+const GitHubTreeWire = Schema.Struct({
+  sha: GitCommitSha,
+  tree: Schema.Array(GitHubTreeEntryWire).check(Schema.isMaxLength(MAX_RECURSIVE_TREE_ENTRIES)),
+  truncated: Schema.Boolean,
+});
+
+const TreeComparisonPaths = Schema.Array(ChangedPath).check(
+  Schema.isMaxLength(MAX_TREE_COMPARISON_PATHS),
+);
+
 /** Reviews are paged chronologically; scanning stays bounded. */
 const MAX_PRIOR_REVIEW_PAGES = 5;
 
@@ -935,6 +978,24 @@ export const gitHubPriorReviewsLayer: Layer.Layer<
       PriorReviewLookupFailure.make({
         reason: `${error._tag}: ${error.message ?? "request failed"}`.slice(0, 2_048),
       });
+    const asTreeLookupFailure =
+      (operation: string) => (error: { readonly _tag: string; readonly message?: string }) =>
+        PriorReviewLookupFailure.make({
+          reason: `${operation}: ${error._tag}: ${error.message ?? "request failed"}`.slice(
+            0,
+            2_048,
+          ),
+        });
+    const decodeLookupJson = <S extends Schema.Top>(schema: S, operation: string) => {
+      const decode = Schema.decodeUnknownEffect(schema);
+      return (response: HttpClientResponse.HttpClientResponse) =>
+        response.json.pipe(
+          Effect.mapError(asTreeLookupFailure(operation)),
+          Effect.flatMap((body) =>
+            decode(body).pipe(Effect.mapError(asTreeLookupFailure(operation))),
+          ),
+        );
+    };
     const readMarkers = (authenticator: Option.Option<ReviewStateAuthenticator["Service"]>) =>
       Effect.gen(function* () {
         const perPage = 100;
@@ -995,12 +1056,12 @@ export const gitHubPriorReviewsLayer: Layer.Layer<
         }
         return { latestFingerprint: latest, latestState };
       }).pipe(Effect.provideService(HttpClient.HttpClient, client));
-    const compareCommits = (baseSha: string, headSha: string, separator: "..." | "..") =>
+    const compareCommits = (baseSha: string, headSha: string) =>
       Effect.gen(function* () {
         const response = yield* HttpClient.execute(
           withCommonHeaders(
             HttpClientRequest.get(
-              `${target.apiUrl}/repos/${target.repository}/compare/${encodeURIComponent(baseSha)}${separator}${encodeURIComponent(headSha)}`,
+              `${target.apiUrl}/repos/${target.repository}/compare/${encodeURIComponent(baseSha)}...${encodeURIComponent(headSha)}`,
             ).pipe(HttpClientRequest.acceptJson),
             target.token,
           ),
@@ -1023,21 +1084,107 @@ export const gitHubPriorReviewsLayer: Layer.Layer<
           truncated: files.length >= MAX_CHANGED_FILES,
         });
       }).pipe(Effect.provideService(HttpClient.HttpClient, client));
-    const compareTrees = (baseSha: string, headSha: string) =>
-      compareCommits(baseSha, headSha, "..").pipe(
-        Effect.map((comparison) =>
-          ReviewHeadComparison.make({
-            // This is a content snapshot, not a lineage claim. Selection
-            // intersects these files with the current PR path set.
-            status: comparison.status === "identical" ? "identical" : "ahead",
-            baseSha,
-            headSha,
-            mergeBaseSha: baseSha,
-            files: comparison.files,
-            truncated: comparison.truncated,
-          }),
-        ),
+    const readTreeSnapshot = Effect.fn("PriorReviews.readTreeSnapshot")(function* (
+      commitSha: string,
+    ) {
+      const commitResponse = yield* client
+        .execute(
+          withCommonHeaders(
+            HttpClientRequest.get(
+              `${target.apiUrl}/repos/${target.repository}/git/commits/${encodeURIComponent(commitSha)}`,
+            ).pipe(HttpClientRequest.acceptJson),
+            target.token,
+          ),
+        )
+        .pipe(
+          Effect.flatMap(HttpClientResponse.filterStatusOk),
+          Effect.mapError(asTreeLookupFailure("get Git commit")),
+        );
+      const commit = yield* decodeLookupJson(
+        GitHubGitCommitWire,
+        "decode Git commit",
+      )(commitResponse);
+      if (commit.sha !== commitSha) {
+        return yield* PriorReviewLookupFailure.make({
+          reason: `GitHub returned commit ${commit.sha} for requested snapshot ${commitSha}`,
+        });
+      }
+      const treeResponse = yield* client
+        .execute(
+          withCommonHeaders(
+            HttpClientRequest.get(
+              `${target.apiUrl}/repos/${target.repository}/git/trees/${encodeURIComponent(commit.tree.sha)}`,
+            ).pipe(
+              HttpClientRequest.acceptJson,
+              HttpClientRequest.setUrlParams({ recursive: "1" }),
+            ),
+            target.token,
+          ),
+        )
+        .pipe(
+          Effect.flatMap(HttpClientResponse.filterStatusOk),
+          Effect.mapError(asTreeLookupFailure("get recursive Git tree")),
+        );
+      const tree = yield* decodeLookupJson(
+        GitHubTreeWire,
+        "decode recursive Git tree",
+      )(treeResponse);
+      if (tree.sha !== commit.tree.sha) {
+        return yield* PriorReviewLookupFailure.make({
+          reason: `GitHub returned tree ${tree.sha} for requested tree ${commit.tree.sha}`,
+        });
+      }
+      const entries = new Map<string, typeof GitHubTreeEntryWire.Type>();
+      for (const entry of tree.tree) {
+        if (entries.has(entry.path)) {
+          return yield* PriorReviewLookupFailure.make({
+            reason: `GitHub returned duplicate path '${entry.path}' in tree ${tree.sha}`,
+          });
+        }
+        entries.set(entry.path, entry);
+      }
+      return { entries, truncated: tree.truncated } as const;
+    });
+    const compareTrees = Effect.fn("PriorReviews.compareTrees")(function* (
+      baseSha: string,
+      headSha: string,
+      paths: ReadonlyArray<string>,
+    ) {
+      const decodeSha = Schema.decodeUnknownEffect(GitCommitSha);
+      const [validatedBaseSha, validatedHeadSha, validatedPaths] = yield* Effect.all([
+        decodeSha(baseSha),
+        decodeSha(headSha),
+        Schema.decodeUnknownEffect(TreeComparisonPaths)(paths),
+      ]).pipe(Effect.mapError(asTreeLookupFailure("validate tree comparison request")));
+      const uniquePaths = [...new Set(validatedPaths)].sort();
+      const { base, head } = yield* Effect.all(
+        {
+          base: readTreeSnapshot(validatedBaseSha),
+          head: readTreeSnapshot(validatedHeadSha),
+        },
+        { concurrency: 2 },
       );
+      if (base.truncated || head.truncated) {
+        return ReviewTreeComparison.make({
+          baseSha: validatedBaseSha,
+          headSha: validatedHeadSha,
+          changedPaths: [],
+          truncated: true,
+        });
+      }
+      const changedPaths = uniquePaths.filter((path) => {
+        const before = base.entries.get(path);
+        const after = head.entries.get(path);
+        if (before === undefined || after === undefined) return before !== after;
+        return before.sha !== after.sha || before.mode !== after.mode || before.type !== after.type;
+      });
+      return ReviewTreeComparison.make({
+        baseSha: validatedBaseSha,
+        headSha: validatedHeadSha,
+        changedPaths,
+        truncated: false,
+      });
+    });
     return PriorReviews.of({
       latestFingerprint: readMarkers(Option.none()).pipe(
         Effect.map((markers) => markers.latestFingerprint),
@@ -1048,7 +1195,7 @@ export const gitHubPriorReviewsLayer: Layer.Layer<
           Effect.map((markers) => markers.latestState),
         );
       }),
-      compareHeads: (baseSha, headSha) => compareCommits(baseSha, headSha, "..."),
+      compareHeads: compareCommits,
       compareTrees,
     });
   }),

package/src/internal/providers.ts

@@ -1,6 +1,6 @@
 import { AnthropicClient, AnthropicLanguageModel } from "@effect/ai-anthropic";
 import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai";
-import { Config, Layer } from "effect";
+import { Config, Effect, Layer, Schema } from "effect";
 import { FetchHttpClient } from "effect/unstable/http";
 
 import { resolveEffortRung, type EffortAliasName, type EffortPosition } from "./effort.ts";
@@ -14,7 +14,36 @@ import { resolveEffortRung, type EffortAliasName, type EffortPosition } from "./
 // application supplies them at the edge (D-027).
 // ---------------------------------------------------------------------------
 
-export type ReviewProvider = "openai" | "anthropic";
+export const ReviewProvider = Schema.Literals(["openai", "anthropic"]);
+export type ReviewProvider = typeof ReviewProvider.Type;
+
+/** OpenAI Responses service tiers supported by the packaged reviewer. */
+export const OpenAiServiceTier = Schema.Literal("fast");
+export type OpenAiServiceTier = typeof OpenAiServiceTier.Type;
+
+/** A provider-specific OpenAI tier was configured for another provider. */
+export class UnsupportedServiceTierProvider extends Schema.TaggedError<UnsupportedServiceTierProvider>()(
+  "UnsupportedServiceTierProvider",
+  {
+    provider: ReviewProvider,
+    serviceTier: OpenAiServiceTier,
+  },
+) {
+  override get message() {
+    return `Service tier '${this.serviceTier}' requires provider 'openai'; received '${this.provider}'.`;
+  }
+}
+
+/** Reject an OpenAI-only service tier before constructing another provider's model. */
+export const validateReviewServiceTier = Effect.fn("validateReviewServiceTier")(function* (
+  provider: ReviewProvider,
+  serviceTier: OpenAiServiceTier | undefined,
+): Effect.fn.Return<OpenAiServiceTier | undefined, UnsupportedServiceTierProvider> {
+  if (serviceTier !== undefined && provider !== "openai") {
+    return yield* UnsupportedServiceTierProvider.make({ provider, serviceTier });
+  }
+  return serviceTier;
+});
 
 export const DEFAULT_PROVIDER: ReviewProvider = "openai";
 
@@ -44,7 +73,11 @@ export const PROVIDER_EFFORT_RUNGS = {
 >;
 
 /** One OpenAI review model binding with the package's structured-output settings. */
-export const makeOpenAiReviewModel = (model?: string, effort?: EffortPosition) =>
+export const makeOpenAiReviewModel = (
+  model?: string,
+  effort?: EffortPosition,
+  serviceTier?: OpenAiServiceTier,
+) =>
   OpenAiLanguageModel.model(model ?? DEFAULT_MODEL.openai, {
     // OpenAI counts hidden reasoning tokens and visible answer tokens against
     // this same ceiling. High-effort reviews can exhaust an 8k allowance
@@ -52,6 +85,7 @@ export const makeOpenAiReviewModel = (model?: string, effort?: EffortPosition) =
     max_output_tokens: 32_000,
     store: false,
     strictJsonSchema: true,
+    ...(serviceTier === undefined ? {} : { service_tier: serviceTier }),
     ...(effort === undefined
       ? {}
       : { reasoning: { effort: resolveEffortRung(effort, PROVIDER_EFFORT_RUNGS.openai) } }),
@@ -68,19 +102,24 @@ export const makeAnthropicReviewModel = (model?: string, effort?: EffortPosition
 
 /**
  * The human-readable descriptor of one provider binding, e.g.
- * `openai/gpt-5.6-sol (effort high)`. Rendered into the review footer and
+ * `openai/gpt-5.6-sol (effort high, service tier fast)`. Rendered into the review footer and
  * included in the changeset-fingerprint signature, so a provider, model, or
- * effort change re-reviews instead of skipping.
+ * request-profile change re-reviews instead of skipping.
  */
 export const describeReviewModel = (
   provider: ReviewProvider,
   model?: string,
   effort?: EffortPosition,
+  serviceTier?: OpenAiServiceTier,
 ): string => {
   const base = `${provider}/${model ?? DEFAULT_MODEL[provider]}`;
-  return effort === undefined
-    ? base
-    : `${base} (effort ${resolveEffortRung(effort, PROVIDER_EFFORT_RUNGS[provider])})`;
+  const details = [
+    ...(effort === undefined
+      ? []
+      : [`effort ${resolveEffortRung(effort, PROVIDER_EFFORT_RUNGS[provider])}`]),
+    ...(serviceTier === undefined ? [] : [`service tier ${serviceTier}`]),
+  ];
+  return details.length === 0 ? base : `${base} (${details.join(", ")})`;
 };
 
 /** The OpenAI client Layer, credential from `OPENAI_API_KEY`. */

package/src/internal/review-state.ts

@@ -131,11 +131,11 @@ export const MAX_STORED_UNREVIEWED_PATHS = 100;
 /** Failed-pass records stored beside the leftover paths; one per unit stage. */
 export const MAX_STORED_UNREVIEWED_PASSES = 24;
 
-/** Stages a leftover path may need retried without a second general discovery. */
+/** Stages a leftover path may need retried on the next incremental run. */
 export const UnreviewedStage = Schema.Literals(["discovery", "specialist", "verification"]);
 export type UnreviewedStage = typeof UnreviewedStage.Type;
 
-/** One failed fan-out pass whose paths should be retried, not rediscovered. */
+/** One failed fan-out pass whose stage remains attached to its exact paths. */
 export class StoredUnreviewedPass extends Schema.Class<StoredUnreviewedPass>(
   "@effect-agent/pr-review/StoredUnreviewedPass",
 )({
@@ -395,6 +395,23 @@ export class ReviewHeadComparison extends Schema.Class<ReviewHeadComparison>(
   truncated: Schema.Boolean,
 }) {}
 
+/**
+ * Current and previous paths for 300 PR files plus bounded stored continuity
+ * paths. The live adapter refuses a larger snapshot-comparison request.
+ */
+export const MAX_TREE_COMPARISON_PATHS = 750;
+
+/** A direct comparison of two complete commit tree snapshots. */
+export class ReviewTreeComparison extends Schema.Class<ReviewTreeComparison>(
+  "@effect-agent/pr-review/ReviewTreeComparison",
+)({
+  baseSha: GitCommitSha,
+  headSha: GitCommitSha,
+  changedPaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(MAX_TREE_COMPARISON_PATHS)),
+  /** True when GitHub returned either recursive tree incompletely. */
+  truncated: Schema.Boolean,
+}) {}
+
 /** Internal review selection applied as a decorator over the full PR source. */
 export interface ReviewSelection {
   readonly mode: ReviewScopeMode;
@@ -403,9 +420,12 @@ export interface ReviewSelection {
   /** 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.
+   * Failed stages attached to the unchanged paths that own them. Verification
+   * retries reopen discovery for only their paths because candidates are not
+   * persisted in review state.
    */
+  readonly retryPasses?: ReadonlyArray<StoredUnreviewedPass>;
+  /** Flattened summaries retained for diagnostics and compatibility. */
   readonly retryPaths: ReadonlyArray<string>;
   readonly retryStages: ReadonlyArray<UnreviewedStage>;
   readonly totalFiles: number;
@@ -429,6 +449,7 @@ export const fullReviewSelection = (input: {
   affectedPaths: input.files.flatMap((file) =>
     file.previousPath === undefined ? [file.path] : [file.path, file.previousPath],
   ),
+  retryPasses: [],
   retryPaths: [],
   retryStages: [],
   totalFiles: input.totalFiles,
@@ -478,19 +499,15 @@ const filePaths = (file: ChangedFile): ReadonlyArray<string> =>
   file.previousPath === undefined ? [file.path] : [file.path, file.previousPath];
 
 const incrementalFromDelta = (input: {
-  readonly current: PullRequestMetadata;
   readonly fullFiles: ReadonlyArray<ChangedFile>;
   readonly profileFingerprint: string;
   readonly priorState: ReviewState;
-  readonly deltaFiles: ReadonlyArray<ChangedFile>;
+  readonly deltaPaths: ReadonlyArray<string>;
   readonly extraAffectedPaths?: ReadonlyArray<string> | undefined;
   readonly reason: string;
 }): ReviewSelection => {
   const currentPaths = new Set(input.fullFiles.flatMap(filePaths));
-  const affectedPaths = new Set([
-    ...input.deltaFiles.flatMap(filePaths),
-    ...(input.extraAffectedPaths ?? []),
-  ]);
+  const affectedPaths = new Set([...input.deltaPaths, ...(input.extraAffectedPaths ?? [])]);
   const initialAffectedCount = affectedPaths.size;
   // Reopen every current path needed to reassess a concern touched by this
   // delta. Repeat to a fixed point because two concerns may overlap on a path.
@@ -509,38 +526,45 @@ const incrementalFromDelta = (input: {
     }
   }
   const selectedByPath = new Map<string, ChangedFile>();
-  for (const file of input.deltaFiles) {
-    if (
-      currentPaths.has(file.path) ||
-      (file.previousPath !== undefined && currentPaths.has(file.previousPath))
-    ) {
-      selectedByPath.set(file.path, file);
-    }
-  }
   const carriedPaths = input.priorState.unreviewedPaths.filter((path) => currentPaths.has(path));
   const retryOnly = new Set<string>();
-  const retryStages = new Set<UnreviewedStage>();
   for (const path of carriedPaths) {
     if (affectedPaths.has(path)) continue;
     retryOnly.add(path);
-    for (const pass of input.priorState.unreviewedPasses) {
-      if (pass.paths.includes(path)) retryStages.add(pass.stage);
-    }
   }
-  if (
-    retryStages.has("verification") &&
-    !retryStages.has("discovery") &&
-    !retryStages.has("specialist")
-  ) {
-    retryStages.add("discovery");
-    retryStages.add("specialist");
+
+  const retryPathsByStage = new Map<UnreviewedStage, Set<string>>();
+  const representedRetryPaths = new Set<string>();
+  for (const pass of input.priorState.unreviewedPasses) {
+    for (const path of pass.paths) {
+      if (!retryOnly.has(path)) continue;
+      const paths = retryPathsByStage.get(pass.stage) ?? new Set<string>();
+      paths.add(path);
+      retryPathsByStage.set(pass.stage, paths);
+      representedRetryPaths.add(path);
+    }
   }
-  if (retryOnly.size > 0 && retryStages.size === 0) {
-    for (const path of retryOnly) affectedPaths.add(path);
-    retryStages.add("discovery");
-    retryStages.add("specialist");
-    retryStages.add("verification");
+  // Some continuity gaps (capacity overflow, partial evidence, legacy state)
+  // have no failed-pass record. They conservatively re-enter fresh discovery
+  // instead of inheriting another path's unrelated failed stage.
+  for (const path of retryOnly) {
+    if (representedRetryPaths.has(path)) continue;
+    retryOnly.delete(path);
+    affectedPaths.add(path);
   }
+  const retryPasses = (["discovery", "specialist", "verification"] as const).flatMap((stage) => {
+    const paths = [...(retryPathsByStage.get(stage) ?? [])]
+      .filter((path) => retryOnly.has(path))
+      .sort();
+    return Array.from({ length: Math.ceil(paths.length / 12) }, (_, index) =>
+      StoredUnreviewedPass.make({
+        stage,
+        paths: paths.slice(index * 12, (index + 1) * 12),
+      }),
+    );
+  });
+  const retryPaths = [...retryOnly].sort();
+  const retryStages = [...new Set(retryPasses.map((pass) => pass.stage))];
   for (const file of input.fullFiles) {
     const needed =
       affectedPaths.has(file.path) ||
@@ -552,10 +576,10 @@ const incrementalFromDelta = (input: {
   const selectedFiles = [...selectedByPath.values()].sort((left, right) =>
     left.path < right.path ? -1 : left.path > right.path ? 1 : 0,
   );
-  const leftoverCount = [...retryOnly].filter((path) => !affectedPaths.has(path)).length;
+  const leftoverCount = retryPaths.length;
   const carriedReason =
     leftoverCount > 0
-      ? `; retrying ${leftoverCount} unchanged leftover path(s) without rediscovery`
+      ? `; retrying ${leftoverCount} unchanged leftover path(s) by recorded failed stage`
       : carriedPaths.length > 0
         ? `; retrying ${carriedPaths.length} carried unreviewed path(s)`
         : "";
@@ -569,8 +593,9 @@ const incrementalFromDelta = (input: {
     reason: `${input.reason}${carriedReason}${concernReason}`,
     files: selectedFiles,
     affectedPaths: [...affectedPaths].sort(),
-    retryPaths: [...retryOnly].filter((path) => !affectedPaths.has(path)).sort(),
-    retryStages: [...retryStages].sort(),
+    retryPasses,
+    retryPaths,
+    retryStages,
     totalFiles: selectedFiles.length,
     baselineSha: input.priorState.reviewedHeadSha,
     priorState: input.priorState,
@@ -588,11 +613,12 @@ export const selectReviewRange = (input: {
   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.
+   * Direct commit-tree snapshot comparison used when the reviewed head is not
+   * a git ancestor. Selection hydrates these paths from the current PR files.
    */
-  readonly contentComparison?: ReviewHeadComparison | undefined;
+  readonly contentComparison?: ReviewTreeComparison | undefined;
+  /** Why the direct snapshot comparison could not produce complete evidence. */
+  readonly contentComparisonFailure?: string | undefined;
   readonly lookupFailure?: string | undefined;
 }): ReviewSelection => {
   const full = (reason: string) =>
@@ -634,26 +660,38 @@ export const selectReviewRange = (input: {
       baseReason = `; base advanced from ${input.priorState.baseSha.slice(0, 7)} and overlapping PR paths were included`;
     }
     return incrementalFromDelta({
-      current: input.current,
       fullFiles: input.fullFiles,
       profileFingerprint: input.profileFingerprint,
       priorState: input.priorState,
-      deltaFiles: comparison.files,
+      deltaPaths: comparison.files.flatMap(filePaths),
       extraAffectedPaths: extraAffected,
       reason: `changes since reviewed head ${input.priorState.reviewedHeadSha.slice(0, 7)}${baseReason}`,
     });
   }
   const contentComparison = input.contentComparison;
-  if (contentComparison !== undefined && !contentComparison.truncated) {
+  if (contentComparison !== undefined) {
+    if (
+      contentComparison.baseSha !== input.priorState.reviewedHeadSha ||
+      contentComparison.headSha !== input.current.headSha
+    ) {
+      return full("the rewritten-head tree snapshot comparison did not match the requested heads");
+    }
+    if (contentComparison.truncated) {
+      return full("the rewritten-head tree snapshot comparison was truncated");
+    }
     return incrementalFromDelta({
-      current: input.current,
       fullFiles: input.fullFiles,
       profileFingerprint: input.profileFingerprint,
       priorState: input.priorState,
-      deltaFiles: contentComparison.files,
+      deltaPaths: contentComparison.changedPaths,
       reason: `rewritten history; contents changed since reviewed head ${input.priorState.reviewedHeadSha.slice(0, 7)}`,
     });
   }
+  if (input.contentComparisonFailure !== undefined) {
+    return full(
+      `the rewritten-head tree snapshot comparison failed: ${input.contentComparisonFailure.slice(0, 2_048)}`,
+    );
+  }
   if (comparison === undefined) return full("the incremental head comparison was unavailable");
   if (comparison.truncated) return full("the incremental comparison exceeded GitHub's file bound");
   return full("the prior reviewed head is not an ancestor of the current head");

package/src/internal/run.ts

@@ -553,17 +553,22 @@ export const executeFanOutReview = <Provider, ModelProvides, ModelRequires>(
     const budget = yield* makeUsageBudget(options.limits ?? fanOutReviewBudgetLimits);
     const totalFiles = executionContext.totalFiles;
     const continuity = yield* resolveReviewContinuityContext();
+    const retryPasses =
+      executionContext.retryPasses ??
+      executionContext.retryStages.map((stage) => ({
+        stage,
+        paths: executionContext.retryPaths,
+      }));
     const pipeline = yield* runFanOutReview(binding, {
       files,
       anchorFiles,
       totalChangedFiles: totalFiles,
       maxFindings: options.maxFindings,
       budget: toRunBudgetHook(budget),
-      ...(executionContext.retryPaths.length > 0
+      ...(retryPasses.length > 0
         ? {
             retry: {
-              paths: executionContext.retryPaths,
-              stages: executionContext.retryStages,
+              passes: retryPasses,
             },
           }
         : {}),