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

package/src/internal/review-state.ts

@@ -37,18 +37,112 @@ export class StoredReviewFinding extends Schema.Class<StoredReviewFinding>(
   body: StoredText,
 }) {}
 
-/** A compact unresolved non-anchored concern carried until a final audit. */
+/** A compact unresolved non-anchored concern with its invalidation paths. */
 export class StoredReviewConcern extends Schema.Class<StoredReviewConcern>(
   "@effect-agent/pr-review/StoredReviewConcern",
 )({
+  /** Absent only on legacy state written before concern path binding. */
+  evidencePaths: Schema.optionalKey(
+    Schema.Array(ChangedPath).check(Schema.isMinLength(1)).check(Schema.isMaxLength(3)),
+  ),
   severity: FindingSeverity,
   title: Schema.NonEmptyString.check(Schema.isMaxLength(120)),
   body: StoredText,
 }) {}
 
+/** How a maintainer settled a previously raised finding or concern. */
+export const AdjudicationDisposition = Schema.Literals(["accepted-risk", "refuted", "obsolete"]);
+export type AdjudicationDisposition = typeof AdjudicationDisposition.Type;
+
+/** The adjudications bound carried by the ReviewState schema. */
+export const MAX_STORED_ADJUDICATIONS = 20;
+
+/**
+ * One maintainer adjudication of a finding or concern identity. Anchored
+ * findings carry their full location identity; unanchored concerns are
+ * identified by title alone, so the location fields stay absent.
+ */
+const StoredAdjudicationFields = Schema.Struct({
+  path: Schema.optionalKey(ChangedPath),
+  startLine: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+  endLine: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+  title: Schema.NonEmptyString.check(Schema.isMaxLength(120)),
+  disposition: AdjudicationDisposition,
+  reason: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(300))),
+  /** GitHub login of the maintainer whose comment adjudicated the identity. */
+  actor: Schema.NonEmptyString.check(Schema.isMaxLength(100)),
+}).check(
+  Schema.makeFilter(
+    (adjudication) => {
+      const locationParts = [
+        adjudication.path,
+        adjudication.startLine,
+        adjudication.endLine,
+      ].filter((part) => part !== undefined).length;
+      return locationParts === 0 || locationParts === 3
+        ? undefined
+        : "path, startLine, and endLine must be either all present or all absent";
+    },
+    { title: "adjudication locations are complete or unanchored" },
+  ),
+);
+
+export class StoredAdjudication extends Schema.Class<StoredAdjudication>(
+  "@effect-agent/pr-review/StoredAdjudication",
+)(StoredAdjudicationFields) {}
+
+/**
+ * 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.
+ */
+export const findingIdentity = (finding: {
+  readonly path: string;
+  readonly startLine: number;
+  readonly endLine: number;
+  readonly title: string;
+}): string =>
+  JSON.stringify(["finding", finding.path, finding.startLine, finding.endLine, finding.title]);
+
+/** The disjoint title-only identity namespace for unanchored concerns. */
+export const concernIdentity = (concern: { readonly title: string }): string =>
+  JSON.stringify(["concern", concern.title]);
+
+/**
+ * An adjudication's identity: the shared finding identity when anchored, the
+ * disjoint concern identity when unanchored.
+ */
+export const adjudicationIdentity = (adjudication: StoredAdjudication): string =>
+  adjudication.path !== undefined &&
+  adjudication.startLine !== undefined &&
+  adjudication.endLine !== undefined
+    ? findingIdentity({
+        path: adjudication.path,
+        startLine: adjudication.startLine,
+        endLine: adjudication.endLine,
+        title: adjudication.title,
+      })
+    : concernIdentity(adjudication);
+
 /** The carried-scope bound; a run that cannot fit its leftovers publishes no state. */
 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. */
+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. */
+export class StoredUnreviewedPass extends Schema.Class<StoredUnreviewedPass>(
+  "@effect-agent/pr-review/StoredUnreviewedPass",
+)({
+  stage: UnreviewedStage,
+  paths: Schema.Array(ChangedPath).check(Schema.isMinLength(1)).check(Schema.isMaxLength(12)),
+}) {}
+
 /**
  * Versioned state embedded after EVERY completed run that can be signed. The
  * head plus full-scope fingerprint forms an incremental baseline; an absent
@@ -56,12 +150,11 @@ export const MAX_STORED_UNREVIEWED_PATHS = 100;
  * 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.
+ * the whole post-baseline scope. Storing hundreds of path strings separately
+ * would not fit GitHub's bounded review body in the worst case.
  */
 export class ReviewState extends Schema.Class<ReviewState>("@effect-agent/pr-review/ReviewState")({
-  version: Schema.Literal(2),
+  version: Schema.Literal(1),
   repository: Schema.NonEmptyString.check(Schema.isMaxLength(200)),
   pullRequestNumber: Schema.Int.check(Schema.isGreaterThan(0)),
   baseRef: Schema.NonEmptyString.check(Schema.isMaxLength(300)),
@@ -69,12 +162,16 @@ export class ReviewState extends Schema.Class<ReviewState>("@effect-agent/pr-rev
   headRef: Schema.NonEmptyString.check(Schema.isMaxLength(300)),
   reviewedHeadSha: GitCommitSha,
   profileFingerprint: Fingerprint,
-  acceptedScopeFingerprint: Fingerprint,
+  settledScopeFingerprint: Fingerprint,
   reviewedPathCount: Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 300 })),
   unresolvedFindings: Schema.Array(StoredReviewFinding).check(Schema.isMaxLength(20)),
   unresolvedConcerns: Schema.Array(StoredReviewConcern).check(Schema.isMaxLength(10)),
   /** Retryable review gaps carried into the next incremental run's scope. */
   unreviewedPaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(MAX_STORED_UNREVIEWED_PATHS)),
+  /** Which failed pass produced those leftovers. */
+  unreviewedPasses: Schema.Array(StoredUnreviewedPass).check(
+    Schema.isMaxLength(MAX_STORED_UNREVIEWED_PASSES),
+  ),
   /**
    * True only when the producing run had complete input coverage, no
    * unsettled pass, and nothing carried. Skip-unchanged authority: an
@@ -82,6 +179,13 @@ export class ReviewState extends Schema.Class<ReviewState>("@effect-agent/pr-rev
    */
   settled: Schema.Boolean,
   lastReviewMode: ReviewScopeMode,
+  /**
+   * Maintainer adjudications standing against this pull request. optionalKey
+   * so state markers signed before the field existed still decode.
+   */
+  adjudications: Schema.optionalKey(
+    Schema.Array(StoredAdjudication).check(Schema.isMaxLength(MAX_STORED_ADJUDICATIONS)),
+  ),
 }) {}
 
 export const toStoredFinding = (finding: ReviewFinding): StoredReviewFinding =>
@@ -106,23 +210,29 @@ export const fromStoredFinding = (finding: StoredReviewFinding): ReviewFinding =
 
 export const toStoredConcern = (concern: ReviewConcern): StoredReviewConcern =>
   StoredReviewConcern.make({
+    ...(concern.evidencePaths === undefined ? {} : { evidencePaths: concern.evidencePaths }),
     severity: concern.severity,
     title: concern.title,
     body: concern.body.slice(0, 800),
   });
 
 export const fromStoredConcern = (concern: StoredReviewConcern): ReviewConcern =>
-  ReviewConcern.make({ severity: concern.severity, title: concern.title, body: concern.body });
+  ReviewConcern.make({
+    ...(concern.evidencePaths === undefined ? {} : { evidencePaths: concern.evidencePaths }),
+    severity: concern.severity,
+    title: concern.title,
+    body: concern.body,
+  });
 
-const STATE_MARKER_PREFIX = "<!-- effect-agent-pr-review state-v2:";
+const STATE_MARKER_PREFIX = "<!-- effect-agent-pr-review state-v1:";
 const STATE_MARKER_SUFFIX = " -->";
 const STATE_MARKER_PATTERN =
-  /(?:^|\n)<!-- effect-agent-pr-review state-v2:([A-Za-z0-9+/]+={0,2})\.([0-9a-f]{64}) -->$/;
-const STATE_SIGNATURE_DOMAIN = "effect-agent-pr-review/state-v2\u0000";
+  /(?:^|\n)<!-- effect-agent-pr-review state-v1:([A-Za-z0-9+/]+={0,2})\.([0-9a-f]{64}) -->$/;
+const STATE_SIGNATURE_DOMAIN = "effect-agent-pr-review/state-v1\u0000";
 export const MAX_REVIEW_STATE_MARKER_CHARS = 24_000;
 export const ReviewStateMarker = Schema.NonEmptyString.check(
   Schema.isMaxLength(MAX_REVIEW_STATE_MARKER_CHARS),
-  Schema.isPattern(/^<!-- effect-agent-pr-review state-v2:[A-Za-z0-9+/]+={0,2}\.[0-9a-f]{64} -->$/),
+  Schema.isPattern(/^<!-- effect-agent-pr-review state-v1:[A-Za-z0-9+/]+={0,2}\.[0-9a-f]{64} -->$/),
 ).pipe(Schema.brand("@effect-agent/pr-review/ReviewStateMarker"));
 export type ReviewStateMarker = typeof ReviewStateMarker.Type;
 
@@ -292,19 +402,26 @@ export interface ReviewSelection {
   readonly files: ReadonlyArray<ChangedFile>;
   /** Paths whose changes invalidate prior findings, including paths reverted out of the PR. */
   readonly affectedPaths: ReadonlyArray<string>;
+  /**
+   * Leftover paths whose contents did not change. Fan-out retries only the
+   * recorded failed stages on these paths and keeps their stored findings.
+   */
+  readonly retryPaths: ReadonlyArray<string>;
+  readonly retryStages: ReadonlyArray<UnreviewedStage>;
   readonly totalFiles: number;
   readonly baselineSha: string | undefined;
   readonly priorState: ReviewState | undefined;
-  readonly profileFingerprint: string;
+  /** 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;
 }
 
-const fullSelection = (input: {
+export const fullReviewSelection = (input: {
   readonly reason: string;
   readonly files: ReadonlyArray<ChangedFile>;
   readonly totalFiles: number;
-  readonly profileFingerprint: string;
+  readonly profileFingerprint?: string | undefined;
 }): ReviewSelection => ({
   mode: "full",
   reason: input.reason,
@@ -312,12 +429,26 @@ const fullSelection = (input: {
   affectedPaths: input.files.flatMap((file) =>
     file.previousPath === undefined ? [file.path] : [file.path, file.previousPath],
   ),
+  retryPaths: [],
+  retryStages: [],
   totalFiles: input.totalFiles,
   baselineSha: undefined,
   priorState: undefined,
   profileFingerprint: input.profileFingerprint,
 });
 
+/** Three-dot lineage from the reviewed head to the current head is usable. */
+export const isLineageAncestor = (
+  comparison: ReviewHeadComparison,
+  priorState: ReviewState,
+  currentHeadSha: string,
+): boolean =>
+  comparison.baseSha === priorState.reviewedHeadSha &&
+  comparison.headSha === currentHeadSha &&
+  comparison.mergeBaseSha === priorState.reviewedHeadSha &&
+  !comparison.truncated &&
+  (comparison.status === "ahead" || comparison.status === "identical");
+
 /**
  * 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
@@ -337,9 +468,116 @@ export const validateReviewState = (
   if (state.profileFingerprint !== profileFingerprint) {
     return "the reviewer profile or model configuration changed";
   }
+  if (state.unresolvedConcerns.some((concern) => concern.evidencePaths === undefined)) {
+    return "stored concerns predate affected-path tracking";
+  }
   return undefined;
 };
 
+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 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 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.
+  let expanded = true;
+  while (expanded) {
+    expanded = false;
+    for (const concern of input.priorState.unresolvedConcerns) {
+      const paths = concern.evidencePaths ?? [];
+      if (!paths.some((path) => affectedPaths.has(path))) continue;
+      for (const path of paths) {
+        if (!affectedPaths.has(path)) {
+          affectedPaths.add(path);
+          expanded = true;
+        }
+      }
+    }
+  }
+  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");
+  }
+  if (retryOnly.size > 0 && retryStages.size === 0) {
+    for (const path of retryOnly) affectedPaths.add(path);
+    retryStages.add("discovery");
+    retryStages.add("specialist");
+    retryStages.add("verification");
+  }
+  for (const file of input.fullFiles) {
+    const needed =
+      affectedPaths.has(file.path) ||
+      (file.previousPath !== undefined && affectedPaths.has(file.previousPath)) ||
+      retryOnly.has(file.path) ||
+      (file.previousPath !== undefined && retryOnly.has(file.previousPath));
+    if (needed) selectedByPath.set(file.path, file);
+  }
+  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 carriedReason =
+    leftoverCount > 0
+      ? `; retrying ${leftoverCount} unchanged leftover path(s) without rediscovery`
+      : carriedPaths.length > 0
+        ? `; retrying ${carriedPaths.length} carried unreviewed path(s)`
+        : "";
+  const concernPathCount = affectedPaths.size - initialAffectedCount;
+  const concernReason =
+    concernPathCount === 0
+      ? ""
+      : `; reopening ${concernPathCount} related concern path(s) for context`;
+  return {
+    mode: "incremental",
+    reason: `${input.reason}${carriedReason}${concernReason}`,
+    files: selectedFiles,
+    affectedPaths: [...affectedPaths].sort(),
+    retryPaths: [...retryOnly].filter((path) => !affectedPaths.has(path)).sort(),
+    retryStages: [...retryStages].sort(),
+    totalFiles: selectedFiles.length,
+    baselineSha: input.priorState.reviewedHeadSha,
+    priorState: input.priorState,
+    profileFingerprint: input.profileFingerprint,
+  };
+};
+
 /** Pure, deterministic range selection with conservative full-review fallbacks. */
 export const selectReviewRange = (input: {
   readonly requestedMode: ReviewMode;
@@ -349,10 +587,16 @@ export const selectReviewRange = (input: {
   readonly priorState: ReviewState | undefined;
   readonly comparison: ReviewHeadComparison | undefined;
   readonly baseComparison?: ReviewHeadComparison | undefined;
+  /**
+   * Two-dot tree comparison used when the reviewed head is not a git ancestor
+   * (rebase, amend, force-push). Intersected with the current PR path set so
+   * main-drift outside the pull request never re-enters scope.
+   */
+  readonly contentComparison?: ReviewHeadComparison | undefined;
   readonly lookupFailure?: string | undefined;
 }): ReviewSelection => {
   const full = (reason: string) =>
-    fullSelection({
+    fullReviewSelection({
       reason,
       files: input.fullFiles,
       totalFiles: input.current.totalChangedFiles,
@@ -366,89 +610,53 @@ export const selectReviewRange = (input: {
   const invalid = validateReviewState(input.priorState, input.current, input.profileFingerprint);
   if (invalid !== undefined) return full(invalid);
   const comparison = input.comparison;
-  if (comparison === undefined) return full("the incremental head comparison was unavailable");
   if (
-    comparison.baseSha !== input.priorState.reviewedHeadSha ||
-    comparison.headSha !== input.current.headSha ||
-    comparison.mergeBaseSha !== input.priorState.reviewedHeadSha ||
-    (comparison.status !== "ahead" && comparison.status !== "identical")
+    comparison !== undefined &&
+    isLineageAncestor(comparison, input.priorState, input.current.headSha)
   ) {
-    return full("the prior reviewed head is not an ancestor of the current head");
-  }
-  if (comparison.truncated) return full("the incremental comparison exceeded GitHub's file bound");
-  const affectedPaths = new Set(
-    comparison.files.flatMap((file) =>
-      file.previousPath === undefined ? [file.path] : [file.path, file.previousPath],
-    ),
-  );
-  let baseReason = "";
-  if (input.priorState.baseSha !== input.current.baseSha) {
-    const baseComparison = input.baseComparison;
-    if (baseComparison === undefined) {
-      return full("the pull request base changed and its lineage comparison was unavailable");
-    }
-    if (
-      baseComparison.baseSha !== input.priorState.baseSha ||
-      baseComparison.headSha !== input.current.baseSha ||
-      baseComparison.mergeBaseSha !== input.priorState.baseSha ||
-      (baseComparison.status !== "ahead" && baseComparison.status !== "identical") ||
-      baseComparison.truncated
-    ) {
-      return full("the pull request base changed materially or exceeded the comparison bound");
-    }
-    for (const file of baseComparison.files) {
-      affectedPaths.add(file.path);
-      if (file.previousPath !== undefined) affectedPaths.add(file.previousPath);
-    }
-    baseReason = `; base advanced from ${input.priorState.baseSha.slice(0, 7)} and overlapping PR paths were included`;
-  }
-  const currentPaths = new Set(
-    input.fullFiles.flatMap((file) =>
-      file.previousPath === undefined ? [file.path] : [file.path, file.previousPath],
-    ),
-  );
-  const selectedByPath = new Map<string, ChangedFile>();
-  for (const file of comparison.files) {
-    if (
-      currentPaths.has(file.path) ||
-      (file.previousPath !== undefined && currentPaths.has(file.previousPath))
-    ) {
-      selectedByPath.set(file.path, file);
+    const extraAffected: Array<string> = [];
+    let baseReason = "";
+    if (input.priorState.baseSha !== input.current.baseSha) {
+      const baseComparison = input.baseComparison;
+      if (baseComparison === undefined) {
+        return full("the pull request base changed and its lineage comparison was unavailable");
+      }
+      if (
+        baseComparison.baseSha !== input.priorState.baseSha ||
+        baseComparison.headSha !== input.current.baseSha ||
+        baseComparison.mergeBaseSha !== input.priorState.baseSha ||
+        (baseComparison.status !== "ahead" && baseComparison.status !== "identical") ||
+        baseComparison.truncated
+      ) {
+        return full("the pull request base changed materially or exceeded the comparison bound");
+      }
+      for (const file of baseComparison.files) extraAffected.push(...filePaths(file));
+      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,
+      extraAffectedPaths: extraAffected,
+      reason: `changes since reviewed head ${input.priorState.reviewedHeadSha.slice(0, 7)}${baseReason}`,
+    });
   }
-  // Retryable gaps carried by the prior state re-enter this run's scope; a
-  // carried path reverted out of the pull request has nothing left to review.
-  const carriedPaths = new Set(
-    input.priorState.unreviewedPaths.filter((path) => currentPaths.has(path)),
-  );
-  for (const path of carriedPaths) affectedPaths.add(path);
-  const rescuePaths = input.priorState.baseSha !== input.current.baseSha;
-  if (rescuePaths || carriedPaths.size > 0) {
-    for (const file of input.fullFiles) {
-      const affected =
-        (rescuePaths &&
-          (affectedPaths.has(file.path) ||
-            (file.previousPath !== undefined && affectedPaths.has(file.previousPath)))) ||
-        carriedPaths.has(file.path) ||
-        (file.previousPath !== undefined && carriedPaths.has(file.previousPath));
-      if (affected) selectedByPath.set(file.path, file);
-    }
+  const contentComparison = input.contentComparison;
+  if (contentComparison !== undefined && !contentComparison.truncated) {
+    return incrementalFromDelta({
+      current: input.current,
+      fullFiles: input.fullFiles,
+      profileFingerprint: input.profileFingerprint,
+      priorState: input.priorState,
+      deltaFiles: contentComparison.files,
+      reason: `rewritten history; contents changed since reviewed head ${input.priorState.reviewedHeadSha.slice(0, 7)}`,
+    });
   }
-  const selectedFiles = [...selectedByPath.values()].sort((left, right) =>
-    left.path < right.path ? -1 : left.path > right.path ? 1 : 0,
-  );
-  const carriedReason =
-    carriedPaths.size === 0 ? "" : `; retrying ${carriedPaths.size} carried unreviewed path(s)`;
-  return {
-    mode: "incremental",
-    reason: `changes since reviewed head ${input.priorState.reviewedHeadSha.slice(0, 7)}${baseReason}${carriedReason}`,
-    files: selectedFiles,
-    affectedPaths: [...affectedPaths].sort(),
-    totalFiles: selectedFiles.length,
-    baselineSha: input.priorState.reviewedHeadSha,
-    priorState: input.priorState,
-    profileFingerprint: input.profileFingerprint,
-  };
+  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");
 };
 
 /** Per-run context consumed by orchestration and publication, not by the model. */
@@ -457,6 +665,20 @@ export class ReviewExecutionContext extends Context.Service<
   ReviewSelection
 >()("@effect-agent/pr-review/ReviewExecutionContext") {}
 
+/**
+ * Explicit direct-run adapter for callers that intentionally review the full
+ * source without authenticated incremental continuity.
+ */
+export const fullReviewExecutionContextLayer = (reason: string) =>
+  Layer.effect(
+    ReviewExecutionContext,
+    Effect.gen(function* () {
+      const source = yield* PullRequestSource;
+      const [metadata, files] = yield* Effect.all([source.metadata, source.changedFiles]);
+      return fullReviewSelection({ reason, files, totalFiles: metadata.totalChangedFiles });
+    }),
+  );
+
 /**
  * Decorate the full source with the selected review range. Full anchor files
  * remain available to host-side publication validation; model tools see only
@@ -506,18 +728,6 @@ export const selectedPullRequestSourceLayer = (
     }),
   );
 
-/** Profile fingerprints are SHA-256 over configuration-only signatures. */
-export const computeProfileFingerprint = (signature: string): Effect.Effect<string> =>
-  Effect.promise(async () => {
-    const digest = await globalThis.crypto.subtle.digest(
-      "SHA-256",
-      new TextEncoder().encode(signature),
-    );
-    return Array.from(new Uint8Array(digest))
-      .map((byte) => byte.toString(16).padStart(2, "0"))
-      .join("");
-  });
-
 /** Build the full-surface mission used only to resolve profile guidance. */
 export const buildProfileMission = (
   metadata: PullRequestMetadata,

package/src/internal/review-units.ts

@@ -24,9 +24,6 @@ export const MAX_REVIEW_UNITS = 8;
 /** A unit never carries more files than this, regardless of their size. */
 export const MAX_UNIT_FILES = 12;
 
-/** Compatibility export; complete evidence chars now own unit packing. */
-export 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,
@@ -45,9 +42,6 @@ export const MAX_UNIT_EVIDENCE_SHARDS = 12;
  */
 export const MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS = MAX_REVIEW_UNITS * MAX_UNIT_EVIDENCE_SHARDS;
 
-/** @deprecated Use `MAX_PATCH_CHARS`; this is now the per-shard bound. */
-export const MAX_FILE_EVIDENCE_CHARS = MAX_PATCH_CHARS;
-
 /** The merged review never exceeds the `CodeReview` findings bound. */
 export const MAX_MERGED_FINDINGS = 20;
 
@@ -468,8 +462,15 @@ export const rankAndDedupeFindings = (
 };
 
 /**
- * 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.
+ */
+export const reviewConcernKey = (concern: ReviewConcern): string =>
+  `${(concern.evidencePaths ?? []).join("\u0000")}\u0001${concern.title}\u0000${concern.body}`;
+
+/**
+ * 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.
  */
 export const rankAndDedupeConcerns = (
@@ -477,7 +478,7 @@ export const rankAndDedupeConcerns = (
 ): ReadonlyArray<ReviewConcern> => {
   const byContent = new Map<string, ReviewConcern>();
   for (const concern of concerns) {
-    const key = `${concern.title}\u0000${concern.body}`;
+    const key = reviewConcernKey(concern);
     const previous = byContent.get(key);
     if (
       previous === undefined ||