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

package/src/internal/review-units.ts

@@ -2,8 +2,12 @@ import { Schema } from "effect";
 
 import type { ChangedFile } from "./diff.ts";
 import { ChangedPath, isReviewableFile } from "./diff.ts";
-import type { FindingSeverity } from "./review-agent.ts";
-import { ReviewFinding } from "./review-agent.ts";
+import {
+  fileReviewEvidenceChunks,
+  type FindingSeverity,
+  MAX_PATCH_CHARS,
+  type ReviewFinding,
+} from "./review-agent.ts";
 
 // ---------------------------------------------------------------------------
 // Pure, deterministic planning for the fan-out reviewer: group the changeset
@@ -19,25 +23,101 @@ export const MAX_REVIEW_UNITS = 8;
 /** A unit never carries more files than this, regardless of their size. */
 export const MAX_UNIT_FILES = 12;
 
-/** Soft changed-line budget per unit; a single oversized file still gets its own unit. */
+/** Compatibility export; complete evidence chars now own unit packing. */
 export const UNIT_CHANGED_LINE_BUDGET = 800;
 
-/** Flat per-file cost so many tiny files still spread across units. */
-const FILE_OVERHEAD_LINES = 20;
+/**
+ * Bound the complete model-visible evidence assigned to one child. This is a
+ * character bound rather than a token estimate because it is deterministic,
+ * provider-independent, and enforced before any model call.
+ */
+export const UNIT_EVIDENCE_CHAR_BUDGET = 240_000;
+
+/** Maximum complete evidence shards placed in one child brief. */
+export const MAX_UNIT_EVIDENCE_SHARDS = 12;
+
+/**
+ * Keep overflow diagnostics bounded to one plan's total assignment capacity.
+ * The plan separately records the exact overflow count and every affected
+ * path, so identifiers are a deterministic diagnostic sample rather than the
+ * authority for whether input coverage is complete.
+ */
+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;
 
 export const ReviewUnitId = Schema.NonEmptyString.check(Schema.isMaxLength(32));
 
+/** High-risk surfaces that receive an explicit specialist focus label. */
+export const ReviewRiskCategory = Schema.Literals([
+  "authentication-authorization",
+  "security-boundary",
+  "persistence-durability",
+  "concurrency",
+  "credential-handling",
+  "external-side-effects",
+]);
+export type ReviewRiskCategory = typeof ReviewRiskCategory.Type;
+
+export const ReviewDiscoveryPerspective = Schema.Literals(["general", "risk-specialist"]);
+export type ReviewDiscoveryPerspective = typeof ReviewDiscoveryPerspective.Type;
+
+export const ReviewPassId = Schema.NonEmptyString.check(Schema.isMaxLength(64));
+export const ReviewEvidenceShardId = Schema.NonEmptyString.check(Schema.isMaxLength(32));
+
+/** One complete bounded slice of a changed path's model-visible evidence. */
+export class ReviewEvidenceShard extends Schema.Class<ReviewEvidenceShard>(
+  "@effect-agent/pr-review/ReviewEvidenceShard",
+)({
+  shardId: ReviewEvidenceShardId,
+  path: ChangedPath,
+  ordinal: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+  total: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+  evidenceChars: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).check(
+    Schema.isLessThanOrEqualTo(MAX_PATCH_CHARS),
+  ),
+}) {}
+
+const EvidenceShardIds = Schema.Array(ReviewEvidenceShardId)
+  .check(Schema.isMinLength(1))
+  .check(Schema.isMaxLength(MAX_UNIT_EVIDENCE_SHARDS));
+
+/** One required, independently scoped discovery attempt. */
+export class ReviewDiscoveryPass extends Schema.Class<ReviewDiscoveryPass>(
+  "@effect-agent/pr-review/ReviewDiscoveryPass",
+)({
+  passId: ReviewPassId,
+  unitId: ReviewUnitId,
+  paths: Schema.Array(ChangedPath)
+    .check(Schema.isMinLength(1))
+    .check(Schema.isMaxLength(MAX_UNIT_FILES)),
+  evidenceShardIds: EvidenceShardIds,
+  perspective: ReviewDiscoveryPerspective,
+  /** Empty for the general pass; explicit deterministic focus for specialists. */
+  riskCategories: Schema.Array(ReviewRiskCategory).check(Schema.isMaxLength(6)),
+}) {}
+
 /** One bounded slice of the changeset delegated to one child reviewer. */
 export class ReviewUnit extends Schema.Class<ReviewUnit>("@effect-agent/pr-review/ReviewUnit")({
   unitId: ReviewUnitId,
   paths: Schema.Array(ChangedPath)
     .check(Schema.isMinLength(1))
     .check(Schema.isMaxLength(MAX_UNIT_FILES)),
+  evidenceShards: Schema.Array(ReviewEvidenceShard)
+    .check(Schema.isMinLength(1))
+    .check(Schema.isMaxLength(MAX_UNIT_EVIDENCE_SHARDS)),
   /** additions + deletions across the unit's files, for honest sizing. */
   changedLines: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  /** Complete model-visible diff/content evidence assigned to each child. */
+  evidenceChars: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).check(
+    Schema.isLessThanOrEqualTo(UNIT_EVIDENCE_CHAR_BUDGET),
+  ),
+  /** Host-classified focus labels for the unit's redundant specialist pass. */
+  riskCategories: Schema.Array(ReviewRiskCategory).check(Schema.isMaxLength(6)),
 }) {}
 
 /** The complete deterministic fan-out plan over one changeset. */
@@ -48,8 +128,20 @@ export class ReviewUnitPlan extends Schema.Class<ReviewUnitPlan>(
   /** True when the source returned fewer files than the pull request has. */
   truncated: Schema.Boolean,
   units: Schema.Array(ReviewUnit).check(Schema.isMaxLength(MAX_REVIEW_UNITS)),
+  /** Exact discovery calls the coordinator must make. */
+  discoveryPasses: Schema.Array(ReviewDiscoveryPass).check(
+    Schema.isMaxLength(MAX_REVIEW_UNITS * 2),
+  ),
   /** Changed files with neither a textual diff nor bounded base/head text. */
   undiffablePaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(300)),
+  /** Assigned paths with one or more evidence shards beyond plan capacity. */
+  partialEvidencePaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(300)),
+  /** Exact number of shards beyond the bounded unit capacity. */
+  unassignedEvidenceShardCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  /** Bounded deterministic prefix of the unassigned shard identifiers. */
+  unassignedEvidenceShardIds: Schema.Array(ReviewEvidenceShardId).check(
+    Schema.isMaxLength(MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS),
+  ),
   /**
    * Diffable files beyond the fan-out capacity (MAX_REVIEW_UNITS units of
    * MAX_UNIT_FILES files). Never silently dropped: the coordinator must name
@@ -58,36 +150,217 @@ export class ReviewUnitPlan extends Schema.Class<ReviewUnitPlan>(
   unassignedPaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(300)),
 }) {}
 
-const fileCost = (file: ChangedFile): number => {
-  const contentChars =
-    (file.reviewBaseContent?.length ?? 0) + (file.reviewHeadContent?.length ?? 0);
-  const contentWeight = Math.ceil(contentChars / 200);
-  return file.additions + file.deletions + contentWeight + FILE_OVERHEAD_LINES;
+const riskRules: ReadonlyArray<{
+  readonly category: ReviewRiskCategory;
+  readonly patterns: ReadonlyArray<RegExp>;
+}> = [
+  {
+    category: "authentication-authorization",
+    patterns: [/auth/, /authoriz/, /permission/, /principal/, /access[-_ ]?control/, /role\b/],
+  },
+  {
+    category: "security-boundary",
+    patterns: [
+      /security/,
+      /sandbox/,
+      /untrusted/,
+      /schema\.decode/,
+      /validation/,
+      /injection/,
+      /csrf/,
+      /xss/,
+      /path traversal/,
+    ],
+  },
+  {
+    category: "persistence-durability",
+    patterns: [
+      /durab/,
+      /persist/,
+      /storage/,
+      /database/,
+      /\bsql\b/,
+      /journal/,
+      /ledger/,
+      /checkpoint/,
+      /migration/,
+      /transaction/,
+    ],
+  },
+  {
+    category: "concurrency",
+    patterns: [
+      /concurr/,
+      /semaphore/,
+      /\bfiber/,
+      /race/,
+      /mutex/,
+      /\block\b/,
+      /queue/,
+      /parallel/,
+      /interrupt/,
+    ],
+  },
+  {
+    category: "credential-handling",
+    patterns: [/credential/, /secret/, /password/, /api[-_ ]?key/, /bearer/, /hmac/, /signature/],
+  },
+  {
+    category: "external-side-effects",
+    patterns: [
+      /publish/,
+      /webhook/,
+      /github/,
+      /fetch\(/,
+      /http/,
+      /send[-_ ]?(email|message)/,
+      /write[-_ ]?(file|record)/,
+      /delete/,
+      /mutation/,
+      /side[-_ ]?effect/,
+      /spawn/,
+      /exec/,
+    ],
+  },
+];
+
+/**
+ * Deterministic host policy for specialist assignment. It intentionally
+ * favors false positives: an extra bounded pass costs work, while a missed
+ * high-risk classification removes redundancy. This is not a claim that the
+ * keyword policy recognizes every semantically risky change.
+ */
+export const classifyReviewRisks = (file: ChangedFile): ReadonlyArray<ReviewRiskCategory> => {
+  const text = [
+    file.path,
+    file.previousPath ?? "",
+    file.patch ?? "",
+    file.reviewBaseContent ?? "",
+    file.reviewHeadContent ?? "",
+  ]
+    .join("\n")
+    .toLowerCase();
+  return riskRules
+    .filter((rule) => rule.patterns.some((pattern) => pattern.test(text)))
+    .map((rule) => rule.category);
+};
+
+/**
+ * Whether every claimed finding anchor was present in the exact bounded
+ * evidence shards assigned to one unit. This is stricter than checking the
+ * full pull-request diff when an oversized path spans multiple units.
+ */
+export const findingAnchorInUnitEvidence = (
+  finding: ReviewFinding,
+  unit: ReviewUnit,
+  files: ReadonlyArray<ChangedFile>,
+): boolean => {
+  const file = files.find((candidate) => candidate.path === finding.path);
+  if (file?.patch === undefined || finding.endLine < finding.startLine) return false;
+  const assignedOrdinals = new Set(
+    unit.evidenceShards
+      .filter((shard) => shard.path === finding.path)
+      .map((shard) => shard.ordinal),
+  );
+  const visibleLines = new Set<number>();
+  const chunks = fileReviewEvidenceChunks(file);
+  for (let index = 0; index < chunks.length; index += 1) {
+    if (!assignedOrdinals.has(index + 1)) continue;
+    for (const line of chunks[index]?.annotatedPatch.split("\n") ?? []) {
+      const match = /^R(\d+) /.exec(line);
+      if (match?.[1] !== undefined) visibleLines.add(Number(match[1]));
+    }
+  }
+  for (let line = finding.startLine; line <= finding.endLine; line += 1) {
+    if (!visibleLines.has(line)) return false;
+  }
+  return true;
+};
+
+interface PlannedEvidenceShard {
+  readonly shard: ReviewEvidenceShard;
+  readonly file: ChangedFile;
+  readonly changedLines: number;
+}
+
+const uniquePaths = (shards: ReadonlyArray<PlannedEvidenceShard>): ReadonlyArray<string> => [
+  ...new Set(shards.map(({ shard }) => shard.path)),
+];
+
+const plannedEvidenceShards = (
+  files: ReadonlyArray<ChangedFile>,
+): ReadonlyArray<PlannedEvidenceShard> => {
+  const planned: Array<PlannedEvidenceShard> = [];
+  let shardIndex = 0;
+  for (const file of files) {
+    const chunks = fileReviewEvidenceChunks(file);
+    for (let index = 0; index < chunks.length; index += 1) {
+      const chunk = chunks[index];
+      if (chunk === undefined) continue;
+      shardIndex += 1;
+      planned.push({
+        shard: ReviewEvidenceShard.make({
+          shardId: `shard-${String(shardIndex).padStart(4, "0")}`,
+          path: file.path,
+          ordinal: index + 1,
+          total: chunks.length,
+          evidenceChars: chunk.annotatedPatch.length,
+        }),
+        file,
+        changedLines: index === 0 ? file.additions + file.deletions : 0,
+      });
+    }
+  }
+  return planned;
 };
 
-const unitOf = (index: number, files: ReadonlyArray<ChangedFile>): ReviewUnit =>
+const unitOf = (index: number, shards: ReadonlyArray<PlannedEvidenceShard>): ReviewUnit =>
   ReviewUnit.make({
     unitId: `unit-${String(index + 1).padStart(3, "0")}`,
-    paths: files.map((file) => file.path),
-    changedLines: files.reduce((total, file) => total + file.additions + file.deletions, 0),
+    paths: uniquePaths(shards),
+    evidenceShards: shards.map(({ shard }) => shard),
+    changedLines: shards.reduce((total, shard) => total + shard.changedLines, 0),
+    evidenceChars: shards.reduce((total, { shard }) => total + shard.evidenceChars, 0),
+    riskCategories: [...new Set(shards.flatMap(({ file }) => classifyReviewRisks(file)))],
   });
 
+const discoveryPassesFor = (units: ReadonlyArray<ReviewUnit>): ReadonlyArray<ReviewDiscoveryPass> =>
+  units.flatMap((unit) => [
+    ReviewDiscoveryPass.make({
+      passId: `${unit.unitId}-general`,
+      unitId: unit.unitId,
+      paths: unit.paths,
+      evidenceShardIds: unit.evidenceShards.map((shard) => shard.shardId),
+      perspective: "general",
+      riskCategories: [],
+    }),
+    ReviewDiscoveryPass.make({
+      passId: `${unit.unitId}-specialist`,
+      unitId: unit.unitId,
+      paths: unit.paths,
+      evidenceShardIds: unit.evidenceShards.map((shard) => shard.shardId),
+      perspective: "risk-specialist",
+      riskCategories: unit.riskCategories,
+    }),
+  ]);
+
 /**
  * Group the changeset into at most `MAX_REVIEW_UNITS` review units.
  *
  * Deterministic by construction: files are ordered by path (so files sharing
  * a directory become neighbors — directory affinity without a heuristic),
- * then packed greedily in that order under the soft changed-line budget and
- * the hard per-unit file bound. Capacity is finite and explicit:
+ * then split into complete line-bounded evidence shards and packed greedily
+ * under the hard evidence and per-unit shard bounds. Capacity is finite and
+ * explicit:
  *
  * - files without a textual diff are still delegated when the source
  *   recovered complete bounded UTF-8 base/head content. Findings from that
  *   evidence cannot anchor inline and are reported as concerns;
  * - files with neither form of textual evidence surface in
  *   `undiffablePaths` instead of laundering missing coverage;
- * - reviewable files beyond `MAX_REVIEW_UNITS` full units surface in
- *   `unassignedPaths` so the review can report them as unreviewed, never
- *   silently truncated.
+ * - an oversized path spans as many deterministic shards and units as needed;
+ * - shards beyond `MAX_REVIEW_UNITS` full units surface explicitly, so a path
+ *   is partial only when finite plan capacity is genuinely exhausted.
  */
 export const planReviewUnits = (
   files: ReadonlyArray<ChangedFile>,
@@ -97,37 +370,58 @@ export const planReviewUnits = (
   const reviewable = ordered.filter(isReviewableFile);
   const undiffable = ordered.filter((file) => !isReviewableFile(file));
 
-  const groups: Array<Array<ChangedFile>> = [];
-  const unassigned: Array<ChangedFile> = [];
-  let current: Array<ChangedFile> = [];
-  let currentCost = 0;
-  for (const file of reviewable) {
-    const cost = fileCost(file);
+  const shards = plannedEvidenceShards(reviewable);
+  const groups: Array<Array<PlannedEvidenceShard>> = [];
+  const unassigned: Array<PlannedEvidenceShard> = [];
+  let current: Array<PlannedEvidenceShard> = [];
+  let currentEvidenceChars = 0;
+  for (const shard of shards) {
+    const nextPaths = new Set([...uniquePaths(current), shard.shard.path]);
     const wouldOverflow =
-      current.length >= MAX_UNIT_FILES ||
-      (current.length > 0 && currentCost + cost > UNIT_CHANGED_LINE_BUDGET);
+      current.length >= MAX_UNIT_EVIDENCE_SHARDS ||
+      nextPaths.size > MAX_UNIT_FILES ||
+      (current.length > 0 &&
+        currentEvidenceChars + shard.shard.evidenceChars > UNIT_EVIDENCE_CHAR_BUDGET);
     if (wouldOverflow) {
       groups.push(current);
       current = [];
-      currentCost = 0;
+      currentEvidenceChars = 0;
     }
     if (groups.length >= MAX_REVIEW_UNITS) {
-      unassigned.push(file);
+      unassigned.push(shard);
       continue;
     }
-    current.push(file);
-    currentCost += cost;
+    current.push(shard);
+    currentEvidenceChars += shard.shard.evidenceChars;
   }
   if (current.length > 0 && groups.length < MAX_REVIEW_UNITS) {
     groups.push(current);
   }
 
+  const units = groups.map((group, index) => unitOf(index, group));
+  const assignedShardIds = new Set(
+    units.flatMap((unit) => unit.evidenceShards.map((shard) => shard.shardId)),
+  );
+  const assignedPaths = new Set(
+    shards
+      .filter(({ shard }) => assignedShardIds.has(shard.shardId))
+      .map(({ shard }) => shard.path),
+  );
+  const unassignedPathsWithEvidence = new Set(unassigned.map(({ shard }) => shard.path));
   return ReviewUnitPlan.make({
     totalFiles: files.length,
     truncated: files.length < options.totalChangedFiles,
-    units: groups.map((group, index) => unitOf(index, group)),
+    units,
+    discoveryPasses: discoveryPassesFor(units),
     undiffablePaths: undiffable.map((file) => file.path),
-    unassignedPaths: unassigned.map((file) => file.path),
+    partialEvidencePaths: [...unassignedPathsWithEvidence].filter((path) =>
+      assignedPaths.has(path),
+    ),
+    unassignedEvidenceShardCount: unassigned.length,
+    unassignedEvidenceShardIds: unassigned
+      .slice(0, MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS)
+      .map(({ shard }) => shard.shardId),
+    unassignedPaths: [...unassignedPathsWithEvidence].filter((path) => !assignedPaths.has(path)),
   });
 };
 

package/src/internal/run.ts

@@ -10,9 +10,10 @@ import {
 import { type Tool } from "effect/unstable/ai";
 
 import {
-  assessReviewCoverage,
-  collectUnitFileSummaries,
+  assessReviewPipeline,
+  ReviewAssurance,
   ReviewCoverage,
+  ReviewInputCoverage,
   type ReviewShape,
 } from "./coverage.ts";
 import type { ChangedFile } from "./diff.ts";
@@ -66,11 +67,11 @@ export const reviewBudgetLimits = UsageBudgetLimits.make({
  * while bounded children run.
  */
 export const fanOutReviewBudgetLimits = UsageBudgetLimits.make({
-  maxInputTokens: 400_000,
-  maxOutputTokens: 16_000,
-  maxToolCalls: 24,
+  maxInputTokens: 600_000,
+  maxOutputTokens: 32_000,
+  maxToolCalls: 32,
   maxCostMicrousd: 2_000_000,
-  maxDurationMillis: 900_000,
+  maxDurationMillis: 1_200_000,
 });
 
 /** Everything one review run produced, publication receipt included. */
@@ -84,6 +85,10 @@ export class ReviewRunOutcome extends Schema.Class<ReviewRunOutcome>(
   activeConcerns: Schema.Array(ReviewConcern).check(Schema.isMaxLength(10)),
   /** Host-owned structural coverage used by the Actions check conclusion. */
   coverage: ReviewCoverage,
+  /** Exact path/evidence assignment, distinct from semantic review work. */
+  inputCoverage: ReviewInputCoverage,
+  /** Settlement of configured discovery, specialist, and verification work. */
+  assurance: ReviewAssurance,
   plan: ReviewPublicationPlan,
   published: Schema.optionalKey(PublishedReview),
   turns: Schema.Int.check(Schema.isGreaterThan(0)),
@@ -245,31 +250,30 @@ export const executeReview = <
     // The engine validated the terminal JSON against the output schema; this
     // decode recovers the typed value on this side of the generic boundary.
     const decoded = yield* Schema.decodeUnknownEffect(CodeReview)(result.output);
-    // Under fan-out, the merged walkthrough must be traceable to the children:
-    // only entries a successfully settled delegation actually reported for its
-    // OWN unit's paths survive (the flat reviewer needs no such check — its
-    // walkthrough carries the same single-agent trust as its findings, and
-    // both stay changeset-validated by planPublication).
+    const reviewTotalFiles = executionContext?.totalFiles ?? metadata.totalChangedFiles;
+    const pipeline = assessReviewPipeline({
+      shape: options.reviewShape ?? "flat",
+      files,
+      totalFiles: reviewTotalFiles,
+      anchorFiles,
+      totalAnchorFiles: metadata.totalChangedFiles,
+      events,
+    });
+    // The coordinator owns prose only. Fan-out findings and concerns are
+    // reconstructed from exact verifier-confirmed discovery candidates; an
+    // unsupported or coordinator-invented candidate cannot reach publication.
     const verifiedReview =
-      options.reviewShape !== "fan-out" || decoded.walkthrough === undefined
+      options.reviewShape !== "fan-out"
         ? decoded
-        : (() => {
-            const verified = new Set(
-              collectUnitFileSummaries(events).map(
-                (entry) => `${entry.path}\u0000${entry.summary}`,
-              ),
-            );
-            const walkthrough = decoded.walkthrough.filter((entry) =>
-              verified.has(`${entry.path}\u0000${entry.summary}`),
-            );
-            return CodeReview.make({
-              summary: decoded.summary,
-              verdict: decoded.verdict,
-              findings: decoded.findings,
-              ...(decoded.concerns !== undefined ? { concerns: decoded.concerns } : {}),
-              ...(walkthrough.length > 0 ? { walkthrough } : {}),
-            });
-          })();
+        : CodeReview.make({
+            summary: decoded.summary,
+            verdict: decoded.verdict,
+            findings: rankAndDedupeFindings(pipeline.confirmedFindings),
+            ...(pipeline.confirmedConcerns.length === 0
+              ? {}
+              : { concerns: rankAndDedupeConcerns(pipeline.confirmedConcerns) }),
+            ...(pipeline.walkthrough.length === 0 ? {} : { walkthrough: pipeline.walkthrough }),
+          });
     const review = enforceFindingsBound(verifiedReview, clampMaxFindings(options.maxFindings));
     const usage = yield* budget.snapshot;
     const affectedPaths = new Set(
@@ -311,18 +315,11 @@ export const executeReview = <
       const key = `${concern.title}\u0000${concern.body}`;
       return activeConcernKeys.has(key) && !currentConcernKeys.has(key);
     });
-    const reviewTotalFiles = executionContext?.totalFiles ?? metadata.totalChangedFiles;
-    const coverage = assessReviewCoverage({
-      shape: options.reviewShape ?? "flat",
-      files,
-      totalFiles: reviewTotalFiles,
-      anchorFiles,
-      totalAnchorFiles: metadata.totalChangedFiles,
-      events,
-    });
+    const { assurance, coverage, inputCoverage } = pipeline;
     const stateCandidate =
       executionContext !== undefined &&
-      coverage.status === "complete" &&
+      inputCoverage.status === "complete" &&
+      assurance.status === "settled" &&
       fingerprint !== undefined &&
       metadata.baseSha !== undefined &&
       executionContext.stateAuthenticator?.status === "available"
@@ -349,7 +346,8 @@ export const executeReview = <
             marker: undefined,
             notice:
               executionContext?.stateAuthenticator?.status === "unavailable" &&
-              coverage.status === "complete"
+              inputCoverage.status === "complete" &&
+              assurance.status === "settled"
                 ? (executionContext.stateAuthenticator.unavailableReason ??
                   "authenticated continuity state is unavailable")
                 : undefined,
@@ -377,8 +375,13 @@ export const executeReview = <
       runUrl: options.runUrl,
       usage,
       usageScope: options.usageScope,
-      fingerprint: coverage.status === "complete" ? fingerprint : undefined,
+      fingerprint:
+        inputCoverage.status === "complete" && assurance.status === "settled"
+          ? fingerprint
+          : undefined,
       coverage,
+      inputCoverage,
+      assurance,
       carriedFindings,
       carriedConcerns,
       reviewMode: executionContext?.mode,
@@ -398,6 +401,8 @@ export const executeReview = <
         activeFindings,
         activeConcerns,
         coverage,
+        inputCoverage,
+        assurance,
         plan,
         turns: result.turns,
         usage,
@@ -415,6 +420,8 @@ export const executeReview = <
       activeFindings,
       activeConcerns,
       coverage,
+      inputCoverage,
+      assurance,
       plan,
       published,
       turns: result.turns,