@codraoss/core 0.9.4 → 0.9.5

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   dedupeFindings
-} from "./chunk-XD6CGYHO.js";
+} from "./chunk-2TF4DSRX.js";
 import {
   InMemoryKV,
   InMemoryOrchestrator,
@@ -8,17 +8,33 @@ import {
   InMemorySessionStore
 } from "./chunk-JC74XH7Q.js";
 import {
-  renderFileDiff
-} from "./chunk-MMVQPGK3.js";
-import "./chunk-RQ5S67XB.js";
+  ruleHitsToComments,
+  scanFileForRuleHits
+} from "./chunk-754NO4DH.js";
+import "./chunk-JAF7JIZQ.js";
+import {
+  changelogExcerptFromDiff,
+  renderFileDiff,
+  reviewBreadth,
+  wantsFileContext
+} from "./chunk-ONJZXUQT.js";
+import {
+  getLanguageForFile
+} from "./chunk-FKRCBUWZ.js";
 import {
   parseVerifyResponse,
   renderDiffSnippet
-} from "./chunk-V3RF6GQW.js";
+} from "./chunk-KTDBDKL5.js";
+import "./chunk-IKVUW4WC.js";
+import "./chunk-XPYVLHSX.js";
+import "./chunk-QPPLO2YV.js";
 import {
-  ruleHitsToComments,
-  scanFileForRuleHits
-} from "./chunk-ILZUCIZH.js";
+  logger
+} from "./chunk-Z5B5X7QP.js";
+import {
+  filterReviewableFiles,
+  parseUnifiedDiff
+} from "./chunk-I5S3NBFL.js";
 import {
   ASYNC_BATCH_POLL_DELAY_SECONDS,
   BIN_DIFF_CHAR_BUDGET,
@@ -27,6 +43,8 @@ import {
   BUSY_RETRY_SECONDS,
   DIFF_CACHE_TTL_SECONDS,
   FILE_FIXED_SUBREQUESTS,
+  FRAGMENTED_HUNK_THRESHOLD,
+  FRAGMENTED_MIN_LINES,
   FRESH_INVOCATION_YIELD_SECONDS,
   JOB_LEASE_SECONDS,
   MAX_FINALIZE_CONTINUATIONS,
@@ -38,18 +56,7 @@ import {
   RETRYABLE_MODEL_FAILURE_RETRY_DELAYS_SECONDS,
   REVIEW_CHUNK_WALL_CLOCK_MS,
   VERIFY_MIN_ANSWER_RATIO
-} from "./chunk-FGXA7JNR.js";
-import "./chunk-R2HRWFRH.js";
-import "./chunk-U3VKVDZ7.js";
-import "./chunk-NSTV4TRP.js";
-import "./chunk-PVXFURDR.js";
-import {
-  logger
-} from "./chunk-WSK45HW4.js";
-import {
-  filterReviewableFiles,
-  parseUnifiedDiff
-} from "./chunk-OIQRTDYR.js";
+} from "./chunk-W3RY755V.js";
 
 // src/review/index.ts
 import "@codraoss/schema/webhook";
@@ -140,13 +147,15 @@ async function getOrFetchRawDiffForCompletedJob(env, job, github) {
 }
 
 // src/review/budget.ts
-function budgetAwareFileLimit(remainingSafeBudget, configuredChunkFileLimit, modelChainLength = 1) {
-  const budgetLimit = Math.floor(remainingSafeBudget / estimatedSubrequestsPerFile(modelChainLength));
-  return Math.min(configuredChunkFileLimit, budgetLimit);
+function budgetAwareFileLimit(remainingSafeBudget, configuredChunkFileLimit, modelChainLength = 1, fetchesFileContent = false, runsSecondaryReviewer = false) {
+  const budgetLimit = Math.floor(
+    remainingSafeBudget / estimatedSubrequestsPerFile(modelChainLength, fetchesFileContent, runsSecondaryReviewer)
+  );
+  return Math.max(remainingSafeBudget > 0 ? 1 : 0, Math.min(configuredChunkFileLimit, budgetLimit));
 }
-function estimatedSubrequestsPerFile(modelChainLength) {
+function estimatedSubrequestsPerFile(modelChainLength, fetchesFileContent = false, runsSecondaryReviewer = false) {
   const modelAttempts = Math.max(1, Math.min(modelChainLength, MAX_MODEL_ATTEMPTS_ESTIMATE));
-  return FILE_FIXED_SUBREQUESTS + modelAttempts;
+  return FILE_FIXED_SUBREQUESTS + modelAttempts * (runsSecondaryReviewer ? 2 : 1) + (fetchesFileContent ? 1 : 0);
 }
 
 // src/review/pack.ts
@@ -154,6 +163,9 @@ function unitFiles(unit) {
   return unit.kind === "single" ? [unit.file] : unit.files;
 }
 var measure = (file) => renderFileDiff(file).length;
+function isFragmented(file) {
+  return file.hunks.length >= FRAGMENTED_HUNK_THRESHOLD && file.lineCount >= FRAGMENTED_MIN_LINES && !file.isNew;
+}
 var asBin = (files) => files.length === 1 ? { kind: "single", file: files[0] } : {
   kind: "bin",
   files,
@@ -174,7 +186,8 @@ function planReviewUnits(files, opts) {
   };
   for (const file of files) {
     const fileChars = measure(file);
-    if (file.lineCount > PACKABLE_MAX_DIFF_LINES || fileChars > BIN_DIFF_CHAR_BUDGET) {
+    const promoteForContext = opts.fullFileContext === true && isFragmented(file);
+    if (promoteForContext || file.lineCount > PACKABLE_MAX_DIFF_LINES || fileChars > BIN_DIFF_CHAR_BUDGET) {
       close();
       units.push({ kind: "single", file });
       continue;
@@ -377,20 +390,49 @@ function scanRuleChannel(file, config) {
     return { comments: [], stats: null };
   }
 }
-async function reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, previousReview, rejectedExemplars = []) {
+function tagReviewer(comments, reviewerModel) {
+  return comments.map((comment) => ({ ...comment, reviewerModel }));
+}
+async function runSecondaryReview(model, params, secondary, path) {
+  try {
+    return await model.reviewFile({
+      ...params,
+      config: {
+        ...params.config,
+        model: { ...params.config.model, main: secondary.model, fallbacks: secondary.fallbacks }
+      }
+    });
+  } catch (error) {
+    logger.warn(`Secondary reviewer failed for ${path}; keeping the primary review`, {
+      model: secondary.model,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+async function reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, previousReview, rejectedExemplars = [], changelogExcerpt = null, fileContext = null) {
   const startedAt = env.clock.now();
   const compactPrompt = (previousReview?.transient_error_count ?? 0) > 0;
   const ruleScan = scanRuleChannel(file, config);
   try {
-    const response = await model.reviewFile({
+    const reviewParams = {
       file,
+      fileContext,
       prTitle: pr.title ?? null,
       prDescription: pr.body ?? null,
+      changelogExcerpt,
       config,
       totalLineCount,
       compactPrompt,
       rejectedExemplars
-    });
+    };
+    const response = await model.reviewFile(reviewParams);
+    const secondary = config.model?.secondary ?? null;
+    const secondaryReview = secondary && !compactPrompt ? await runSecondaryReview(model, reviewParams, secondary, file.path) : null;
+    const llmComments = [
+      ...tagReviewer(response.parsed.comments, response.modelUsed),
+      ...secondaryReview ? tagReviewer(secondaryReview.parsed.comments, secondaryReview.modelUsed) : []
+    ];
     await env.fileReviews.upsertFileReview(job.id, {
       filePath: file.path,
       fileStatus: "done",
@@ -399,9 +441,11 @@ async function reviewAndPersistFile(env, job, file, pr, config, totalLineCount,
       diffLineCount: file.lineCount,
       diffInput: null,
       rawAiOutput: response.rawText,
-      parsedComments: [...response.parsed.comments, ...ruleScan.comments],
-      inputTokens: response.inputTokens,
-      outputTokens: response.outputTokens,
+      // One row per file, always: `file_reviews` is unique on (job_id, file_path), and review
+      // inheritance, resume and finalize all assume that. The two reviewers merge into it.
+      parsedComments: [...llmComments, ...ruleScan.comments],
+      inputTokens: response.inputTokens + (secondaryReview?.inputTokens ?? 0),
+      outputTokens: response.outputTokens + (secondaryReview?.outputTokens ?? 0),
       durationMs: env.clock.now() - startedAt,
       verdict: response.parsed.verdict,
       fileSummary: response.parsed.fileSummary,
@@ -410,8 +454,17 @@ async function reviewAndPersistFile(env, job, file, pr, config, totalLineCount,
       errorMessage: null,
       withheldCounts: {
         evidence: (response.parsed.evidenceStats?.unmatched ?? 0) + (response.parsed.evidenceStats?.absent ?? 0) + (response.parsed.evidenceStats?.weak ?? 0),
-        claimDenied: Object.values(response.parsed.deniedClaimCounts ?? {}).reduce((sum, n) => sum + n, 0)
-      }
+        claimDenied: Object.values(response.parsed.deniedClaimCounts ?? {}).reduce((sum, n) => sum + n, 0),
+        // Findings about code the diff never touched. Counted apart from the evidence gate: those are
+        // findings whose quote could not be found at all, these are ones that were found in the wrong
+        // place, and only the second number says anything about how the reviewer is misreading a PR.
+        contextOnly: response.parsed.evidenceStats?.contextOnly ?? 0,
+        // "X is missing", answered by finding X. Counted so the gate's real hit rate is visible.
+        absenceRefuted: response.parsed.absenceCheckStats?.refuted ?? 0
+      },
+      // Only logged until now, which made "how often did a review run unconstrained or truncated?"
+      // unanswerable without reading the logs of every job one at a time.
+      degraded: response.degraded ?? null
     });
     logger.info(`File review parsed: ${file.path}`, {
       jobId: job.id,
@@ -513,7 +566,7 @@ function proportionalSplit(total, weights) {
   }
   return parts;
 }
-async function reviewAndPersistBin(env, job, files, pr, config, totalLineCount, model, resolveFailureModelProvider, rejectedExemplars = []) {
+async function reviewAndPersistBin(env, job, files, pr, config, totalLineCount, model, resolveFailureModelProvider, rejectedExemplars = [], changelogExcerpt = null) {
   const startedAt = env.clock.now();
   const ruleScans = new Map(files.map((file) => [file.path, scanRuleChannel(file, config)]));
   const persisted = /* @__PURE__ */ new Set();
@@ -539,6 +592,7 @@ async function reviewAndPersistBin(env, job, files, pr, config, totalLineCount,
       files,
       prTitle: pr.title ?? null,
       prDescription: pr.body ?? null,
+      changelogExcerpt,
       config,
       totalLineCount,
       rejectedExemplars
@@ -569,8 +623,12 @@ async function reviewAndPersistBin(env, job, files, pr, config, totalLineCount,
         errorMessage: null,
         withheldCounts: {
           evidence: (parsed.evidenceStats?.unmatched ?? 0) + (parsed.evidenceStats?.absent ?? 0) + (parsed.evidenceStats?.weak ?? 0),
-          claimDenied: Object.values(parsed.deniedClaimCounts ?? {}).reduce((sum, n) => sum + n, 0)
+          claimDenied: Object.values(parsed.deniedClaimCounts ?? {}).reduce((sum, n) => sum + n, 0),
+          contextOnly: parsed.evidenceStats?.contextOnly ?? 0,
+          absenceRefuted: parsed.absenceCheckStats?.refuted ?? 0
         },
+        // The whole bin shared one call, so every member inherits its degradation.
+        degraded: response.degraded ?? null,
         batchSize: files.length
       };
     });
@@ -694,14 +752,19 @@ function shadowEvaluate(candidates, posted) {
     dropUnmatchedEvidence: count((c) => !c.evidence)
   };
 }
-function verifyCandidateLimit(effectiveMaxComments) {
-  return Math.min(40, Math.max(10, effectiveMaxComments * 3));
+function verifyCandidateLimit(breadth) {
+  return Math.min(40, Math.max(10, breadth * 3));
 }
 async function verifyFindings(params) {
   const { comments, files, model, config, job } = params;
-  const keepAll = () => ({ comments, dropped: [], reasons: /* @__PURE__ */ new Map() });
-  if (comments.length === 0) return keepAll();
-  const limit = verifyCandidateLimit(params.maxCandidates ?? config.review.max_comments);
+  const keepAll = (skipped) => ({
+    comments,
+    dropped: [],
+    reasons: /* @__PURE__ */ new Map(),
+    skipped
+  });
+  if (comments.length === 0) return keepAll(null);
+  const limit = verifyCandidateLimit(params.maxCandidates ?? reviewBreadth(config.review));
   const toVerify = comments.slice(0, limit);
   const fileByPath = new Map(files.map((file) => [file.path, file]));
   const prepared = toVerify.map((comment) => ({
@@ -709,7 +772,7 @@ async function verifyFindings(params) {
     snippet: renderDiffSnippet(fileByPath.get(comment.path), comment.line ?? void 0)
   }));
   const verifiable = prepared.filter((entry) => entry.snippet !== "" || entry.comment.evidence);
-  if (verifiable.length === 0) return keepAll();
+  if (verifiable.length === 0) return keepAll("no_verifiable_candidates");
   const candidates = verifiable.map((entry, index) => ({
     index,
     path: entry.comment.path,
@@ -742,7 +805,7 @@ async function verifyFindings(params) {
         candidates: candidates.length,
         answered
       });
-      return keepAll();
+      return keepAll("low_answer_ratio");
     }
     const dropped = [];
     const reasons = /* @__PURE__ */ new Map();
@@ -769,13 +832,13 @@ async function verifyFindings(params) {
       dropped: dropped.length,
       topReasons: dropped.slice(0, 5).map((drop) => drop.reason)
     });
-    return { comments: comments.filter((comment) => !droppedSet.has(comment)), dropped, reasons };
+    return { comments: comments.filter((comment) => !droppedSet.has(comment)), dropped, reasons, skipped: null };
   } catch (error) {
     logger.warn("Verification pass failed; posting pre-verification findings", {
       jobId: job.id,
       error: error instanceof Error ? error.message : String(error)
     });
-    return keepAll();
+    return keepAll("verify_call_failed");
   }
 }
 
@@ -841,6 +904,50 @@ async function loadRejectedExemplars(env, job) {
 
 // src/review/phase.ts
 import { defaultRepoConfig as defaultRepoConfig2, REVIEW_CONCURRENCY_LIMITS } from "@codraoss/schema";
+
+// src/review/file-context.ts
+var VALIDATION_SAMPLES = 5;
+function contentMatchesDiff(file, content) {
+  const lines = content.split("\n");
+  const samples = [];
+  for (const hunk of file.hunks) {
+    for (const line of hunk.lines) {
+      if (line.kind === "del" || typeof line.newLineNumber !== "number") continue;
+      if (!line.content.trim()) continue;
+      samples.push({ newLineNumber: line.newLineNumber, content: line.content });
+    }
+  }
+  if (samples.length === 0) return false;
+  const step = Math.max(1, Math.floor(samples.length / VALIDATION_SAMPLES));
+  for (let i = 0; i < samples.length; i += step) {
+    const sample = samples[i];
+    if (lines[sample.newLineNumber - 1] !== sample.content) return false;
+  }
+  return true;
+}
+async function loadFileContext(github, job, file, onFetch) {
+  if (!github.getRepoFile) return null;
+  let content;
+  try {
+    onFetch?.();
+    content = await github.getRepoFile(job.owner, job.repo, file.path, job.commitSha);
+  } catch (error) {
+    logger.warn(`Could not fetch file content for ${file.path}; reviewing the diff alone`, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+  if (!content) return null;
+  if (!contentMatchesDiff(file, content)) {
+    logger.warn(`Fetched content for ${file.path} does not line up with the diff; reviewing the diff alone`, {
+      commitSha: job.commitSha
+    });
+    return null;
+  }
+  return content;
+}
+
+// src/review/phase.ts
 async function runReviewPhase(env, job, leaseOwner, github, model, tracker) {
   if (!hasCompletedStep(job, "Preparation")) {
     await runPreparePhase(env, job, leaseOwner, github);
@@ -861,12 +968,16 @@ async function runReviewPhase(env, job, leaseOwner, github, model, tracker) {
   const { concurrencyLevel, maxFiles } = await env.settings.getReviewSettings();
   const { files } = await getDiffFiles(env, job, github, config, maxFiles);
   const totalLineCount = files.reduce((sum, file) => sum + file.lineCount, 0);
+  const changelogExcerpt = changelogExcerptFromDiff(files);
   const configuredChunkFileLimit = REVIEW_CONCURRENCY_LIMITS[concurrencyLevel];
   const modelChainLength = 1 + (config.model.fallbacks?.length ?? 0);
   const reviewChunkFileLimit = budgetAwareFileLimit(
     tracker.remainingSafeBudget(),
     configuredChunkFileLimit,
-    modelChainLength
+    modelChainLength,
+    config.review.full_file_context,
+    // A second reviewer walks its own chain per file, so fewer files fit in one invocation.
+    Boolean(config.model?.secondary)
   );
   if (reviewChunkFileLimit <= 0) {
     throw new Error("Subrequest budget for this invocation was exhausted before starting the next review chunk.");
@@ -917,7 +1028,7 @@ async function runReviewPhase(env, job, leaseOwner, github, model, tracker) {
         transientErrorCount: existing?.transient_error_count ?? 0
       }];
     }));
-    const units = planReviewUnits(files, { enabled: true }).flatMap((unit) => narrowUnit(unit, ledger));
+    const units = planReviewUnits(files, { enabled: true, fullFileContext: config.review.full_file_context }).flatMap((unit) => narrowUnit(unit, ledger));
     const plannedBins = units.filter((unit) => unit.kind === "bin");
     let binsDispatched = 0;
     let filesDispatchedInBins = 0;
@@ -927,7 +1038,7 @@ async function runReviewPhase(env, job, leaseOwner, github, model, tracker) {
       const binFiles = unit.kind === "bin" ? unit.files : [];
       binFiles.forEach((file) => binnedPaths.add(file.path));
       reviewTasks.push((async () => {
-        const terminal = await reviewAndPersistBin(env, job, binFiles, pr, config, totalLineCount, model, resolveFailureModelProvider, rejectedExemplars);
+        const terminal = await reviewAndPersistBin(env, job, binFiles, pr, config, totalLineCount, model, resolveFailureModelProvider, rejectedExemplars, changelogExcerpt);
         terminalProgress += terminal;
       })());
       processedThisChunk += 1;
@@ -955,6 +1066,16 @@ async function runReviewPhase(env, job, leaseOwner, github, model, tracker) {
       continue;
     }
     const inherited = parentReviews.get(file.path);
+    let fileContextPromise = null;
+    const fileContextFor = () => {
+      if (!wantsFileContext(file, config.review.full_file_context, {
+        compactPrompt: (existingReview?.transient_error_count ?? 0) > 0
+      })) {
+        return Promise.resolve(null);
+      }
+      fileContextPromise ??= loadFileContext(github, job, file, () => tracker.incrementSubrequests(1));
+      return fileContextPromise;
+    };
     const reviewTask = async () => {
       if (awaitingReview) {
         const poll = await model.pollReviewBatch({
@@ -971,7 +1092,7 @@ async function runReviewPhase(env, job, leaseOwner, github, model, tracker) {
           logger.warn(`Async batch poll failed for ${file.path}; falling back to synchronous review`, {
             error: poll.error instanceof Error ? poll.error.message : String(poll.error)
           });
-          await reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, existingReview, rejectedExemplars);
+          await reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, existingReview, rejectedExemplars, changelogExcerpt, await fileContextFor());
           terminalProgress += 1;
           return;
         }
@@ -982,8 +1103,10 @@ async function runReviewPhase(env, job, leaseOwner, github, model, tracker) {
       if (!inherited) {
         const submitted = await model.submitReviewBatch({
           file,
+          fileContext: await fileContextFor(),
           prTitle: pr.title ?? null,
           prDescription: pr.body ?? null,
+          changelogExcerpt,
           config,
           totalLineCount,
           compactPrompt: (existingReview?.transient_error_count ?? 0) > 0
@@ -1012,13 +1135,13 @@ async function runReviewPhase(env, job, leaseOwner, github, model, tracker) {
           awaitingAsync += 1;
           return;
         }
-        await reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, existingReview, rejectedExemplars);
+        await reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, existingReview, rejectedExemplars, changelogExcerpt, await fileContextFor());
         terminalProgress += 1;
         return;
       }
       if (!canInheritParentFileReview(config, inherited)) {
         logger.info(`Ignoring inherited review for ${file.path}; parent model ${inherited.model_used} is not in the current model strategy`);
-        await reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, existingReview, rejectedExemplars);
+        await reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, existingReview, rejectedExemplars, changelogExcerpt, await fileContextFor());
         terminalProgress += 1;
       } else {
         await env.fileReviews.upsertFileReview(job.id, {
@@ -1187,6 +1310,20 @@ async function applyFindingGates(params) {
   const severityRanks = { P0: 0, P1: 1, P2: 2, P3: 3, nit: 4 };
   const minRank = severityRanks[config.review.min_severity] ?? 4;
   const minConfidence = config.review.min_confidence ?? 0;
+  const languageGates = config.review.language_gates ?? {};
+  const gatesByLanguage = new Map(
+    Object.entries(languageGates).map(([language, gate]) => [language.toLowerCase(), gate])
+  );
+  const thresholdsFor = (path) => {
+    if (gatesByLanguage.size === 0) return { minRank, minConfidence };
+    const language = getLanguageForFile(path)?.language;
+    const override = language ? gatesByLanguage.get(language.toLowerCase()) : void 0;
+    if (!override) return { minRank, minConfidence };
+    return {
+      minRank: override.min_severity ? severityRanks[override.min_severity] ?? 4 : minRank,
+      minConfidence: override.min_confidence ?? minConfidence
+    };
+  };
   const dispositions = /* @__PURE__ */ new Map();
   const verifyReasons = /* @__PURE__ */ new Map();
   const recordDisposition = (comments, stage) => {
@@ -1197,11 +1334,12 @@ async function applyFindingGates(params) {
     }
   };
   let finalComments = reviewedComments.filter((c) => {
-    if ((severityRanks[c.severity] ?? 4) > minRank) {
+    const thresholds = thresholdsFor(c.path);
+    if ((severityRanks[c.severity] ?? 4) > thresholds.minRank) {
       recordDisposition([c], "severity");
       return false;
     }
-    if (typeof c.confidenceScore === "number" && c.confidenceScore < minConfidence) {
+    if (typeof c.confidenceScore === "number" && c.confidenceScore < thresholds.minConfidence) {
       recordDisposition([c], "confidence");
       return false;
     }
@@ -1234,7 +1372,7 @@ async function applyFindingGates(params) {
     return (b.confidenceScore ?? 0) - (a.confidenceScore ?? 0);
   });
   const beforeVerifyList = finalComments;
-  const verify = await verifyFindings({ job, config, files, comments: finalComments, model, maxCandidates: effectiveMaxComments });
+  const verify = await verifyFindings({ job, config, files, comments: finalComments, model, maxCandidates: reviewBreadth(config.review) });
   finalComments = verify.comments;
   const droppedByVerification = verify.dropped.length;
   for (const drop of verify.dropped) recordDisposition([drop.comment], drop.disposition);
@@ -1251,7 +1389,7 @@ async function applyFindingGates(params) {
   const omittedCount = reviewedComments.length - finalComments.length;
   const droppedByFilters = omittedCount - droppedBySuppression - droppedByVerification - droppedByCap;
   const withheldByParser = reviews.reduce(
-    (sum, review) => sum + (review.withheld_counts?.evidence ?? 0) + (review.withheld_counts?.claimDenied ?? 0),
+    (sum, review) => sum + (review.withheld_counts?.evidence ?? 0) + (review.withheld_counts?.claimDenied ?? 0) + (review.withheld_counts?.contextOnly ?? 0) + (review.withheld_counts?.absenceRefuted ?? 0),
     0
   );
   const byClaimType = {};
@@ -1269,6 +1407,9 @@ async function applyFindingGates(params) {
     finalComments,
     dispositions,
     verifyReasons,
+    // Non-null means these findings were never checked. The caller records it on the job, so a review
+    // that skipped verification stops looking identical to one that passed it.
+    verificationSkipped: verify.skipped,
     suppressedComments,
     droppedBySuppression,
     beforeVerifyList,
@@ -1282,6 +1423,17 @@ async function applyFindingGates(params) {
 }
 
 // src/review/finalize.ts
+function partialReviewMessage(input) {
+  const plural = (n) => n === 1 ? "" : "s";
+  const reasons = [];
+  if (input.failedFileCount > 0) {
+    reasons.push(`${input.failedFileCount} of ${input.reviewedFileCount} file${plural(input.reviewedFileCount)} could not be reviewed`);
+  }
+  if (input.filesOverCap > 0) {
+    reasons.push(`${input.filesOverCap} file${plural(input.filesOverCap)} left out by the file and diff-size limits`);
+  }
+  return reasons.length > 0 ? `Partial review: ${reasons.join("; ")}.` : null;
+}
 async function runFinalizePhase(env, job, leaseOwner, github, formatter, model) {
   await env.jobs.updateJobStep(job.id, "Generating Summary", { status: "running" });
   const pr = await github.getPullRequest(job.owner, job.repo, job.prNumber);
@@ -1333,10 +1485,12 @@ async function runFinalizePhase(env, job, leaseOwner, github, formatter, model)
   }
   const hasFailures = fileSummaries.some((file) => file.verdict === "failed");
   const failedFileCount = fileSummaries.filter((file) => file.verdict === "failed").length;
+  await env.jobs.updateJobStep(job.id, "Verifying Findings", { status: "running" });
   const {
     finalComments,
     dispositions,
     verifyReasons,
+    verificationSkipped,
     suppressedComments,
     droppedBySuppression,
     beforeVerifyList,
@@ -1359,6 +1513,7 @@ async function runFinalizePhase(env, job, leaseOwner, github, formatter, model)
   logger.info("Finding pipeline outcome", {
     jobId: job.id,
     parsed: reviewedComments.length,
+    verificationSkipped,
     droppedByFilters,
     droppedBySuppression,
     droppedByVerification,
@@ -1381,17 +1536,27 @@ async function runFinalizePhase(env, job, leaseOwner, github, formatter, model)
     jobId: job.id,
     ...shadowEvaluate(beforeVerifyList, finalComments)
   });
+  await env.jobs.updateJobStep(job.id, "Verifying Findings", verificationSkipped ? { status: "failed", error: `Verification did not run (${verificationSkipped}); findings were posted unverified.` } : { status: "done" });
   const rawVerdict = formatter.summarizeVerdict([...finalComments, ...suppressedComments], hasFailures);
   const everythingWithheld = finalComments.length === 0 && suppressedComments.length === 0 && (withheldByParser > 0 || omittedCount > 0);
   const verdictSummary = everythingWithheld && rawVerdict.verdict === "approve" ? { ...rawVerdict, verdict: "comment" } : rawVerdict;
   await env.jobs.updateJobStep(job.id, "Generating Summary", { status: "done" });
   await heartbeatAndCheckSuperseded(env, job.id, leaseOwner);
-  let formattedSummary = formatter.formatReviewOverview(pr.head.sha, env.botUsername);
+  const formattedSummary = formatter.formatReviewOverview({
+    commitSha: pr.head.sha,
+    postedFindings: finalComments.length,
+    filesReviewed: files.length,
+    linesReviewed: files.reduce((sum, file) => sum + file.lineCount, 0),
+    withheldFindings: withheldByParser + droppedByFilters + droppedByVerification,
+    filesFailed: failedFileCount
+  });
   if (filesOverCap > 0) {
-    formattedSummary += `
-
-> [!WARNING]
-> **${filesOverCap} file${filesOverCap === 1 ? " was" : "s were"} not reviewed.** This pull request has ${files.length + filesOverCap} reviewable files and the limit is ${reviewSettings.maxFiles}. Raise it in Settings to cover the whole diff.`;
+    logger.info("Some reviewable files were skipped by the file or diff-size limits", {
+      jobId: job.id,
+      filesOverCap,
+      reviewed: files.length,
+      maxFiles: reviewSettings.maxFiles
+    });
   }
   const finalizeRetriedPastPost = job.steps.some(
     (step) => step.name === "Completing" && (step.status === "running" || step.status === "done")
@@ -1414,6 +1579,16 @@ async function runFinalizePhase(env, job, leaseOwner, github, formatter, model)
     const postedFingerprints = review.postedIndices.map((index) => finalComments[index]?.fingerprint).filter((fingerprint) => Boolean(fingerprint));
     await env.fileReviews.markCommentsPosted(job.id, postedFingerprints);
   }
+  if (finalComments.length === 0 && github.addIssueReaction) {
+    try {
+      await github.addIssueReaction(job.owner, job.repo, job.prNumber, "+1");
+    } catch (error) {
+      logger.warn("Could not react to the pull request", {
+        jobId: job.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   try {
     const withReasons = /* @__PURE__ */ new Map();
     for (const fingerprint of /* @__PURE__ */ new Set([...dispositions.keys(), ...verifyReasons.keys()])) {
@@ -1436,7 +1611,11 @@ async function runFinalizePhase(env, job, leaseOwner, github, formatter, model)
     const sev = comment.severity || "unknown";
     severityDistribution[sev] = (severityDistribution[sev] || 0) + 1;
   }
-  const partialErrorMessage = hasFailures ? `Partial review: ${failedFileCount} of ${files.length} file${files.length === 1 ? "" : "s"} could not be reviewed.` : null;
+  const partialErrorMessage = partialReviewMessage({
+    failedFileCount: hasFailures ? failedFileCount : 0,
+    reviewedFileCount: files.length,
+    filesOverCap
+  });
   await env.jobs.completeJob(job.id, {
     verdict: verdictSummary.verdict,
     fileCount: files.length,