@codraoss/core 0.9.4

package/dist/index.js

@@ -0,0 +1,1755 @@
+import {
+  dedupeFindings
+} from "./chunk-XD6CGYHO.js";
+import {
+  InMemoryKV,
+  InMemoryOrchestrator,
+  InMemoryQueue,
+  InMemorySessionStore
+} from "./chunk-JC74XH7Q.js";
+import {
+  renderFileDiff
+} from "./chunk-MMVQPGK3.js";
+import "./chunk-RQ5S67XB.js";
+import {
+  parseVerifyResponse,
+  renderDiffSnippet
+} from "./chunk-V3RF6GQW.js";
+import {
+  ruleHitsToComments,
+  scanFileForRuleHits
+} from "./chunk-ILZUCIZH.js";
+import {
+  ASYNC_BATCH_POLL_DELAY_SECONDS,
+  BIN_DIFF_CHAR_BUDGET,
+  BIN_MAX_FILES,
+  BIN_TARGET_DIFF_LINES,
+  BUSY_RETRY_SECONDS,
+  DIFF_CACHE_TTL_SECONDS,
+  FILE_FIXED_SUBREQUESTS,
+  FRESH_INVOCATION_YIELD_SECONDS,
+  JOB_LEASE_SECONDS,
+  MAX_FINALIZE_CONTINUATIONS,
+  MAX_JOB_CONTINUATIONS,
+  MAX_MODEL_ATTEMPTS_ESTIMATE,
+  MAX_RETRYABLE_FILE_REVIEW_FAILURES,
+  MISSING_FILE_ERROR,
+  PACKABLE_MAX_DIFF_LINES,
+  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";
+
+// src/review/index.ts
+import "@codraoss/schema/webhook";
+import { REVIEW_CONCURRENCY_LIMITS as REVIEW_CONCURRENCY_LIMITS2 } from "@codraoss/schema";
+
+// src/review/request.ts
+function shouldTriggerFromChangeRequest(action, config) {
+  return config.on.includes(action);
+}
+function extractReviewRequest(input) {
+  if (input.eventName === "change_request") {
+    const payload = input.payload;
+    if (input.config.review.ignore_drafts && payload.changeRequest.draft) {
+      return null;
+    }
+    if (!shouldTriggerFromChangeRequest(payload.action, input.config.review)) {
+      return null;
+    }
+    return {
+      installationId: payload.installationId,
+      owner: payload.repository.owner,
+      repo: payload.repository.name,
+      prNumber: payload.changeRequest.number,
+      prTitle: payload.changeRequest.title,
+      prAuthor: payload.changeRequest.author,
+      commitSha: payload.changeRequest.head.sha,
+      baseSha: payload.changeRequest.base.sha,
+      headRef: payload.changeRequest.head.ref,
+      baseRef: payload.changeRequest.base.ref,
+      trigger: "auto"
+    };
+  }
+  if (input.eventName === "comment") {
+    const payload = input.payload;
+    const mentionTrigger = input.config.review.mention_trigger;
+    if (!payload.issue.isChangeRequest || payload.action !== "created" || !mentionTrigger) {
+      return null;
+    }
+    if (!payload.comment.body.includes(mentionTrigger)) {
+      return null;
+    }
+    return {
+      installationId: payload.installationId,
+      owner: payload.repository.owner,
+      repo: payload.repository.name,
+      prNumber: payload.issue.number,
+      prTitle: null,
+      prAuthor: null,
+      commitSha: "",
+      baseSha: "",
+      headRef: null,
+      baseRef: null,
+      trigger: "mention"
+    };
+  }
+  return null;
+}
+
+// src/review/diff-cache.ts
+import { reviewMaxFilesRange } from "@codraoss/schema";
+function diffCacheKey(jobId) {
+  return `diff:${jobId}`;
+}
+async function getDiffFiles(env, job, github, config, maxFiles = reviewMaxFilesRange.default) {
+  const cacheKey = diffCacheKey(job.id);
+  let rawDiff = await env.kv.get(cacheKey);
+  if (!rawDiff) {
+    rawDiff = await github.getPullRequestDiff(job.owner, job.repo, job.prNumber);
+    try {
+      await env.kv.put(cacheKey, rawDiff, { expirationTtl: DIFF_CACHE_TTL_SECONDS });
+    } catch (error) {
+      logger.warn(`Failed to cache PR diff for job ${job.id}; it will be re-fetched on the next phase`, error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  return filterReviewableFiles(parseUnifiedDiff(rawDiff, config.review), config.review, maxFiles);
+}
+async function getOrFetchRawDiffForCompletedJob(env, job, github) {
+  const cacheKey = diffCacheKey(job.id);
+  const cached = await env.kv.get(cacheKey);
+  if (cached) return cached;
+  const rawDiff = await github.getCompareDiff(job.owner, job.repo, job.baseSha, job.commitSha);
+  try {
+    await env.kv.put(cacheKey, rawDiff, { expirationTtl: DIFF_CACHE_TTL_SECONDS });
+  } catch (error) {
+    logger.warn(`Failed to cache reconstructed diff for job ${job.id}`, error instanceof Error ? error : new Error(String(error)));
+  }
+  return rawDiff;
+}
+
+// src/review/budget.ts
+function budgetAwareFileLimit(remainingSafeBudget, configuredChunkFileLimit, modelChainLength = 1) {
+  const budgetLimit = Math.floor(remainingSafeBudget / estimatedSubrequestsPerFile(modelChainLength));
+  return Math.min(configuredChunkFileLimit, budgetLimit);
+}
+function estimatedSubrequestsPerFile(modelChainLength) {
+  const modelAttempts = Math.max(1, Math.min(modelChainLength, MAX_MODEL_ATTEMPTS_ESTIMATE));
+  return FILE_FIXED_SUBREQUESTS + modelAttempts;
+}
+
+// src/review/pack.ts
+function unitFiles(unit) {
+  return unit.kind === "single" ? [unit.file] : unit.files;
+}
+var measure = (file) => renderFileDiff(file).length;
+var asBin = (files) => files.length === 1 ? { kind: "single", file: files[0] } : {
+  kind: "bin",
+  files,
+  diffLineCount: files.reduce((sum, f) => sum + f.lineCount, 0),
+  diffChars: files.reduce((sum, f) => sum + measure(f), 0)
+};
+function planReviewUnits(files, opts) {
+  if (!opts.enabled) return files.map((file) => ({ kind: "single", file }));
+  const units = [];
+  let open = [];
+  let lines = 0;
+  let chars = 0;
+  const close = () => {
+    if (open.length > 0) units.push(asBin(open));
+    open = [];
+    lines = 0;
+    chars = 0;
+  };
+  for (const file of files) {
+    const fileChars = measure(file);
+    if (file.lineCount > PACKABLE_MAX_DIFF_LINES || fileChars > BIN_DIFF_CHAR_BUDGET) {
+      close();
+      units.push({ kind: "single", file });
+      continue;
+    }
+    if (open.length > 0 && (lines + file.lineCount > BIN_TARGET_DIFF_LINES || chars + fileChars > BIN_DIFF_CHAR_BUDGET || open.length >= BIN_MAX_FILES)) close();
+    open.push(file);
+    lines += file.lineCount;
+    chars += fileChars;
+  }
+  close();
+  return units;
+}
+function narrowUnit(unit, ledger) {
+  const outstanding = unitFiles(unit).filter((file) => !ledger.get(file.path)?.handled);
+  if (outstanding.length === 0) return [];
+  const failedBefore = outstanding.some((file) => (ledger.get(file.path)?.transientErrorCount ?? 0) > 0);
+  if (failedBefore) return outstanding.map((file) => ({ kind: "single", file }));
+  return [asBin(outstanding)];
+}
+
+// src/review/phase-control.ts
+async function heartbeatAndCheckSuperseded(env, jobId, leaseOwner) {
+  await env.jobs.heartbeatJobLease(jobId, leaseOwner, JOB_LEASE_SECONDS);
+  const currentJob = await env.jobs.getJobForProcessing(jobId);
+  if (currentJob?.status === "superseded") {
+    throw new Error("JOB_SUPERSEDED");
+  }
+}
+var NextPhaseError = class extends Error {
+  constructor(phase, delaySeconds) {
+    super(`NextPhase: ${phase}`);
+    this.phase = phase;
+    this.delaySeconds = delaySeconds;
+  }
+  phase;
+  delaySeconds;
+};
+async function enqueueJobPhase(env, jobId, phase, delaySeconds = 0) {
+  await env.jobs.markJobContinuationQueued(jobId, delaySeconds);
+  throw new NextPhaseError(phase, delaySeconds);
+}
+function hasCompletedStep(job, stepName) {
+  return job.steps.some((step) => step.name === stepName && step.status === "done");
+}
+async function failJobAndCheckRun(env, job, github, message) {
+  try {
+    await env.jobs.failJob(job.id, message);
+  } catch (dbError) {
+    logger.error(`Critical: failed to mark job ${job.id} as failed in the DB; it may remain stuck until lease-expiry recovery reclaims it`, dbError);
+    return;
+  }
+  try {
+    const latest = await env.jobs.getJobForProcessing(job.id);
+    const checkRunId = latest?.check_run_id ?? job.checkRunId;
+    if (checkRunId) {
+      await github.updateCheckRun(job.owner, job.repo, checkRunId, {
+        status: "completed",
+        conclusion: "failure",
+        title: "Review failed",
+        summary: message
+      });
+      await env.jobs.markJobCheckRunCompleted(job.id);
+    }
+  } catch (checkRunError) {
+    logger.warn(`Failed to update GitHub check run for failed job ${job.id}; opportunistic maintenance will retry it`, checkRunError);
+  }
+}
+
+// src/review/retry-policy.ts
+import { normalizeModelId } from "@codraoss/schema";
+import { isSubrequestBudgetMessage, isTimeoutMessage, matchesAnyTransientSubstring } from "@codraoss/schema/transient-errors";
+function isRetryableFileReviewErrorMessage(message) {
+  if (!message) return false;
+  const lower = message.toLowerCase();
+  if (lower.includes("retrying later") || lower.includes("all configured review models failed")) {
+    return true;
+  }
+  if (isTimeoutMessage(lower)) {
+    return false;
+  }
+  return matchesAnyTransientSubstring(lower) || lower.includes("google request failed with 5") || lower.includes("temporary") || lower.includes("subrequest");
+}
+function isSubrequestBudgetError(error) {
+  return isSubrequestBudgetMessage(error);
+}
+function retryableModelFailureDelaySeconds(failureCount) {
+  if (!failureCount || failureCount < 1) return RETRYABLE_MODEL_FAILURE_RETRY_DELAYS_SECONDS[0];
+  const index = Math.min(failureCount - 1, RETRYABLE_MODEL_FAILURE_RETRY_DELAYS_SECONDS.length - 1);
+  return RETRYABLE_MODEL_FAILURE_RETRY_DELAYS_SECONDS[index];
+}
+function getRetryableModelFailureDelaySeconds(error) {
+  const record = error && typeof error === "object" ? error : null;
+  const retryAfterSeconds = typeof record?.retryAfterSeconds === "number" ? record.retryAfterSeconds : null;
+  return retryAfterSeconds ?? RETRYABLE_MODEL_FAILURE_RETRY_DELAYS_SECONDS[0];
+}
+function shouldRetryExistingFileReview(review) {
+  return review.file_status === "failed" && isRetryableFileReviewErrorMessage(review.error_msg);
+}
+function countsAsHandledFileReview(review) {
+  return !shouldRetryExistingFileReview(review);
+}
+function isAwaitingAsyncReview(review) {
+  return review.file_status === "pending" && !!review.async_request_id;
+}
+function bareModelId(model) {
+  const normalized = normalizeModelId(model);
+  const colon = normalized.indexOf(":");
+  return colon === -1 ? normalized : normalized.slice(colon + 1);
+}
+function configuredModelSet(config) {
+  const models = /* @__PURE__ */ new Set();
+  const addModel = (model) => {
+    if (model) models.add(bareModelId(model));
+  };
+  addModel(config.model?.main);
+  for (const fallback of config.model?.fallbacks ?? []) {
+    addModel(fallback);
+  }
+  for (const tier of config.model?.size_overrides ?? []) {
+    addModel(tier.model);
+    for (const fallback of tier.fallbacks ?? []) {
+      addModel(fallback);
+    }
+  }
+  return models;
+}
+function canInheritParentFileReview(config, review) {
+  return configuredModelSet(config).has(bareModelId(review.model_used));
+}
+async function resolveModelProviderName(env, modelId) {
+  if (!modelId || modelId === "unconfigured") return null;
+  try {
+    const resolved = await env.modelConfigs.getResolvedModelConfig(normalizeModelId(modelId));
+    return resolved?.providerName ?? null;
+  } catch (error) {
+    logger.warn(`Failed to resolve provider for model ${modelId}`, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+
+// src/review/file-runner.ts
+import "@codraoss/schema";
+async function persistCompletedReview(env, job, file, response) {
+  await env.fileReviews.upsertFileReview(job.id, {
+    filePath: file.path,
+    fileStatus: "done",
+    modelUsed: response.modelUsed,
+    modelProvider: response.provider,
+    diffLineCount: file.lineCount,
+    diffInput: null,
+    rawAiOutput: response.rawText,
+    parsedComments: response.parsed.comments,
+    inputTokens: response.inputTokens,
+    outputTokens: response.outputTokens,
+    durationMs: null,
+    verdict: response.parsed.verdict,
+    fileSummary: response.parsed.fileSummary,
+    overallCorrectness: response.parsed.overallCorrectness,
+    confidenceScore: response.parsed.confidenceScore,
+    errorMessage: null,
+    asyncRequestId: null,
+    asyncModel: null
+  });
+}
+async function persistFailedFileReview(env, jobId, input) {
+  await env.fileReviews.upsertFileReview(jobId, {
+    filePath: input.filePath,
+    fileStatus: "failed",
+    modelUsed: input.modelUsed,
+    modelProvider: input.modelProvider ?? null,
+    diffLineCount: input.diffLineCount,
+    diffInput: null,
+    rawAiOutput: null,
+    parsedComments: input.parsedComments ?? [],
+    inputTokens: null,
+    outputTokens: null,
+    durationMs: input.durationMs ?? null,
+    verdict: null,
+    fileSummary: null,
+    errorMessage: input.errorMessage,
+    ...input.clearAsync ? { asyncRequestId: null, asyncModel: null } : {}
+  });
+}
+function scanRuleChannel(file, config) {
+  const rules = config.review.rules;
+  if (!rules?.enabled) return { comments: [], stats: null };
+  try {
+    const result = scanFileForRuleHits(file, {
+      disabledRuleIds: rules.disabled_rule_ids,
+      shadowRuleIds: rules.shadow_rule_ids,
+      deniedClaimTypes: config.review.deny_claim_types
+    });
+    return { comments: ruleHitsToComments(file, result), stats: result.stats };
+  } catch (error) {
+    logger.warn(`Rule scan failed for ${file.path}; continuing with LLM findings only`, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { comments: [], stats: null };
+  }
+}
+async function reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, previousReview, rejectedExemplars = []) {
+  const startedAt = env.clock.now();
+  const compactPrompt = (previousReview?.transient_error_count ?? 0) > 0;
+  const ruleScan = scanRuleChannel(file, config);
+  try {
+    const response = await model.reviewFile({
+      file,
+      prTitle: pr.title ?? null,
+      prDescription: pr.body ?? null,
+      config,
+      totalLineCount,
+      compactPrompt,
+      rejectedExemplars
+    });
+    await env.fileReviews.upsertFileReview(job.id, {
+      filePath: file.path,
+      fileStatus: "done",
+      modelUsed: response.modelUsed,
+      modelProvider: response.provider,
+      diffLineCount: file.lineCount,
+      diffInput: null,
+      rawAiOutput: response.rawText,
+      parsedComments: [...response.parsed.comments, ...ruleScan.comments],
+      inputTokens: response.inputTokens,
+      outputTokens: response.outputTokens,
+      durationMs: env.clock.now() - startedAt,
+      verdict: response.parsed.verdict,
+      fileSummary: response.parsed.fileSummary,
+      overallCorrectness: response.parsed.overallCorrectness,
+      confidenceScore: response.parsed.confidenceScore,
+      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)
+      }
+    });
+    logger.info(`File review parsed: ${file.path}`, {
+      jobId: job.id,
+      model: response.modelUsed,
+      kept: response.parsed.comments.length,
+      evidence: response.parsed.evidenceStats,
+      claimTypes: response.parsed.claimTypeCounts,
+      deniedClaims: response.parsed.deniedClaimCounts,
+      absenceCheck: response.parsed.absenceCheckStats,
+      ruleChannel: ruleScan.stats,
+      degraded: response.degraded
+    });
+    if (response.wasPromptTruncated) {
+      logger.warn(`Reviewed only part of ${file.path}; findings from the remainder are missing.`, {
+        jobId: job.id,
+        model: response.modelUsed,
+        reviewedLineCount: response.reviewedLineCount,
+        diffLineCount: file.lineCount
+      });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown file review error";
+    const modelId = config.model?.main ?? "unconfigured";
+    const modelProvider = await resolveFailureModelProvider();
+    if (isSubrequestBudgetError(error)) {
+      logger.warn(`File review deferred for ${file.path}; subrequest budget will retry in a fresh invocation`, {
+        error: errorMessage
+      });
+      Object.defineProperty(error, "retryAfterSeconds", {
+        value: FRESH_INVOCATION_YIELD_SECONDS,
+        configurable: true
+      });
+      throw error;
+    }
+    if (env.modelErrors.isRetryableModelError(error)) {
+      const failureCount = await env.fileReviews.recordRetryableFileReviewFailure(job.id, {
+        filePath: file.path,
+        modelUsed: modelId,
+        modelProvider,
+        diffLineCount: file.lineCount,
+        diffInput: null,
+        durationMs: env.clock.now() - startedAt,
+        errorMessage,
+        countsAsAttempt: env.modelErrors.nextChainIndexOf(error) === null
+      });
+      if (failureCount >= MAX_RETRYABLE_FILE_REVIEW_FAILURES) {
+        const finalError = `Review skipped after ${failureCount} repeated model provider outages.`;
+        await persistFailedFileReview(env, job.id, {
+          filePath: file.path,
+          modelUsed: modelId,
+          modelProvider,
+          diffLineCount: file.lineCount,
+          durationMs: env.clock.now() - startedAt,
+          errorMessage: finalError,
+          parsedComments: ruleScan.comments
+        });
+        logger.error(`File review failed permanently for ${file.path} after transient retries`, {
+          attempts: failureCount,
+          error: errorMessage
+        });
+        return;
+      }
+      logger.warn(`File review deferred for ${file.path}; transient model/provider failure will retry later`, {
+        error: errorMessage,
+        attempts: failureCount
+      });
+      Object.defineProperty(error, "retryAfterSeconds", {
+        value: retryableModelFailureDelaySeconds(failureCount),
+        configurable: true
+      });
+      throw error;
+    }
+    logger.error(`File review failed for ${file.path}`, { error });
+    const isHardLimit = errorMessage.includes("4006") || errorMessage.toLowerCase().includes("allocation");
+    if (isHardLimit) {
+      logger.warn(`File review hit hard provider allocation limit for ${file.path}, marking as failed to allow partial PR review.`, { error: errorMessage });
+    }
+    await persistFailedFileReview(env, job.id, {
+      filePath: file.path,
+      modelUsed: modelId,
+      modelProvider,
+      diffLineCount: file.lineCount,
+      durationMs: env.clock.now() - startedAt,
+      errorMessage,
+      parsedComments: ruleScan.comments
+    });
+  }
+}
+
+// src/review/bin-runner.ts
+function proportionalSplit(total, weights) {
+  if (weights.length === 0) return [];
+  const sum = weights.reduce((a, b) => a + b, 0);
+  const parts = sum <= 0 ? weights.map(() => Math.floor(total / weights.length)) : weights.map((w) => Math.floor(total * w / sum));
+  const assigned = parts.reduce((a, b) => a + b, 0);
+  if (assigned < total) {
+    const largest = weights.indexOf(Math.max(...weights));
+    parts[largest === -1 ? 0 : largest] += total - assigned;
+  }
+  return parts;
+}
+async function reviewAndPersistBin(env, job, files, pr, config, totalLineCount, model, resolveFailureModelProvider, rejectedExemplars = []) {
+  const startedAt = env.clock.now();
+  const ruleScans = new Map(files.map((file) => [file.path, scanRuleChannel(file, config)]));
+  const persisted = /* @__PURE__ */ new Set();
+  let terminalCount = 0;
+  const failedRow = (file, errorMessage, modelProvider) => ({
+    filePath: file.path,
+    fileStatus: "failed",
+    modelUsed: config.model?.main ?? "unconfigured",
+    modelProvider: modelProvider ?? null,
+    diffLineCount: file.lineCount,
+    rawAiOutput: null,
+    parsedComments: ruleScans.get(file.path)?.comments ?? [],
+    inputTokens: null,
+    outputTokens: null,
+    durationMs: env.clock.now() - startedAt,
+    verdict: null,
+    fileSummary: null,
+    errorMessage,
+    batchSize: files.length
+  });
+  try {
+    const response = await model.reviewFiles({
+      files,
+      prTitle: pr.title ?? null,
+      prDescription: pr.body ?? null,
+      config,
+      totalLineCount,
+      rejectedExemplars
+    });
+    const reviewed = files.filter((file) => response.batch.reviews.has(file.path));
+    const weights = reviewed.map((file) => renderFileDiff(file).length);
+    const inputSplit = proportionalSplit(response.inputTokens, weights);
+    const outputSplit = proportionalSplit(response.outputTokens, weights);
+    const durationMs = env.clock.now() - startedAt;
+    const rows = reviewed.map((file, index) => {
+      const parsed = response.batch.reviews.get(file.path);
+      const rules = ruleScans.get(file.path);
+      return {
+        filePath: file.path,
+        fileStatus: "done",
+        modelUsed: response.modelUsed,
+        modelProvider: response.provider,
+        diffLineCount: file.lineCount,
+        rawAiOutput: response.rawText,
+        parsedComments: [...parsed.comments, ...rules.comments],
+        inputTokens: inputSplit[index],
+        outputTokens: outputSplit[index],
+        durationMs,
+        verdict: parsed.verdict,
+        fileSummary: parsed.fileSummary,
+        overallCorrectness: parsed.overallCorrectness,
+        confidenceScore: parsed.confidenceScore,
+        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)
+        },
+        batchSize: files.length
+      };
+    });
+    if (rows.length > 0) {
+      await env.fileReviews.bulkUpsertFileReviews(job.id, rows);
+      for (const row of rows) persisted.add(row.filePath);
+      terminalCount += rows.length;
+    }
+    if (response.batch.missing.length > 0) {
+      const counts = await env.fileReviews.bulkRecordRetryableFileReviewFailures(job.id, response.batch.missing.map((path) => ({
+        filePath: path,
+        modelUsed: response.modelUsed,
+        diffLineCount: files.find((f) => f.path === path)?.lineCount ?? 0,
+        errorMessage: MISSING_FILE_ERROR
+      })));
+      for (const count of counts) persisted.add(count.filePath);
+      const exhausted = counts.filter((c) => c.transientErrorCount >= MAX_RETRYABLE_FILE_REVIEW_FAILURES);
+      if (exhausted.length > 0) {
+        await env.fileReviews.bulkUpsertFileReviews(job.id, exhausted.map((c) => failedRow(
+          files.find((f) => f.path === c.filePath),
+          `Review skipped after the model omitted this file ${c.transientErrorCount} times.`
+        )));
+        terminalCount += exhausted.length;
+      }
+    }
+    logger.info("Batched file review parsed", {
+      jobId: job.id,
+      model: response.modelUsed,
+      binSize: files.length,
+      binPaths: files.map((f) => f.path),
+      binDiffLines: files.reduce((sum, f) => sum + f.lineCount, 0),
+      durationMs,
+      inputTokens: response.inputTokens,
+      outputTokens: response.outputTokens,
+      keptPerFile: rows.map((r) => ({ path: r.filePath, kept: r.parsedComments.length })),
+      entriesReturned: response.batch.stats.entriesReturned,
+      missingFiles: response.batch.missing,
+      unroutableEntries: response.batch.stats.unroutableEntries,
+      pathMismatchFindings: response.batch.stats.pathMismatchFindings,
+      ambiguousAcrossBin: response.batch.stats.ambiguousAcrossBin,
+      flatFallback: response.batch.stats.flatFallback,
+      overCap: response.batch.stats.overCap
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown batched review error";
+    const modelId = config.model?.main ?? "unconfigured";
+    const modelProvider = await resolveFailureModelProvider();
+    if (isSubrequestBudgetError(error)) {
+      logger.warn("Batched review deferred; subrequest budget will retry in a fresh invocation", {
+        jobId: job.id,
+        paths: files.map((f) => f.path),
+        error: errorMessage
+      });
+      Object.defineProperty(error, "retryAfterSeconds", { value: FRESH_INVOCATION_YIELD_SECONDS, configurable: true });
+      throw error;
+    }
+    const outstanding = files.filter((file) => !persisted.has(file.path));
+    if (outstanding.length === 0) {
+      logger.warn("Batched review hit an error after every file was persisted; keeping the committed rows", {
+        jobId: job.id,
+        paths: files.map((f) => f.path),
+        error: errorMessage
+      });
+      return terminalCount;
+    }
+    if (env.modelErrors.isRetryableModelError(error)) {
+      const advancedTo = env.modelErrors.nextChainIndexOf(error);
+      const counts = await env.fileReviews.bulkRecordRetryableFileReviewFailures(job.id, outstanding.map((file) => ({
+        filePath: file.path,
+        modelUsed: modelId,
+        diffLineCount: file.lineCount,
+        errorMessage
+      })), { countsAsAttempt: advancedTo === null });
+      const exhausted = counts.filter((c) => c.transientErrorCount >= MAX_RETRYABLE_FILE_REVIEW_FAILURES);
+      if (exhausted.length > 0) {
+        await env.fileReviews.bulkUpsertFileReviews(job.id, exhausted.map((c) => failedRow(
+          files.find((f) => f.path === c.filePath),
+          `Review skipped after ${c.transientErrorCount} repeated model provider outages.`,
+          modelProvider
+        )));
+        terminalCount += exhausted.length;
+        logger.error("Files in a batched review failed permanently after transient retries", {
+          jobId: job.id,
+          paths: exhausted.map((c) => c.filePath),
+          error: errorMessage
+        });
+      }
+      const stillRetrying = counts.filter((c) => c.transientErrorCount < MAX_RETRYABLE_FILE_REVIEW_FAILURES);
+      if (stillRetrying.length === 0) return terminalCount;
+      logger.warn("Batched review deferred; transient model/provider failure will retry later", {
+        jobId: job.id,
+        paths: stillRetrying.map((c) => c.filePath),
+        error: errorMessage
+      });
+      Object.defineProperty(error, "retryAfterSeconds", {
+        value: retryableModelFailureDelaySeconds(Math.max(...stillRetrying.map((c) => c.transientErrorCount))),
+        configurable: true
+      });
+      throw error;
+    }
+    logger.error("Batched review failed", { jobId: job.id, paths: outstanding.map((f) => f.path), error });
+    await env.fileReviews.bulkUpsertFileReviews(job.id, outstanding.map((file) => failedRow(file, errorMessage, modelProvider)));
+    terminalCount += outstanding.length;
+  }
+  return terminalCount;
+}
+
+// src/finding-gates.ts
+var LOW_YIELD_TITLE = /missing|redundant|repetitive|inconsisten|documentation|\btype\b|\bany\b|potential/i;
+function shadowEvaluate(candidates, posted) {
+  const postedSet = new Set(posted);
+  const count = (predicate) => ({
+    wouldDrop: candidates.filter(predicate).length,
+    wouldDropPosted: posted.filter(predicate).length
+  });
+  return {
+    candidates: candidates.length,
+    posted: postedSet.size,
+    dropP3AndNit: count((c) => c.severity === "P3" || c.severity === "nit"),
+    dropLowYieldTitle: count((c) => LOW_YIELD_TITLE.test(c.title)),
+    dropUnmatchedEvidence: count((c) => !c.evidence)
+  };
+}
+function verifyCandidateLimit(effectiveMaxComments) {
+  return Math.min(40, Math.max(10, effectiveMaxComments * 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 toVerify = comments.slice(0, limit);
+  const fileByPath = new Map(files.map((file) => [file.path, file]));
+  const prepared = toVerify.map((comment) => ({
+    comment,
+    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();
+  const candidates = verifiable.map((entry, index) => ({
+    index,
+    path: entry.comment.path,
+    line: entry.comment.line ?? null,
+    title: entry.comment.title,
+    body: entry.comment.body,
+    snippet: entry.snippet,
+    evidence: entry.comment.evidence ?? null
+  }));
+  try {
+    const response = await model.verifyFindings({ candidates, config });
+    const results = parseVerifyResponse(response.rawText);
+    const byIndex = /* @__PURE__ */ new Map();
+    const conflicting = /* @__PURE__ */ new Set();
+    for (const result of results) {
+      if (!Number.isInteger(result.index) || result.index < 0 || result.index >= candidates.length) continue;
+      const verdict = result.decidable === false ? "drop" : result.verdict;
+      const prior = byIndex.get(result.index);
+      if (prior && prior.verdict !== verdict) {
+        conflicting.add(result.index);
+        continue;
+      }
+      if (!prior) byIndex.set(result.index, { verdict, reason: result.reason });
+    }
+    for (const index of conflicting) byIndex.delete(index);
+    const answered = byIndex.size;
+    if (answered === 0 || answered / candidates.length < VERIFY_MIN_ANSWER_RATIO) {
+      logger.warn("Verification did not answer enough indices; keeping all findings", {
+        jobId: job.id,
+        candidates: candidates.length,
+        answered
+      });
+      return keepAll();
+    }
+    const dropped = [];
+    const reasons = /* @__PURE__ */ new Map();
+    verifiable.forEach((entry, index) => {
+      const result = byIndex.get(index);
+      if (result?.reason) reasons.set(entry.comment, result.reason);
+      if (result?.verdict === "drop") {
+        dropped.push({ comment: entry.comment, disposition: "verify", reason: result.reason });
+        return;
+      }
+      if (!result) {
+        dropped.push({
+          comment: entry.comment,
+          disposition: "verify_unanswered",
+          reason: "the verifier returned no verdict for this finding"
+        });
+      }
+    });
+    const droppedSet = new Set(dropped.map((drop) => drop.comment));
+    logger.info("Verification pass complete", {
+      jobId: job.id,
+      candidates: candidates.length,
+      answered,
+      dropped: dropped.length,
+      topReasons: dropped.slice(0, 5).map((drop) => drop.reason)
+    });
+    return { comments: comments.filter((comment) => !droppedSet.has(comment)), dropped, reasons };
+  } catch (error) {
+    logger.warn("Verification pass failed; posting pre-verification findings", {
+      jobId: job.id,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return keepAll();
+  }
+}
+
+// src/review/prepare.ts
+import { defaultRepoConfig } from "@codraoss/schema";
+async function runPreparePhase(env, job, leaseOwner, github) {
+  await env.jobs.updateJobStep(job.id, "Preparation", { status: "running" });
+  const pr = await github.getPullRequest(job.owner, job.repo, job.prNumber);
+  const config = job.configSnapshot ?? defaultRepoConfig;
+  try {
+    await env.jobs.setJobPullRequestMeta(job.id, {
+      prTitle: pr.title ?? null,
+      prAuthor: pr.user?.login ?? null
+    });
+  } catch (error) {
+    logger.warn(`Failed to refresh PR metadata for job ${job.id}`, error instanceof Error ? error : new Error(String(error)));
+  }
+  let checkRunId = job.checkRunId;
+  if (!checkRunId) {
+    const checkRun = await github.createCheckRun(job.owner, job.repo, {
+      headSha: pr.head.sha,
+      title: "Review queued",
+      summary: "Codra has started reviewing this pull request."
+    });
+    checkRunId = checkRun.id;
+    await env.jobs.updateJobCheckRun(job.id, checkRun.id);
+  }
+  const { maxFiles } = await env.settings.getReviewSettings();
+  const { files } = await getDiffFiles(env, job, github, config, maxFiles);
+  await env.jobs.completePreparationStep(job.id, files.length);
+  await env.jobs.heartbeatJobLease(job.id, leaseOwner, JOB_LEASE_SECONDS);
+  if (files.length === 0) {
+    await env.jobs.updateJobStep(job.id, "Reviewing Files", { status: "done" });
+    await enqueueJobPhase(env, job.id, "finalize", FRESH_INVOCATION_YIELD_SECONDS);
+    return;
+  }
+  if (checkRunId) {
+    try {
+      await github.updateCheckRun(job.owner, job.repo, checkRunId, {
+        title: `Reviewing (0/${files.length})`,
+        summary: "Codra is analyzing changed files."
+      });
+    } catch (error) {
+      logger.warn(`Failed to update initial progress check run for job ${job.id}; continuing to the review phase anyway`, error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  await enqueueJobPhase(env, job.id, "review", FRESH_INVOCATION_YIELD_SECONDS);
+}
+async function loadRejectedExemplars(env, job) {
+  try {
+    const repositoryId = await env.learning.getRepositoryIdForJob(job.id);
+    if (repositoryId === null) return [];
+    const rows = await env.learning.getRejectedExemplars({ repositoryId, limit: 5 });
+    return rows.map((row) => ({ title: row.title, claimType: row.claim_type }));
+  } catch (error) {
+    logger.warn("Could not load rejected exemplars; reviewing without them", {
+      jobId: job.id,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return [];
+  }
+}
+
+// src/review/phase.ts
+import { defaultRepoConfig as defaultRepoConfig2, REVIEW_CONCURRENCY_LIMITS } from "@codraoss/schema";
+async function runReviewPhase(env, job, leaseOwner, github, model, tracker) {
+  if (!hasCompletedStep(job, "Preparation")) {
+    await runPreparePhase(env, job, leaseOwner, github);
+    return;
+  }
+  await env.jobs.updateJobStep(job.id, "Reviewing Files", { status: "running" });
+  const [rejectedExemplars, pr] = await Promise.all([
+    loadRejectedExemplars(env, job),
+    github.getPullRequest(job.owner, job.repo, job.prNumber)
+  ]);
+  const config = job.configSnapshot ?? defaultRepoConfig2;
+  const failureModelId = config.model?.main ?? "unconfigured";
+  let failureModelProviderPromise = null;
+  const resolveFailureModelProvider = () => {
+    failureModelProviderPromise ??= resolveModelProviderName(env, failureModelId);
+    return failureModelProviderPromise;
+  };
+  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 configuredChunkFileLimit = REVIEW_CONCURRENCY_LIMITS[concurrencyLevel];
+  const modelChainLength = 1 + (config.model.fallbacks?.length ?? 0);
+  const reviewChunkFileLimit = budgetAwareFileLimit(
+    tracker.remainingSafeBudget(),
+    configuredChunkFileLimit,
+    modelChainLength
+  );
+  if (reviewChunkFileLimit <= 0) {
+    throw new Error("Subrequest budget for this invocation was exhausted before starting the next review chunk.");
+  }
+  const startedAt = env.clock.now();
+  let processedThisChunk = 0;
+  const jobIdsToQuery = [job.id];
+  if (job.retryOfJobId) jobIdsToQuery.push(job.retryOfJobId);
+  const allExistingReviews = await env.fileReviews.getFileReviewsForJobs(jobIdsToQuery);
+  const currentReviews = /* @__PURE__ */ new Map();
+  const parentReviews = /* @__PURE__ */ new Map();
+  for (const review of allExistingReviews) {
+    if (review.job_id === job.id) currentReviews.set(review.file_path, review);
+    else if (review.file_status === "done") parentReviews.set(review.file_path, review);
+  }
+  const reviewTasks = [];
+  let terminalProgress = 0;
+  let awaitingAsync = 0;
+  if (job.retryOfJobId && parentReviews.size > 0) {
+    const inheritablePaths = files.flatMap((file) => {
+      if (currentReviews.has(file.path)) return [];
+      const parent = parentReviews.get(file.path);
+      return parent && canInheritParentFileReview(config, parent) ? [file.path] : [];
+    });
+    if (inheritablePaths.length > 0) {
+      const inheritedPaths = await env.fileReviews.bulkInheritFileReviews({
+        jobId: job.id,
+        parentJobId: job.retryOfJobId,
+        filePaths: inheritablePaths
+      });
+      for (const path of inheritedPaths) {
+        const parent = parentReviews.get(path);
+        if (parent) currentReviews.set(path, parent);
+      }
+      terminalProgress += inheritedPaths.length;
+      if (inheritedPaths.length > 0) {
+        logger.info(`Bulk-inherited ${inheritedPaths.length} parent file reviews for job ${job.id} in one pass`);
+      }
+    }
+  }
+  const binnedPaths = /* @__PURE__ */ new Set();
+  if (config.review.batch_small_files) {
+    const ledger = new Map(files.map((file) => {
+      const existing = currentReviews.get(file.path);
+      const inheritable = parentReviews.get(file.path);
+      return [file.path, {
+        handled: Boolean(existing && countsAsHandledFileReview(existing) || inheritable && canInheritParentFileReview(config, inheritable)),
+        transientErrorCount: existing?.transient_error_count ?? 0
+      }];
+    }));
+    const units = planReviewUnits(files, { enabled: true }).flatMap((unit) => narrowUnit(unit, ledger));
+    const plannedBins = units.filter((unit) => unit.kind === "bin");
+    let binsDispatched = 0;
+    let filesDispatchedInBins = 0;
+    for (const unit of plannedBins) {
+      if (processedThisChunk >= reviewChunkFileLimit) break;
+      if (env.clock.now() - startedAt >= REVIEW_CHUNK_WALL_CLOCK_MS) break;
+      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);
+        terminalProgress += terminal;
+      })());
+      processedThisChunk += 1;
+      binsDispatched += 1;
+      filesDispatchedInBins += binFiles.length;
+    }
+    if (plannedBins.length > 0) {
+      logger.info("Batched review plan", {
+        jobId: job.id,
+        binsPlanned: plannedBins.length,
+        binsDispatched,
+        filesInBins: filesDispatchedInBins,
+        modelCallsSaved: filesDispatchedInBins - binsDispatched
+      });
+    }
+  }
+  for (const file of files) {
+    if (binnedPaths.has(file.path)) continue;
+    const existingReview = currentReviews.get(file.path);
+    const awaitingReview = existingReview && isAwaitingAsyncReview(existingReview) ? existingReview : null;
+    if (existingReview && countsAsHandledFileReview(existingReview) && !awaitingReview) {
+      continue;
+    }
+    if (!awaitingReview && processedThisChunk >= reviewChunkFileLimit) {
+      continue;
+    }
+    const inherited = parentReviews.get(file.path);
+    const reviewTask = async () => {
+      if (awaitingReview) {
+        const poll = await model.pollReviewBatch({
+          model: awaitingReview.async_model ?? awaitingReview.model_used,
+          requestId: awaitingReview.async_request_id,
+          file,
+          config
+        });
+        if (poll.status === "pending") {
+          awaitingAsync += 1;
+          return;
+        }
+        if (poll.status === "failed") {
+          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);
+          terminalProgress += 1;
+          return;
+        }
+        await persistCompletedReview(env, job, file, poll.response);
+        terminalProgress += 1;
+        return;
+      }
+      if (!inherited) {
+        const submitted = await model.submitReviewBatch({
+          file,
+          prTitle: pr.title ?? null,
+          prDescription: pr.body ?? null,
+          config,
+          totalLineCount,
+          compactPrompt: (existingReview?.transient_error_count ?? 0) > 0
+        });
+        if (submitted) {
+          await env.fileReviews.upsertFileReview(job.id, {
+            filePath: file.path,
+            fileStatus: "pending",
+            modelUsed: submitted.model,
+            modelProvider: null,
+            diffLineCount: file.lineCount,
+            diffInput: null,
+            rawAiOutput: null,
+            parsedComments: [],
+            inputTokens: null,
+            outputTokens: null,
+            durationMs: null,
+            verdict: null,
+            fileSummary: null,
+            overallCorrectness: null,
+            confidenceScore: null,
+            errorMessage: null,
+            asyncRequestId: submitted.requestId,
+            asyncModel: submitted.model
+          });
+          awaitingAsync += 1;
+          return;
+        }
+        await reviewAndPersistFile(env, job, file, pr, config, totalLineCount, model, resolveFailureModelProvider, existingReview, rejectedExemplars);
+        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);
+        terminalProgress += 1;
+      } else {
+        await env.fileReviews.upsertFileReview(job.id, {
+          filePath: file.path,
+          fileStatus: "done",
+          modelUsed: inherited.model_used,
+          modelProvider: inherited.model_provider,
+          diffLineCount: inherited.diff_line_count,
+          diffInput: inherited.diff_input,
+          rawAiOutput: inherited.raw_ai_output,
+          parsedComments: inherited.parsed_comments,
+          inputTokens: inherited.input_tokens,
+          outputTokens: inherited.output_tokens,
+          durationMs: inherited.duration_ms,
+          verdict: inherited.verdict,
+          fileSummary: inherited.file_summary,
+          overallCorrectness: inherited.overall_correctness,
+          confidenceScore: inherited.confidence_score,
+          errorMessage: null
+        });
+        currentReviews.set(file.path, inherited);
+        terminalProgress += 1;
+      }
+    };
+    reviewTasks.push(reviewTask());
+    if (!awaitingReview) processedThisChunk += 1;
+    if (env.clock.now() - startedAt >= REVIEW_CHUNK_WALL_CLOCK_MS) {
+      break;
+    }
+  }
+  const results = await Promise.allSettled(reviewTasks);
+  await heartbeatAndCheckSuperseded(env, job.id, leaseOwner);
+  if (terminalProgress > 0) {
+    await env.jobs.resetJobContinuationCount(job.id);
+  }
+  logger.info("Review chunk model usage", {
+    jobId: job.id,
+    subrequests: tracker.getSubrequestCount(),
+    usage: tracker.getTotalUsage(),
+    wasted: tracker.getWasted()
+  });
+  const rejected = results.filter((result) => result.status === "rejected");
+  if (rejected.length > 0) {
+    rejected.forEach((result, index) => {
+      logger.error(`Review chunk task ${index + 1}/${rejected.length} failed`, result.reason);
+    });
+    const deferrableError = rejected.map((r) => r.reason).find((r) => env.modelErrors.isRetryableModelError(r) || isSubrequestBudgetError(r));
+    if (deferrableError) {
+      throw deferrableError;
+    }
+    throw rejected.length === 1 ? rejected[0].reason : new AggregateError(rejected.map((result) => result.reason), `${rejected.length} review chunk tasks failed`);
+  }
+  const latestReviews = await env.fileReviews.getFileReviewsForJobs([job.id]);
+  const reviewedPaths = new Set(
+    latestReviews.flatMap((review) => countsAsHandledFileReview(review) && !isAwaitingAsyncReview(review) ? [review.file_path] : [])
+  );
+  const completedCount = files.filter((file) => reviewedPaths.has(file.path)).length;
+  if (completedCount >= files.length) {
+    await env.jobs.updateJobStep(job.id, "Reviewing Files", { status: "done" });
+    await enqueueJobPhase(env, job.id, "finalize", FRESH_INVOCATION_YIELD_SECONDS);
+    return;
+  }
+  if (awaitingAsync > 0 && terminalProgress === 0) {
+    const pollCount = await env.jobs.markJobContinuationQueued(job.id, ASYNC_BATCH_POLL_DELAY_SECONDS);
+    if (pollCount > MAX_JOB_CONTINUATIONS) {
+      logger.error(`Async batch reviews did not complete after ${pollCount} polls; degrading to a partial review: ${job.owner}/${job.repo} PR #${job.prNumber}`);
+      for (const review of latestReviews.filter(isAwaitingAsyncReview)) {
+        await persistFailedFileReview(env, job.id, {
+          filePath: review.file_path,
+          modelUsed: review.async_model ?? review.model_used,
+          diffLineCount: review.diff_line_count,
+          errorMessage: "Async batch review did not complete in time.",
+          clearAsync: true
+        });
+      }
+      await env.jobs.updateJobStep(job.id, "Reviewing Files", { status: "done" });
+      throw new NextPhaseError("finalize", FRESH_INVOCATION_YIELD_SECONDS);
+    }
+    throw new NextPhaseError("review", ASYNC_BATCH_POLL_DELAY_SECONDS);
+  }
+  if (job.checkRunId) {
+    try {
+      await github.updateCheckRun(job.owner, job.repo, job.checkRunId, {
+        title: `Reviewing (${completedCount}/${files.length})`,
+        summary: "Codra is continuing this review in the next queue chunk."
+      });
+    } catch (error) {
+      logger.warn(`Failed to update progress check run for job ${job.id}; continuing to the next chunk anyway`, error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  await enqueueJobPhase(env, job.id, "review", FRESH_INVOCATION_YIELD_SECONDS);
+}
+
+// src/review/finalize.ts
+import { defaultRepoConfig as defaultRepoConfig3 } from "@codraoss/schema";
+
+// src/review/telemetry.ts
+async function sendReviewTelemetry(env, job, files, reviews, overrides, meta) {
+  try {
+    const doneReviews = reviews.filter((r) => r.file_status === "done");
+    const cleanModels = Array.from(
+      new Set(
+        doneReviews.flatMap((r) => {
+          const model = bareModelId(r.model_used);
+          return model && !model.toLowerCase().includes("test") ? [model] : [];
+        })
+      )
+    );
+    const extractExtension = (filePath) => {
+      const name = filePath.split("/").pop() || filePath;
+      const dotIndex = name.lastIndexOf(".");
+      if (dotIndex <= 0) return "";
+      return name.slice(dotIndex + 1).toLowerCase();
+    };
+    await env.telemetry.send({
+      linesReviewed: files.reduce((sum, file) => sum + file.lineCount, 0),
+      inputTokens: doneReviews.reduce((sum, r) => sum + (r.input_tokens ?? 0), 0),
+      outputTokens: doneReviews.reduce((sum, r) => sum + (r.output_tokens ?? 0), 0),
+      modelsUsed: cleanModels,
+      fileExtensions: Array.from(new Set(files.flatMap((f) => {
+        const extension = extractExtension(f.path);
+        return extension ? [extension] : [];
+      }))),
+      triggerType: job.trigger,
+      reviewDurationMs: Math.max(0, env.clock.now() - new Date(job.createdAt).getTime()),
+      filesReviewed: files.length,
+      concurrencyLevel: meta.concurrencyLevel,
+      prTotalLinesChanged: files.reduce((sum, file) => sum + file.lineCount, 0),
+      retryCount: meta.retryCount,
+      ...overrides
+    });
+  } catch (e) {
+    logger.error("Failed to send telemetry", e instanceof Error ? e : new Error(String(e)));
+  }
+}
+async function loadSuppressedFingerprints(env, jobId) {
+  const posted = /* @__PURE__ */ new Map();
+  const rejected = /* @__PURE__ */ new Set();
+  const postedV2 = /* @__PURE__ */ new Set();
+  const rejectedV2 = /* @__PURE__ */ new Set();
+  try {
+    for (const row of await env.fileReviews.getSuppressedFindings(jobId)) {
+      if (!row.anchored) {
+        if (row.fingerprint) rejected.add(row.fingerprint);
+        if (row.fingerprint_v2) rejectedV2.add(row.fingerprint_v2);
+        continue;
+      }
+      if (row.fingerprint_v2) postedV2.add(row.fingerprint_v2);
+      if (!row.fingerprint || !row.anchor_hash) continue;
+      const anchors = posted.get(row.fingerprint) ?? /* @__PURE__ */ new Set();
+      anchors.add(row.anchor_hash);
+      posted.set(row.fingerprint, anchors);
+    }
+  } catch (error) {
+    logger.warn("Could not load suppressed findings; posting without cross-run dedupe", {
+      jobId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  return { posted, rejected, postedV2, rejectedV2 };
+}
+
+// src/review/gate-pipeline.ts
+async function applyFindingGates(params) {
+  const { env, job, config, files, model, effectiveMaxComments, reviewedComments, reviews } = 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 dispositions = /* @__PURE__ */ new Map();
+  const verifyReasons = /* @__PURE__ */ new Map();
+  const recordDisposition = (comments, stage) => {
+    for (const comment of comments) {
+      if (comment.fingerprint && !dispositions.has(comment.fingerprint)) {
+        dispositions.set(comment.fingerprint, stage);
+      }
+    }
+  };
+  let finalComments = reviewedComments.filter((c) => {
+    if ((severityRanks[c.severity] ?? 4) > minRank) {
+      recordDisposition([c], "severity");
+      return false;
+    }
+    if (typeof c.confidenceScore === "number" && c.confidenceScore < minConfidence) {
+      recordDisposition([c], "confidence");
+      return false;
+    }
+    return true;
+  });
+  const suppressed = await loadSuppressedFingerprints(env, job.id);
+  const suppressedComments = [];
+  const hasSuppressionData = suppressed.rejected.size > 0 || suppressed.posted.size > 0 || suppressed.rejectedV2.size > 0 || suppressed.postedV2.size > 0;
+  if (hasSuppressionData) {
+    finalComments = finalComments.filter((c) => {
+      const rejected = c.fingerprint && suppressed.rejected.has(c.fingerprint) || c.fingerprintV2 && suppressed.rejectedV2.has(c.fingerprintV2);
+      const anchors = c.fingerprint ? suppressed.posted.get(c.fingerprint) : void 0;
+      const alreadyPosted = anchors && c.anchorHash && anchors.has(c.anchorHash) || c.fingerprintV2 && suppressed.postedV2.has(c.fingerprintV2);
+      if (rejected || alreadyPosted) {
+        suppressedComments.push(c);
+        return false;
+      }
+      return true;
+    });
+  }
+  const droppedBySuppression = suppressedComments.length;
+  recordDisposition(suppressedComments, "suppression");
+  const beforeDedupe = finalComments;
+  finalComments = dedupeFindings(finalComments);
+  const survivedDedupe = new Set(finalComments);
+  recordDisposition(beforeDedupe.filter((c) => !survivedDedupe.has(c)), "dedupe");
+  finalComments.sort((a, b) => {
+    const rankDiff = (severityRanks[a.severity] ?? 4) - (severityRanks[b.severity] ?? 4);
+    if (rankDiff !== 0) return rankDiff;
+    return (b.confidenceScore ?? 0) - (a.confidenceScore ?? 0);
+  });
+  const beforeVerifyList = finalComments;
+  const verify = await verifyFindings({ job, config, files, comments: finalComments, model, maxCandidates: effectiveMaxComments });
+  finalComments = verify.comments;
+  const droppedByVerification = verify.dropped.length;
+  for (const drop of verify.dropped) recordDisposition([drop.comment], drop.disposition);
+  for (const [comment, reason] of verify.reasons) {
+    if (comment.fingerprint) verifyReasons.set(comment.fingerprint, reason);
+  }
+  const beforeCapList = finalComments;
+  const beforeCap = finalComments.length;
+  if (finalComments.length > effectiveMaxComments) {
+    finalComments = finalComments.slice(0, effectiveMaxComments);
+  }
+  const droppedByCap = beforeCap - finalComments.length;
+  recordDisposition(beforeCapList.slice(effectiveMaxComments), "cap");
+  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),
+    0
+  );
+  const byClaimType = {};
+  for (const comment of reviewedComments) {
+    const key = comment.claimType ?? "unlabelled";
+    byClaimType[key] ??= { generated: 0, posted: 0 };
+    byClaimType[key].generated += 1;
+  }
+  for (const comment of finalComments) {
+    const key = comment.claimType ?? "unlabelled";
+    byClaimType[key] ??= { generated: 0, posted: 0 };
+    byClaimType[key].posted += 1;
+  }
+  return {
+    finalComments,
+    dispositions,
+    verifyReasons,
+    suppressedComments,
+    droppedBySuppression,
+    beforeVerifyList,
+    droppedByVerification,
+    droppedByCap,
+    omittedCount,
+    droppedByFilters,
+    withheldByParser,
+    byClaimType
+  };
+}
+
+// src/review/finalize.ts
+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);
+  const config = job.configSnapshot ?? defaultRepoConfig3;
+  const reviewSettings = await env.settings.getReviewSettings();
+  const [{ files, skipped: filesOverCap }, initialReviews] = await Promise.all([
+    getDiffFiles(env, job, github, config, reviewSettings.maxFiles),
+    env.fileReviews.getFileReviewsForJobs([job.id])
+  ]);
+  let reviews = initialReviews;
+  {
+    const reviewedPaths = new Set(reviews.map((r) => r.file_path));
+    const missingFiles = files.filter((f) => !reviewedPaths.has(f.path));
+    if (missingFiles.length > 0) {
+      logger.warn(`Job ${job.id} reached finalize phase with ${missingFiles.length} missing file reviews. Forcing them to failed state.`);
+      await env.fileReviews.bulkMarkFilesFailed(
+        job.id,
+        missingFiles.map((file) => ({ filePath: file.path, diffLineCount: file.lineCount })),
+        { modelUsed: config.model?.main ?? "unconfigured", errorMessage: "This file was not reviewed before the review run completed." }
+      );
+      reviews = await env.fileReviews.getFileReviewsForJobs([job.id]);
+    } else if (reviews.length < files.length) {
+      await env.jobs.updateJobStep(job.id, "Reviewing Files", { status: "running" });
+      await enqueueJobPhase(env, job.id, "review", FRESH_INVOCATION_YIELD_SECONDS);
+      return;
+    }
+  }
+  await env.jobs.updateJobStep(job.id, "Reviewing Files", { status: "done" });
+  const reviewedComments = reviews.flatMap((review2) => review2.parsed_comments);
+  const fileSummaries = reviews.map((review2) => ({
+    path: review2.file_path,
+    summary: review2.file_status === "failed" ? `Review failed: ${review2.error_msg ?? "Unknown file review error"}` : review2.file_summary ?? "",
+    verdict: review2.file_status === "failed" ? "failed" : review2.verdict ?? "comment"
+  }));
+  const { concurrencyLevel, maxComments: globalMaxComments } = reviewSettings;
+  const effectiveMaxComments = Math.min(config.review.max_comments, globalMaxComments);
+  const retryCount = job.retryOfJobId ? 1 : 0;
+  if (fileSummaries.length > 0 && fileSummaries.every((file) => file.verdict === "failed")) {
+    await env.jobs.updateJobStep(job.id, "Generating Summary", { status: "failed", error: "All files failed to review" });
+    await sendReviewTelemetry(
+      env,
+      job,
+      files,
+      reviews,
+      { findingsReported: 0, verdict: "failed", severityDistribution: {} },
+      { concurrencyLevel, retryCount }
+    );
+    throw new Error("All files failed to review");
+  }
+  const hasFailures = fileSummaries.some((file) => file.verdict === "failed");
+  const failedFileCount = fileSummaries.filter((file) => file.verdict === "failed").length;
+  const {
+    finalComments,
+    dispositions,
+    verifyReasons,
+    suppressedComments,
+    droppedBySuppression,
+    beforeVerifyList,
+    droppedByVerification,
+    droppedByCap,
+    omittedCount,
+    droppedByFilters,
+    withheldByParser,
+    byClaimType
+  } = await applyFindingGates({
+    env,
+    job,
+    config,
+    files,
+    model,
+    effectiveMaxComments,
+    reviewedComments,
+    reviews
+  });
+  logger.info("Finding pipeline outcome", {
+    jobId: job.id,
+    parsed: reviewedComments.length,
+    droppedByFilters,
+    droppedBySuppression,
+    droppedByVerification,
+    droppedByCap,
+    posted: finalComments.length,
+    withheldByParser,
+    byClaimType,
+    byChannel: {
+      llm: finalComments.filter((c) => c.source !== "rule").length,
+      rule: finalComments.filter((c) => c.source === "rule").length
+    },
+    byRule: reviewedComments.reduce((acc, c) => {
+      if (c.source === "rule" && c.ruleId) acc[c.ruleId] = (acc[c.ruleId] ?? 0) + 1;
+      return acc;
+    }, {}),
+    postedAny: finalComments.length > 0,
+    postedPer100Files: files.length > 0 ? Math.round(finalComments.length / files.length * 1e3) / 10 : 0
+  });
+  logger.info("Shadow filter evaluation", {
+    jobId: job.id,
+    ...shadowEvaluate(beforeVerifyList, finalComments)
+  });
+  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);
+  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.`;
+  }
+  const finalizeRetriedPastPost = job.steps.some(
+    (step) => step.name === "Completing" && (step.status === "running" || step.status === "done")
+  );
+  await env.jobs.updateJobStep(job.id, "Completing", { status: "running" });
+  const existingReview = finalizeRetriedPastPost ? await github.findBotReviewForCommit(job.owner, job.repo, job.prNumber, pr.head.sha, env.botUsername) : null;
+  const review = existingReview ?? await github.createReview(job.owner, job.repo, job.prNumber, {
+    commitSha: pr.head.sha,
+    event: formatter.toReviewEvent(verdictSummary.verdict),
+    body: formattedSummary,
+    comments: finalComments.map((comment) => ({
+      path: comment.path,
+      line: comment.line ?? void 0,
+      side: "RIGHT",
+      position: comment.position ?? void 0,
+      body: formatter.formatInlineComment(comment)
+    }))
+  });
+  if (review.postedIndices && review.postedIndices.length > 0) {
+    const postedFingerprints = review.postedIndices.map((index) => finalComments[index]?.fingerprint).filter((fingerprint) => Boolean(fingerprint));
+    await env.fileReviews.markCommentsPosted(job.id, postedFingerprints);
+  }
+  try {
+    const withReasons = /* @__PURE__ */ new Map();
+    for (const fingerprint of /* @__PURE__ */ new Set([...dispositions.keys(), ...verifyReasons.keys()])) {
+      withReasons.set(fingerprint, {
+        disposition: dispositions.get(fingerprint) ?? null,
+        reason: verifyReasons.get(fingerprint) ?? null
+      });
+    }
+    await env.fileReviews.markCommentDispositions(job.id, withReasons);
+  } catch (error) {
+    logger.warn("Could not record finding dispositions", {
+      jobId: job.id,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const fileInputTokens = reviews.reduce((sum, review2) => sum + (review2.input_tokens ?? 0), 0);
+  const fileOutputTokens = reviews.reduce((sum, review2) => sum + (review2.output_tokens ?? 0), 0);
+  const severityDistribution = {};
+  for (const comment of finalComments) {
+    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;
+  await env.jobs.completeJob(job.id, {
+    verdict: verdictSummary.verdict,
+    fileCount: files.length,
+    commentCount: finalComments.length,
+    totalInputTokens: fileInputTokens,
+    totalOutputTokens: fileOutputTokens,
+    summaryMarkdown: formattedSummary,
+    reviewId: review.id,
+    summaryModel: null,
+    errorMessage: partialErrorMessage
+  });
+  logger.info(`Review job completed: ${job.owner}/${job.repo} PR #${job.prNumber}`);
+  try {
+    if (job.checkRunId) {
+      await github.updateCheckRun(job.owner, job.repo, job.checkRunId, {
+        status: "completed",
+        conclusion: hasFailures ? "failure" : verdictSummary.verdict === "approve" ? "success" : "neutral",
+        title: hasFailures ? "Review partially failed" : verdictSummary.verdict === "approve" ? "LGTM" : "Comments posted",
+        summary: `${finalComments.length} inline comments across ${files.length} files.${hasFailures ? ` ${failedFileCount} file${failedFileCount === 1 ? "" : "s"} could not be reviewed.` : ""}`
+      });
+      await env.jobs.markJobCheckRunCompleted(job.id);
+    }
+    if (config.review.labels !== false) {
+      const labels = config.review.labels;
+      const labelMap = {
+        comment: { name: labels.p1, color: "f79009" },
+        approve: { name: labels.p2, color: "027a48" }
+      };
+      const label = labelMap[verdictSummary.verdict];
+      await github.removeIssueLabelsIfPresent(
+        job.owner,
+        job.repo,
+        job.prNumber,
+        [labels.p1, labels.p2, labels.p3].filter((possibleLabel) => possibleLabel !== label.name)
+      );
+      await github.ensureLabel(job.owner, job.repo, label.name, label.color);
+      await github.addIssueLabels(job.owner, job.repo, job.prNumber, [label.name]);
+    }
+  } catch (error) {
+    logger.warn(`Post-review labels/check-run update failed for job ${job.id}; review is posted and job is completed, so leaving it best-effort`, error instanceof Error ? error : new Error(String(error)));
+  }
+  await sendReviewTelemetry(
+    env,
+    job,
+    files,
+    reviews,
+    { findingsReported: finalComments.length, verdict: verdictSummary.verdict, severityDistribution },
+    { concurrencyLevel, retryCount }
+  );
+}
+
+// src/review/index.ts
+async function runReview(env, message) {
+  const resolved = await resolveQueuedJob(env, message);
+  if (!resolved) {
+    return { action: "ack" };
+  }
+  if (resolved.job.status === "queued") {
+    const { concurrencyLevel } = await env.settings.getReviewSettings();
+    const maxConcurrentJobs = REVIEW_CONCURRENCY_LIMITS2[concurrencyLevel];
+    const runningCount = await env.jobs.getOtherRunningJobsCount(resolved.job.id);
+    if (runningCount >= maxConcurrentJobs) {
+      logger.info(`Throttling admission of job ${resolved.job.id}: ${runningCount} other jobs are currently running.`);
+      return { action: "retry", delaySeconds: 30 };
+    }
+  }
+  const leaseOwner = env.ids.randomUUID();
+  const claim = await env.jobs.claimJobLease(resolved.job.id, leaseOwner, JOB_LEASE_SECONDS);
+  if (claim.status === "missing") {
+    logger.warn(`Job not found for processing: ${resolved.job.id}`);
+    return { action: "ack" };
+  }
+  if (claim.status === "terminal") {
+    logger.info(`Job ${resolved.job.id} is already terminal (${claim.row.status}), acking queue delivery.`);
+    return { action: "ack" };
+  }
+  if (claim.status === "busy") {
+    logger.info(`Job ${resolved.job.id} has a fresh lease; retrying queue delivery later.`);
+    return { action: "retry", delaySeconds: Math.min(BUSY_RETRY_SECONDS, claim.retryAfterSeconds) };
+  }
+  const job = env.jobs.mapJob(claim.row);
+  if (message.workflowInstanceId && job.workflowInstanceId !== message.workflowInstanceId) {
+    try {
+      await env.jobs.setJobWorkflowInstance(job.id, message.workflowInstanceId);
+    } catch (error) {
+      logger.warn(`Failed to bind workflow instance id for job ${job.id}`, error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  const phase = resolved.phase;
+  const tracker = env.createTokenTracker();
+  const github = env.createGitHub(job.installationId, tracker);
+  const model = env.createModel(job.id, tracker);
+  const formatter = env.createFormatter();
+  try {
+    if (phase === "prepare") {
+      await runPreparePhase(env, job, leaseOwner, github);
+    } else if (phase === "finalize") {
+      await runFinalizePhase(env, job, leaseOwner, github, formatter, model);
+    } else {
+      await runReviewPhase(env, job, leaseOwner, github, model, tracker);
+    }
+    await env.jobs.releaseJobLease(job.id, leaseOwner);
+    return { action: "ack" };
+  } catch (error) {
+    const messageText = error instanceof Error ? error.message : "Unknown review failure";
+    if (messageText === "JOB_SUPERSEDED") {
+      logger.info(`Job ${job.id} was superseded during execution, stopping.`);
+      await env.jobs.releaseJobLease(job.id, leaseOwner);
+      return { action: "ack" };
+    }
+    if (error instanceof NextPhaseError) {
+      await env.jobs.releaseJobLease(job.id, leaseOwner);
+      return { action: "next_phase", phase: error.phase, delaySeconds: error.delaySeconds, jobId: job.id, freshInstance: error.phase === "finalize" };
+    }
+    if (env.modelErrors.isRetryableModelError(error)) {
+      const delaySeconds = getRetryableModelFailureDelaySeconds(error);
+      logger.warn(`Review job hit transient model/provider failure; scheduling delayed continuation: ${job.owner}/${job.repo} PR #${job.prNumber}`, {
+        error: messageText,
+        phase,
+        delaySeconds
+      });
+      return continueOrFailWedgedJob(env, job, github, leaseOwner, phase, delaySeconds, "transient model/provider failures");
+    }
+    if (isSubrequestBudgetError(error)) {
+      const record = error && typeof error === "object" ? error : null;
+      const delaySeconds = typeof record?.retryAfterSeconds === "number" ? record.retryAfterSeconds : FRESH_INVOCATION_YIELD_SECONDS;
+      logger.warn(`Review job hit the per-invocation subrequest limit; rescheduling ${phase} on a fresh budget: ${job.owner}/${job.repo} PR #${job.prNumber}`, {
+        error: messageText,
+        phase,
+        delaySeconds
+      });
+      return continueOrFailWedgedJob(env, job, github, leaseOwner, phase, delaySeconds, "per-invocation subrequest limits");
+    }
+    console.error("JOB FAILED WITH ERROR:", error);
+    logger.error(`Review job failed: ${job.owner}/${job.repo} PR #${job.prNumber}`, error);
+    await failJobAndCheckRun(env, job, github, messageText);
+    await env.jobs.releaseJobLease(job.id, leaseOwner);
+    return { action: "ack" };
+  }
+}
+async function continueOrFailWedgedJob(env, job, github, leaseOwner, phase, delaySeconds, reason) {
+  const continuationCount = await env.jobs.markJobContinuationQueued(job.id, delaySeconds);
+  const ceiling = phase === "finalize" ? MAX_FINALIZE_CONTINUATIONS : MAX_JOB_CONTINUATIONS;
+  if (continuationCount > ceiling) {
+    if (phase === "review") {
+      logger.error(`Review job exceeded the continuation ceiling; degrading to a partial review: ${job.owner}/${job.repo} PR #${job.prNumber}`, {
+        phase,
+        continuationCount,
+        reason
+      });
+      const stillPending = (await env.fileReviews.getFileReviewsForJobs([job.id])).filter(isAwaitingAsyncReview);
+      for (const review of stillPending) {
+        await persistFailedFileReview(env, job.id, {
+          filePath: review.file_path,
+          modelUsed: review.async_model ?? review.model_used,
+          diffLineCount: review.diff_line_count,
+          errorMessage: "Async batch review did not complete before the job wedged.",
+          clearAsync: true
+        });
+      }
+      await env.jobs.resetJobContinuationCount(job.id);
+      await env.jobs.releaseJobLease(job.id, leaseOwner);
+      return { action: "next_phase", phase: "finalize", delaySeconds: FRESH_INVOCATION_YIELD_SECONDS, jobId: job.id, freshInstance: true };
+    } else {
+      const message = `Review could not make progress after ${continuationCount} continuation attempts (${reason}). Failing the job to avoid an endless retry loop; re-run it once the underlying provider issue clears.`;
+      logger.error(`Review job exceeded the continuation ceiling; failing terminally: ${job.owner}/${job.repo} PR #${job.prNumber}`, {
+        phase,
+        continuationCount,
+        reason
+      });
+      await failJobAndCheckRun(env, job, github, message);
+      await env.jobs.releaseJobLease(job.id, leaseOwner);
+      return { action: "ack" };
+    }
+  }
+  await env.jobs.releaseJobLease(job.id, leaseOwner);
+  const freshInstance = reason.includes("subrequest");
+  return { action: "next_phase", phase, delaySeconds, jobId: job.id, freshInstance };
+}
+async function resolveQueuedJob(env, message) {
+  if (message.jobId) {
+    const row = await env.jobs.getJobForProcessing(message.jobId);
+    return row ? { job: env.jobs.mapJob(row), phase: message.phase ?? "review" } : null;
+  }
+  if (!message.eventName) {
+    logger.warn("Queue message ignored: missing eventName");
+    return null;
+  }
+  let eventName = message.eventName;
+  let payload = message.payload;
+  if (payload === void 0) {
+    const delivery = await env.webhooks.getWebhookDelivery(message.deliveryId);
+    if (!delivery) {
+      logger.warn(`Queue message ignored: webhook delivery not found: ${message.deliveryId}`);
+      return null;
+    }
+    eventName = delivery.event_name;
+    payload = delivery.payload;
+  }
+  if (eventName !== "change_request" && eventName !== "comment") {
+    logger.info(`Queue message ignored: unsupported webhook event ${eventName}`);
+    return null;
+  }
+  const installationId = String(payload.installationId ?? "");
+  if (!installationId || !("repository" in payload) || !payload.repository) {
+    logger.info("Queue message ignored: missing installation or repository info");
+    return null;
+  }
+  const repoConfig = await env.repoConfig.loadRepoConfig({
+    installationId,
+    owner: payload.repository.owner,
+    repo: payload.repository.name
+  });
+  if (repoConfig.enabled === false) {
+    logger.info(`Job ignored: repository ${payload.repository.owner}/${payload.repository.name} is disabled`);
+    return null;
+  }
+  const extracted = extractReviewRequest({
+    eventName,
+    payload,
+    botUsername: env.botUsername,
+    config: repoConfig.parsedJson
+  });
+  if (!extracted) {
+    if (eventName === "change_request") {
+      const prPayload = payload;
+      if (prPayload.action === "closed" && repoConfig.parsedJson.review.labels !== false) {
+        const labels = repoConfig.parsedJson.review.labels;
+        const gh = env.githubClients.forInstallation(installationId);
+        await gh.removeIssueLabelsIfPresent(
+          prPayload.repository.owner,
+          prPayload.repository.name,
+          prPayload.changeRequest.number,
+          [labels.p1, labels.p2, labels.p3]
+        );
+      }
+    }
+    return null;
+  }
+  let resolved = extracted;
+  const githubClient = env.githubClients.forInstallation(installationId);
+  if (eventName === "comment") {
+    const pr = await githubClient.getPullRequest(extracted.owner, extracted.repo, extracted.prNumber);
+    resolved = {
+      ...extracted,
+      prTitle: pr.title,
+      prAuthor: pr.user.login,
+      commitSha: pr.head.sha,
+      baseSha: pr.base.sha,
+      headRef: pr.head.ref,
+      baseRef: pr.base.ref
+    };
+  }
+  const duplicateJob = await env.jobs.findExistingJobForHead({
+    owner: resolved.owner,
+    repo: resolved.repo,
+    prNumber: resolved.prNumber,
+    commitSha: resolved.commitSha,
+    trigger: resolved.trigger
+  });
+  if (duplicateJob) {
+    if (duplicateJob.status === "queued" || duplicateJob.status === "running") {
+      logger.info(`Resuming duplicate in-flight job ${duplicateJob.id} for ${resolved.owner}/${resolved.repo} PR #${resolved.prNumber}.`);
+      return { job: duplicateJob, phase: message.phase ?? "prepare" };
+    }
+    logger.info(`Duplicate terminal job found for ${resolved.owner}/${resolved.repo} PR #${resolved.prNumber}, skipping.`);
+    return null;
+  }
+  const job = await env.jobs.insertJob({
+    installationId: resolved.installationId,
+    owner: resolved.owner,
+    repo: resolved.repo,
+    prNumber: resolved.prNumber,
+    prTitle: resolved.prTitle,
+    prAuthor: resolved.prAuthor,
+    commitSha: resolved.commitSha,
+    baseSha: resolved.baseSha,
+    trigger: resolved.trigger,
+    headRef: resolved.headRef,
+    baseRef: resolved.baseRef,
+    configSnapshot: repoConfig.parsedJson
+  });
+  await env.jobs.supersedeOlderJobs({
+    installationId: resolved.installationId,
+    owner: resolved.owner,
+    repo: resolved.repo,
+    prNumber: resolved.prNumber,
+    newJobId: job.id
+  });
+  return { job, phase: "prepare" };
+}
+export {
+  BIN_DIFF_CHAR_BUDGET,
+  BIN_MAX_FILES,
+  BIN_TARGET_DIFF_LINES,
+  FRESH_INVOCATION_YIELD_SECONDS,
+  InMemoryKV,
+  InMemoryOrchestrator,
+  InMemoryQueue,
+  InMemorySessionStore,
+  NextPhaseError,
+  PACKABLE_MAX_DIFF_LINES,
+  budgetAwareFileLimit,
+  estimatedSubrequestsPerFile,
+  extractReviewRequest,
+  failJobAndCheckRun,
+  getDiffFiles,
+  getOrFetchRawDiffForCompletedJob,
+  narrowUnit,
+  planReviewUnits,
+  proportionalSplit,
+  runReview,
+  unitFiles,
+  verifyFindings
+};
+//# sourceMappingURL=index.js.map