@h-rig/bundle-default-lifecycle 0.0.6-alpha.155 → 0.0.6-alpha.157

package/dist/src/control-plane/verifier.js

@@ -0,0 +1,1478 @@
+// @bun
+// packages/bundle-default-lifecycle/src/control-plane/verifier.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { resolveRuntimeSecrets } from "@rig/runtime/control-plane/runtime/baked-secrets";
+import { readPrMetadata } from "@rig/runtime/control-plane/native/git-ops";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { readConfiguredTaskSourceTask } from "@rig/runtime/control-plane/tasks/source-lifecycle";
+import { artifactDirForId, lookupTask, readTaskConfig } from "@rig/runtime/control-plane/native/task-state";
+import { nowIso, resolveHarnessPaths, runCapture } from "@rig/runtime/control-plane/native/utils";
+import {
+  collectPrReviewEvidence,
+  evaluateStrictPrMergeGate,
+  parseGreptileScore,
+  stripHtml
+} from "@rig/pr-review-plugin";
+async function verifyTask(options) {
+  const paths = resolveHarnessPaths(options.projectRoot);
+  const taskId = options.taskId;
+  const normalizedTaskId = lookupTask(options.projectRoot, taskId);
+  const artifactDir = artifactDirForId(options.projectRoot, taskId);
+  mkdirSync(artifactDir, { recursive: true });
+  const validationSummaryPath = resolve(artifactDir, "validation-summary.json");
+  const reviewFeedbackPath = resolve(artifactDir, "review-feedback.md");
+  const reviewStatePath = resolve(artifactDir, "review-state.json");
+  const greptileRawPath = resolve(artifactDir, "review-greptile-raw.json");
+  const prStates = readPrMetadata(options.projectRoot, taskId);
+  const prState = prStates[0] || null;
+  const localReasons = [];
+  const aiReasons = [];
+  const aiWarnings = [];
+  let aiVerdict = "SKIP";
+  let aiRawFeedback = "";
+  const persistArtifacts = options.persistArtifacts !== false;
+  if (!normalizedTaskId && !await hasConfiguredSourceTask(options.projectRoot, taskId)) {
+    localReasons.push(`[Task Config] Unknown task id '${taskId}' in task-config or configured task source.`);
+  }
+  if (!existsSync(validationSummaryPath)) {
+    localReasons.push(`[Artifact Quality] validation-summary.json not found at ${validationSummaryPath}.`);
+  } else {
+    const summary = await parseValidationSummary(validationSummaryPath);
+    if (!isAcceptedValidationSummary(summary)) {
+      localReasons.push(`[Validation] validation-summary status is '${summary?.status ?? "unknown"}', expected 'pass' or zero-check 'skipped'.`);
+    }
+  }
+  for (const file of ["task-result.json", "decision-log.md", "next-actions.md", "changed-files.txt"]) {
+    const requiredPath = resolve(artifactDir, file);
+    if (!existsSync(requiredPath)) {
+      localReasons.push(`[Artifact Quality] Missing required artifact file: ${requiredPath}`);
+    }
+  }
+  const taskResultPath = resolve(artifactDir, "task-result.json");
+  if (existsSync(taskResultPath)) {
+    const taskResult = await readJsonFile(taskResultPath);
+    const artifactStatus = typeof taskResult?.status === "string" ? taskResult.status.trim().toLowerCase() : "";
+    if (artifactStatus === "partial") {
+      localReasons.push("[Artifact Quality] task-result.json status is 'partial'; completion requires a terminal result.");
+    }
+    if (hasNonEmptyBlockers(taskResult?.blockers)) {
+      localReasons.push("[Artifact Quality] task-result.json blockers must be empty for completion.");
+    }
+    if (nextActionsIndicateRemainingScope(stringifyNextActions(taskResult?.nextActions ?? taskResult?.next_actions))) {
+      localReasons.push("[Artifact Quality] task-result.json next actions indicate remaining implementation scope.");
+    }
+  }
+  const nextActionsPath = resolve(artifactDir, "next-actions.md");
+  if (existsSync(nextActionsPath)) {
+    const nextActionsContent = await Bun.file(nextActionsPath).text();
+    if (nextActionsContent.includes("TODO: Replace this scaffold") || nextActionsContent.includes("bd-<downstream-task-id>")) {
+      localReasons.push("[Artifact Quality] next-actions.md still contains scaffold placeholder text. Replace with real recommendations.");
+    }
+    if (nextActionsIndicateRemainingScope(nextActionsContent)) {
+      localReasons.push("[Artifact Quality] next-actions.md indicates remaining implementation scope.");
+    }
+  }
+  const sourceCloseoutIssueId = resolveGithubSourceIssueId(options.projectRoot, taskId);
+  if (sourceCloseoutIssueId) {
+    localReasons.push(...evaluateGithubSourceIssuePrCloseout(options.projectRoot, prStates, sourceCloseoutIssueId));
+  }
+  const reviewMode = await loadReviewMode(paths.reviewProfilePath, process.env.AI_REVIEW_MODE || "advisory");
+  const reviewProvider = await loadReviewProvider(paths.reviewProfilePath, process.env.AI_REVIEW_PROVIDER || "github");
+  if (!options.skipAiReview && localReasons.length === 0 && reviewProvider === "greptile" && reviewMode !== "off") {
+    const ai = await runGreptileReview({
+      projectRoot: options.projectRoot,
+      taskId,
+      artifactDir,
+      prStates,
+      reviewMode
+    });
+    aiVerdict = ai.verdict;
+    aiRawFeedback = ai.feedback;
+    aiReasons.push(...ai.reasons);
+    aiWarnings.push(...ai.warnings);
+    if (reviewMode === "required" && ai.verdict !== "APPROVE" && ai.reasons.length === 0) {
+      aiReasons.push(`[AI Review] Required mode needs a completed Greptile approval; current verdict is ${ai.verdict}.`);
+    }
+    if (persistArtifacts && ai.rawResponse) {
+      writeFileSync(greptileRawPath, `${ai.rawResponse}
+`, "utf-8");
+    }
+  } else if (!options.skipAiReview && reviewMode === "off") {
+    aiWarnings.push("[AI Review] AI review mode is off.");
+  }
+  const aiReviewApproved = options.skipAiReview || reviewProvider !== "greptile" || isAiReviewApproved({
+    reviewMode,
+    aiVerdict,
+    aiReasons
+  });
+  if (persistArtifacts) {
+    writeFeedbackFile({
+      taskId,
+      provider: reviewProvider,
+      mode: reviewMode,
+      verdict: aiVerdict,
+      localReasons,
+      aiReasons,
+      aiWarnings,
+      aiRawFeedback,
+      output: reviewFeedbackPath
+    });
+    writeReviewStateFile({
+      taskId,
+      approved: localReasons.length === 0 && aiReviewApproved,
+      provider: reviewProvider,
+      mode: reviewMode,
+      verdict: aiVerdict,
+      prState,
+      localReasons,
+      aiReasons,
+      aiWarnings,
+      output: reviewStatePath
+    });
+  }
+  if (localReasons.length > 0) {
+    return {
+      approved: false,
+      localReasons,
+      aiReasons,
+      aiWarnings,
+      aiVerdict,
+      reviewFeedbackPath,
+      reviewStatePath
+    };
+  }
+  if (!aiReviewApproved) {
+    return {
+      approved: false,
+      localReasons,
+      aiReasons,
+      aiWarnings,
+      aiVerdict,
+      reviewFeedbackPath,
+      reviewStatePath
+    };
+  }
+  return {
+    approved: true,
+    localReasons,
+    aiReasons,
+    aiWarnings,
+    aiVerdict,
+    reviewFeedbackPath,
+    reviewStatePath
+  };
+}
+async function readJsonFile(path) {
+  try {
+    return await Bun.file(path).json();
+  } catch {
+    return null;
+  }
+}
+function hasNonEmptyBlockers(blockers) {
+  if (blockers == null) {
+    return false;
+  }
+  if (typeof blockers === "string") {
+    const normalized = blockers.trim().toLowerCase();
+    return normalized.length > 0 && normalized !== "none" && normalized !== "n/a";
+  }
+  if (Array.isArray(blockers)) {
+    return blockers.some((entry) => {
+      if (typeof entry === "string") {
+        const normalized = entry.trim().toLowerCase();
+        return normalized.length > 0 && normalized !== "none" && normalized !== "n/a";
+      }
+      return entry != null;
+    });
+  }
+  if (typeof blockers === "object") {
+    return Object.keys(blockers).length > 0;
+  }
+  return Boolean(blockers);
+}
+function stringifyNextActions(value) {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => stringifyNextActions(entry)).join(`
+`);
+  }
+  return JSON.stringify(value);
+}
+function nextActionsIndicateRemainingScope(content) {
+  const normalized = content.trim();
+  if (!normalized) {
+    return false;
+  }
+  const lower = normalized.toLowerCase();
+  if (/^(#\s*)?next actions\s*\n+\s*(none|n\/a|no remaining scope)\.?\s*$/i.test(normalized)) {
+    return false;
+  }
+  return /^\s*- \[ \]/m.test(normalized) || /\b(remaining scope|still need|needs? to be implemented|not yet implemented|not implemented|follow[- ]?up required|blocked by|blocker:)\b/i.test(lower);
+}
+async function hasConfiguredSourceTask(projectRoot, taskId) {
+  return readConfiguredTaskSourceTask(projectRoot, taskId).then((result) => result.task !== null).catch(() => false);
+}
+function resolveGithubSourceIssueId(projectRoot, taskId) {
+  const fromRuntime = loadRuntimeContextFromEnv()?.sourceTask?.sourceIssueId;
+  if (typeof fromRuntime === "string" && isGithubSourceIssueId(fromRuntime)) {
+    return fromRuntime;
+  }
+  try {
+    const taskConfig = readTaskConfig(projectRoot);
+    const entry = taskConfig[taskId];
+    const sourceIssueId = typeof entry?.sourceIssueId === "string" ? entry.sourceIssueId : typeof entry?.source_issue_id === "string" ? entry.source_issue_id : null;
+    if (sourceIssueId && isGithubSourceIssueId(sourceIssueId)) {
+      return sourceIssueId;
+    }
+    const rig = entry?._rig;
+    if (rig && typeof rig === "object" && !Array.isArray(rig)) {
+      const rigRecord = rig;
+      const rigSourceIssueId = typeof rigRecord.sourceIssueId === "string" ? rigRecord.sourceIssueId : null;
+      if (rigSourceIssueId && isGithubSourceIssueId(rigSourceIssueId)) {
+        return rigSourceIssueId;
+      }
+    }
+  } catch {}
+  return null;
+}
+function isGithubSourceIssueId(value) {
+  return /^[^/\s]+\/[^#\s]+#\d+$/.test(value.trim());
+}
+function evaluateGithubSourceIssuePrCloseout(projectRoot, prStates, sourceIssueId) {
+  const issueNumber = sourceIssueId.match(/#(\d+)$/)?.[1];
+  if (!issueNumber) {
+    return [`[Source Issue] GitHub issue task ${sourceIssueId} has an invalid source issue id.`];
+  }
+  if (prStates.length === 0) {
+    return [
+      `[Source Issue] GitHub issue task ${sourceIssueId} must have an open, green, mergeable PR with resolved review feedback and closeout intent (for example "Closes #${issueNumber}"). Source issue closure or merge is not required before completion.`
+    ];
+  }
+  const rejectionReasons = [];
+  for (const prState of prStates) {
+    const hydratedPr = hydratePrCloseoutState(projectRoot, prState);
+    const prReasons = evaluateSinglePrSourceIssueCloseout(hydratedPr, sourceIssueId, issueNumber);
+    if (prReasons.length === 0) {
+      return [];
+    }
+    rejectionReasons.push(...prReasons);
+  }
+  return uniqueStrings(rejectionReasons);
+}
+function hydratePrCloseoutState(projectRoot, prState) {
+  if (hasLocalPrCloseoutEvidence(prState)) {
+    return prState;
+  }
+  const snapshot = loadGithubPullRequestCloseoutSnapshot(projectRoot, prState);
+  return snapshot ? { ...prState, ...snapshot } : prState;
+}
+function hasLocalPrCloseoutEvidence(prState) {
+  const hasCloseoutText = typeof prState.title === "string" || typeof prState.body === "string" || Array.isArray(prState.closingIssues) && prState.closingIssues.length > 0;
+  return hasCloseoutText && typeof prState.state === "string" && typeof prState.isDraft === "boolean" && typeof prState.mergeable === "string" && typeof prState.mergeStateStatus === "string" && typeof prState.reviewDecision === "string" && Array.isArray(prState.statusCheckRollup) && Array.isArray(prState.reviewThreads);
+}
+function loadGithubPullRequestCloseoutSnapshot(projectRoot, prState) {
+  const prNumber = parsePullRequestNumber(prState.url || "");
+  if (!prNumber) {
+    return null;
+  }
+  try {
+    const repoName = deriveRepoName(projectRoot, prState);
+    if (!repoName) {
+      return null;
+    }
+    const view = runGhJson(projectRoot, [
+      "pr",
+      "view",
+      `${prNumber}`,
+      "--repo",
+      repoName,
+      "--json",
+      "state,isDraft,mergeable,mergeStateStatus,reviewDecision,title,body,statusCheckRollup"
+    ]);
+    return {
+      state: stringField(view, "state"),
+      isDraft: booleanField(view, "isDraft"),
+      mergeable: stringField(view, "mergeable"),
+      mergeStateStatus: stringField(view, "mergeStateStatus"),
+      reviewDecision: stringField(view, "reviewDecision"),
+      title: stringField(view, "title"),
+      body: stringField(view, "body"),
+      statusCheckRollup: statusCheckRollupField(view, "statusCheckRollup"),
+      reviewThreads: loadGithubReviewThreads(projectRoot, repoName, prNumber)
+    };
+  } catch {
+    return null;
+  }
+}
+function evaluateSinglePrSourceIssueCloseout(prState, sourceIssueId, issueNumber) {
+  const prLabel = prState.url || prState.branch || "recorded PR";
+  const reasons = [];
+  if (!prStateClosesIssue(prState, sourceIssueId, issueNumber)) {
+    reasons.push(`[Source Issue] GitHub issue task ${sourceIssueId} must have PR closeout intent (for example "Closes #${issueNumber}"). "Closes part of #N" is not sufficient.`);
+  }
+  const state = (prState.state || "").toUpperCase();
+  if (state !== "OPEN") {
+    reasons.push(`[Source Issue] PR ${prLabel} must be open before operator-controlled merge; current state is ${prState.state || "unknown"}.`);
+  }
+  if (prState.isDraft !== false) {
+    reasons.push(`[Source Issue] PR ${prLabel} must not be a draft.`);
+  }
+  const mergeable = (prState.mergeable || "").toUpperCase();
+  const mergeStateStatus = (prState.mergeStateStatus || "").toUpperCase();
+  if (mergeable !== "MERGEABLE" || mergeStateStatus === "DIRTY" || mergeStateStatus === "BLOCKED") {
+    reasons.push(`[Source Issue] PR ${prLabel} must be mergeable before completion (mergeable=${prState.mergeable || "unknown"}, mergeStateStatus=${prState.mergeStateStatus || "unknown"}).`);
+  }
+  reasons.push(...evaluateSourceCloseoutChecks(prState, prLabel));
+  reasons.push(...evaluateSourceCloseoutReviewState(prState, prLabel));
+  return reasons;
+}
+function evaluateSourceCloseoutChecks(prState, prLabel) {
+  const checks = prState.statusCheckRollup;
+  if (!Array.isArray(checks) || checks.length === 0) {
+    return [`[Source Issue] PR ${prLabel} must have green check evidence before completion.`];
+  }
+  const ciGate = evaluatePullRequestCiChecks(checks, "PR", 0, { mergeStateStatus: prState.mergeStateStatus });
+  if (ciGate.verdict === "APPROVE") {
+    return [];
+  }
+  return ciGate.reasons.map((reason) => reason.replace("PR#0", prLabel));
+}
+function evaluateSourceCloseoutReviewState(prState, prLabel) {
+  const reasons = [];
+  const reviewDecision = (prState.reviewDecision || "").toUpperCase();
+  if (reviewDecision === "REVIEW_REQUIRED" || reviewDecision === "CHANGES_REQUESTED") {
+    reasons.push(`[Source Issue] PR ${prLabel} required review is unresolved (${prState.reviewDecision}).`);
+  }
+  if (!Array.isArray(prState.reviewThreads)) {
+    reasons.push(`[Source Issue] PR ${prLabel} review thread resolution could not be verified.`);
+    return reasons;
+  }
+  for (const comment of filterUnresolvedReviewThreadComments(prState.reviewThreads)) {
+    reasons.push(`[Source Issue] PR ${prLabel} has unresolved review thread on ${comment.path || "unknown path"}: ${summarizeComment(comment.body || "")}`);
+  }
+  return reasons;
+}
+function filterUnresolvedReviewThreadComments(threads) {
+  const comments = [];
+  for (const thread of threads) {
+    if (thread.isResolved === true || thread.isOutdated === true) {
+      continue;
+    }
+    const threadComments = thread.comments?.nodes ?? [];
+    if (threadComments.length === 0) {
+      comments.push({ body: "Unresolved review thread" });
+      continue;
+    }
+    comments.push(threadComments[threadComments.length - 1]);
+  }
+  return comments;
+}
+function stringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+function booleanField(record, key) {
+  const value = record[key];
+  return typeof value === "boolean" ? value : undefined;
+}
+function statusCheckRollupField(record, key) {
+  const value = record[key];
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter(isGithubStatusCheckRollupItem);
+}
+function isGithubStatusCheckRollupItem(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values));
+}
+function prStateClosesIssue(pr, sourceIssueId, issueNumber) {
+  const closingIssues = pr.closingIssues ?? [];
+  if (closingIssues.some((issue) => closingIssueMatches(issue, sourceIssueId, issueNumber))) {
+    return true;
+  }
+  const text = [pr.title, pr.body].filter((value) => typeof value === "string").join(`
+`);
+  return prTextClosesIssue(text, issueNumber);
+}
+function closingIssueMatches(issue, sourceIssueId, issueNumber) {
+  if (typeof issue === "number") {
+    return String(issue) === issueNumber;
+  }
+  if (typeof issue === "string") {
+    return issue === sourceIssueId || issue.replace(/^#/, "") === issueNumber;
+  }
+  return String(issue.number ?? "") === issueNumber || issue.id === issueNumber || issue.sourceIssueId === sourceIssueId;
+}
+function prTextClosesIssue(text, issueNumber) {
+  if (!text.trim()) {
+    return false;
+  }
+  const escaped = issueNumber.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const closePattern = new RegExp(`\\b(close[sd]?|fix(e[sd])?|resolve[sd]?)\\s+#${escaped}\\b`, "i");
+  return closePattern.test(text);
+}
+async function parseValidationSummary(path) {
+  return readJsonFile(path);
+}
+function isAcceptedValidationSummary(summary) {
+  if (!summary) {
+    return false;
+  }
+  if (summary.status === "pass") {
+    return true;
+  }
+  return summary.status === "skipped" && summary.total === 0 && summary.failed === 0;
+}
+async function loadReviewMode(reviewProfilePath, fallback) {
+  const parsed = existsSync(reviewProfilePath) ? await readJsonFile(reviewProfilePath) : null;
+  const mode = parsed?.mode;
+  if (mode === "off" || mode === "advisory" || mode === "required") {
+    return mode;
+  }
+  if (fallback === "off" || fallback === "advisory" || fallback === "required") {
+    return fallback;
+  }
+  return "advisory";
+}
+async function loadReviewProvider(reviewProfilePath, fallback) {
+  const parsed = existsSync(reviewProfilePath) ? await readJsonFile(reviewProfilePath) : null;
+  const provider = parsed?.provider;
+  if (typeof provider === "string" && provider.trim().length > 0) {
+    return provider;
+  }
+  return fallback || "greptile";
+}
+function resolveRepoSlug(projectRoot) {
+  const paths = resolveHarnessPaths(projectRoot);
+  const remote = runCapture(["git", "-C", paths.monorepoRoot, "remote", "get-url", "origin"], projectRoot).stdout.trim() || runCapture(["git", "-C", projectRoot, "remote", "get-url", "origin"], projectRoot).stdout.trim();
+  if (!remote) {
+    return "";
+  }
+  if (remote.startsWith("git@")) {
+    return remote.split(":")[1]?.replace(/\.git$/, "") || "";
+  }
+  const cleaned = remote.replace(/^https?:\/\//, "").replace(/\.git$/, "");
+  const slash = cleaned.indexOf("/");
+  return slash >= 0 ? cleaned.slice(slash + 1) : cleaned;
+}
+async function runGreptileReview(options) {
+  const reasons = [];
+  const warnings = [];
+  const secrets = resolveRuntimeSecrets(process.env);
+  const apiKey = secrets.GREPTILE_API_KEY || "";
+  const apiBase = secrets.GREPTILE_API_BASE || "https://api.greptile.com/mcp";
+  const remote = secrets.GREPTILE_REMOTE || "github";
+  const greptileDefaultBranch = secrets.GREPTILE_DEFAULT_BRANCH || "main";
+  const { pollAttempts, pollIntervalMs } = resolveGreptilePollSettings({
+    reviewMode: options.reviewMode,
+    secrets
+  });
+  if (!apiKey) {
+    reasons.push("[AI Review] Missing GREPTILE_API_KEY.");
+    return { verdict: "SKIP", feedback: "", reasons, warnings, rawResponse: "" };
+  }
+  if (options.prStates.length === 0) {
+    reasons.push("[AI Review] Missing pr-state.json or no PRs were recorded for review.");
+    return { verdict: "SKIP", feedback: "", reasons, warnings, rawResponse: "" };
+  }
+  const perPrResults = [];
+  for (const prState of options.prStates) {
+    try {
+      const prResult = await runGreptileReviewForPr({
+        apiBase,
+        apiKey,
+        remote,
+        defaultBranch: greptileDefaultBranch,
+        projectRoot: options.projectRoot,
+        taskId: options.taskId,
+        prState,
+        reviewMode: options.reviewMode,
+        pollAttempts,
+        pollIntervalMs
+      });
+      if (prResult.verdict === "SKIP") {
+        warnings.push(...prResult.reasons.map(asGreptileInfrastructureWarning));
+      } else {
+        reasons.push(...prResult.reasons);
+      }
+      warnings.push(...prResult.warnings);
+      perPrResults.push(prResult);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const fallback = await runGithubGreptileFallbackReviewForPr({
+        projectRoot: options.projectRoot,
+        taskId: options.taskId,
+        prState,
+        reviewMode: options.reviewMode,
+        infrastructureError: message,
+        pollAttempts,
+        pollIntervalMs
+      }).catch(() => null);
+      if (fallback) {
+        if (fallback.verdict === "SKIP") {
+          warnings.push(...fallback.reasons.map(asGreptileInfrastructureWarning));
+        } else {
+          reasons.push(...fallback.reasons);
+        }
+        warnings.push(...fallback.warnings);
+        perPrResults.push(fallback);
+        continue;
+      }
+      warnings.push(asGreptileInfrastructureWarning(`Greptile infrastructure failure for ${prState.url || prState.branch || options.taskId}: ${message}`));
+      perPrResults.push({
+        verdict: "SKIP",
+        feedback: "",
+        reasons: [],
+        warnings: [],
+        rawPayload: { pr: prState, error: message }
+      });
+    }
+  }
+  if (perPrResults.some((result) => result.verdict === "REJECT")) {
+    return {
+      verdict: "REJECT",
+      feedback: perPrResults.map((result) => result.feedback).filter(Boolean).join(`
+
+`),
+      reasons,
+      warnings,
+      rawResponse: JSON.stringify(perPrResults.map((result) => result.rawPayload), null, 2)
+    };
+  }
+  if (perPrResults.every((result) => result.verdict === "APPROVE")) {
+    return {
+      verdict: "APPROVE",
+      feedback: perPrResults.map((result) => result.feedback).filter(Boolean).join(`
+
+`),
+      reasons,
+      warnings,
+      rawResponse: JSON.stringify(perPrResults.map((result) => result.rawPayload), null, 2)
+    };
+  }
+  return {
+    verdict: "SKIP",
+    feedback: perPrResults.map((result) => result.feedback).filter(Boolean).join(`
+
+`),
+    reasons,
+    warnings,
+    rawResponse: JSON.stringify(perPrResults.map((result) => result.rawPayload), null, 2)
+  };
+}
+function writeFeedbackFile(options) {
+  const lines = [
+    "# AI Review Feedback",
+    "",
+    `- Task: ${options.taskId}`,
+    `- Provider: ${options.provider}`,
+    `- Mode: ${options.mode}`,
+    `- Verdict: ${options.verdict}`,
+    ""
+  ];
+  if (options.localReasons.length > 0) {
+    lines.push("## Local Rejection Reasons", "");
+    for (const reason of options.localReasons) {
+      lines.push(`- ${reason}`);
+    }
+    lines.push("");
+  }
+  if (options.aiReasons.length > 0) {
+    lines.push("## AI Rejection Reasons", "");
+    for (const reason of options.aiReasons) {
+      lines.push(`- ${reason}`);
+    }
+    lines.push("");
+  }
+  if (options.aiWarnings.length > 0) {
+    lines.push("## AI Warnings", "");
+    for (const warning of options.aiWarnings) {
+      lines.push(`- ${warning}`);
+    }
+    lines.push("");
+  }
+  if (options.aiRawFeedback) {
+    lines.push("## Raw Reviewer Feedback", "", "```text", options.aiRawFeedback, "```", "");
+  }
+  writeFileSync(options.output, `${lines.join(`
+`)}
+`, "utf-8");
+}
+function writeReviewStateFile(options) {
+  const payload = {
+    task_id: options.taskId,
+    approved: options.approved,
+    provider: options.provider,
+    mode: options.mode,
+    verdict: options.verdict,
+    pr: options.prState,
+    local_reasons: options.localReasons,
+    ai_reasons: options.aiReasons,
+    ai_warnings: options.aiWarnings,
+    updated_at: nowIso()
+  };
+  writeFileSync(options.output, `${JSON.stringify(payload, null, 2)}
+`, "utf-8");
+}
+async function runGreptileReviewForPr(options) {
+  const reasons = [];
+  const warnings = [];
+  const repoName = deriveRepoName(options.projectRoot, options.prState);
+  const prNumber = parsePullRequestNumber(options.prState.url || "");
+  const defaultBranch = options.defaultBranch;
+  const expectedHeadSha = resolvePrHeadSha(options.projectRoot, options.prState);
+  if (!repoName) {
+    reasons.push(`[AI Review] Could not resolve repository slug for ${options.prState.repoLabel || options.prState.target || "PR"}.`);
+    return { verdict: "SKIP", feedback: "", reasons, warnings, rawPayload: { pr: options.prState } };
+  }
+  if (!prNumber) {
+    reasons.push(`[AI Review] Could not parse PR number from ${options.prState.url || "missing PR URL"}.`);
+    return { verdict: "SKIP", feedback: "", reasons, warnings, rawPayload: { pr: options.prState } };
+  }
+  const githubPrState = loadGithubPullRequestState(options.projectRoot, repoName, prNumber);
+  if (shouldPreferGithubGreptileFallback(githubPrState)) {
+    return runGithubGreptileFallbackReviewForPr({
+      projectRoot: options.projectRoot,
+      taskId: options.taskId,
+      prState: options.prState,
+      reviewMode: options.reviewMode,
+      infrastructureError: undefined,
+      pollAttempts: options.pollAttempts,
+      pollIntervalMs: options.pollIntervalMs
+    });
+  }
+  const initialReviewsPayload = await callGreptileMcpToolJson(options.apiBase, options.apiKey, "list_code_reviews", {
+    name: repoName,
+    remote: options.remote,
+    defaultBranch,
+    prNumber,
+    limit: 20
+  });
+  const existingReview = findGreptileReviewForHeadSha(initialReviewsPayload.codeReviews || [], expectedHeadSha);
+  const shouldTrigger = shouldTriggerGreptileReview(existingReview, expectedHeadSha);
+  let triggerStartedAt = Date.now();
+  if (shouldTrigger) {
+    triggerStartedAt = Date.now();
+    await callGreptileMcpTool(options.apiBase, options.apiKey, "trigger_code_review", {
+      name: repoName,
+      remote: options.remote,
+      defaultBranch,
+      branch: options.prState.branch,
+      prNumber
+    }).catch((error) => {
+      throw new Error(`Greptile trigger failed for ${repoName}#${prNumber}: ${error instanceof Error ? error.message : String(error)}`);
+    });
+  } else {
+    const existingCreatedAt = Date.parse(existingReview?.createdAt || "");
+    triggerStartedAt = Number.isFinite(existingCreatedAt) ? existingCreatedAt : Date.now();
+  }
+  let selectedReview = null;
+  let reviewsPayload = initialReviewsPayload;
+  let githubCheckRollup = [];
+  let githubCheckState = { pending: false, completed: false };
+  for (let attempt = 0;; attempt += 1) {
+    const listPayload = attempt === 0 ? initialReviewsPayload : await callGreptileMcpToolJson(options.apiBase, options.apiKey, "list_code_reviews", {
+      name: repoName,
+      remote: options.remote,
+      defaultBranch,
+      prNumber,
+      limit: 20
+    });
+    reviewsPayload = listPayload;
+    selectedReview = pickRelevantCodeReview(listPayload.codeReviews || [], triggerStartedAt, expectedHeadSha);
+    githubCheckRollup = loadGithubPullRequestCheckRollup(options.projectRoot, repoName, prNumber);
+    githubCheckState = classifyGithubGreptileCheckState(githubCheckRollup);
+    if (!shouldContinueGreptileMcpPolling({
+      attempt,
+      pollAttempts: options.pollAttempts,
+      githubCheckState,
+      selectedReview
+    })) {
+      break;
+    }
+    await Bun.sleep(options.pollIntervalMs);
+  }
+  const ciGate = evaluatePullRequestCiChecks(githubCheckRollup, repoName, prNumber, { mergeStateStatus: options.prState.mergeStateStatus });
+  if (ciGate.verdict !== "APPROVE") {
+    return {
+      verdict: ciGate.verdict,
+      feedback: "",
+      reasons: ciGate.reasons,
+      warnings,
+      rawPayload: { pr: options.prState, codeReviews: reviewsPayload, checkRollup: githubCheckRollup }
+    };
+  }
+  if (!selectedReview) {
+    reasons.push(`[AI Review] Greptile did not produce a review for ${repoName}#${prNumber}.`);
+    return {
+      verdict: "SKIP",
+      feedback: "",
+      reasons,
+      warnings,
+      rawPayload: { pr: options.prState, codeReviews: reviewsPayload }
+    };
+  }
+  if (selectedReview.status === "FAILED") {
+    reasons.push(`[AI Review] Greptile review failed for ${repoName}#${prNumber}.`);
+    return {
+      verdict: "SKIP",
+      feedback: "",
+      reasons,
+      warnings,
+      rawPayload: { pr: options.prState, codeReviews: reviewsPayload, selectedReview }
+    };
+  }
+  if (selectedReview.status === "SKIPPED") {
+    reasons.push(`[AI Review] Greptile skipped review for ${repoName}#${prNumber}.`);
+    return {
+      verdict: "SKIP",
+      feedback: "",
+      reasons,
+      warnings,
+      rawPayload: { pr: options.prState, codeReviews: reviewsPayload, selectedReview }
+    };
+  }
+  if (selectedReview.status !== "COMPLETED") {
+    if (githubCheckState.completed) {
+      return runGithubGreptileFallbackReviewForPr({
+        projectRoot: options.projectRoot,
+        taskId: options.taskId,
+        prState: options.prState,
+        reviewMode: options.reviewMode,
+        infrastructureError: `Greptile MCP review stayed ${selectedReview.status} after the GitHub Greptile check completed.`,
+        pollAttempts: options.pollAttempts,
+        pollIntervalMs: options.pollIntervalMs
+      });
+    }
+    reasons.push(`[AI Review] Greptile review for ${repoName}#${prNumber} did not finish before timeout (last status: ${selectedReview.status}).`);
+    return {
+      verdict: "SKIP",
+      feedback: "",
+      reasons,
+      warnings,
+      rawPayload: { pr: options.prState, codeReviews: reviewsPayload, selectedReview }
+    };
+  }
+  const reviewDetails = await callGreptileMcpToolJson(options.apiBase, options.apiKey, "get_code_review", { codeReviewId: selectedReview.id });
+  const commentsPayload = await callGreptileMcpToolJson(options.apiBase, options.apiKey, "list_merge_request_comments", {
+    name: repoName,
+    remote: options.remote,
+    defaultBranch,
+    prNumber,
+    greptileGenerated: true,
+    createdAfter: selectedReview.createdAt
+  });
+  const actionableComments = filterActionableGreptileComments(commentsPayload.comments || []);
+  const reviewBody = reviewDetails.codeReview?.body || "";
+  const score = parseGreptileScore(reviewBody);
+  const feedback = [
+    `## ${options.prState.repoLabel || repoName} PR Review`,
+    "",
+    `- PR: ${options.prState.url || `${repoName}#${prNumber}`}`,
+    `- Review ID: ${selectedReview.id}`,
+    `- Status: ${selectedReview.status}`,
+    "",
+    reviewBody ? stripHtml(reviewBody).trim() : "Greptile completed without summary body."
+  ].filter(Boolean).join(`
+`);
+  if (actionableComments.length > 0) {
+    for (const comment of actionableComments) {
+      reasons.push(`[AI Review] ${repoName}#${prNumber} has unresolved Greptile comment on ${comment.filePath}: ${summarizeComment(comment.body || "")}`);
+    }
+    return {
+      verdict: "REJECT",
+      feedback,
+      reasons,
+      warnings,
+      rawPayload: {
+        pr: options.prState,
+        codeReviews: reviewsPayload,
+        selectedReview,
+        reviewDetails,
+        comments: commentsPayload
+      }
+    };
+  }
+  const blockerScanBody = stripHtml(reviewBody).replace(/\b(?:no|without|zero)\s+blockers?\b/gi, " ").replace(/\bno\s+changes\s+requested\b/gi, " ");
+  if (/not safe(?: to merge)?|unsafe(?: to merge)?|do not merge|cannot merge|blockers?|must fix|changes requested|please fix|needs? fix|fix this|address this|\breject(?:ed|ion)?\b|\bskip(?:ped)?\b|status\s*:\s*(?:reject(?:ed)?|skip(?:ped)?|failed)/i.test(blockerScanBody)) {
+    reasons.push(`[AI Review] ${repoName}#${prNumber} summary indicates the PR is not safe to merge.`);
+    return {
+      verdict: "REJECT",
+      feedback,
+      reasons,
+      warnings,
+      rawPayload: {
+        pr: options.prState,
+        codeReviews: reviewsPayload,
+        selectedReview,
+        reviewDetails,
+        comments: commentsPayload
+      }
+    };
+  }
+  if (score?.scale === 5 && score.value < 5) {
+    reasons.push(`[AI Review] ${repoName}#${prNumber} completed with Greptile confidence ${score.value}/${score.scale}; strict review requires 5/5 before merge.`);
+    return {
+      verdict: "REJECT",
+      feedback,
+      reasons,
+      warnings,
+      rawPayload: {
+        pr: options.prState,
+        codeReviews: reviewsPayload,
+        selectedReview,
+        reviewDetails,
+        comments: commentsPayload,
+        score
+      }
+    };
+  }
+  const prUrl = options.prState.url || `https://github.com/${repoName}/pull/${prNumber}`;
+  let strictGate = null;
+  try {
+    const strictEvidence = await collectStrictPrEvidenceForVerifier({
+      projectRoot: options.projectRoot,
+      taskId: options.taskId,
+      prUrl,
+      apiSignals: [{
+        id: selectedReview.id,
+        body: reviewBody,
+        reviewedSha: selectedReview.metadata?.checkHeadSha ?? null,
+        status: selectedReview.status
+      }]
+    });
+    strictGate = evaluateStrictPrMergeGate(strictEvidence);
+  } catch (error) {
+    reasons.push(`[AI Review] Strict Greptile evidence collection failed for ${repoName}#${prNumber}: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      verdict: "REJECT",
+      feedback,
+      reasons,
+      warnings,
+      rawPayload: {
+        pr: options.prState,
+        codeReviews: reviewsPayload,
+        selectedReview,
+        reviewDetails,
+        comments: commentsPayload,
+        score
+      }
+    };
+  }
+  if (!strictGate.approved) {
+    return {
+      verdict: strictGate.pending ? "SKIP" : "REJECT",
+      feedback,
+      reasons: strictGate.reasons.map((reason) => reason.startsWith("[AI Review]") ? reason : `[AI Review] ${reason}`),
+      warnings: [...warnings, ...strictGate.warnings],
+      rawPayload: {
+        pr: options.prState,
+        codeReviews: reviewsPayload,
+        selectedReview,
+        reviewDetails,
+        comments: commentsPayload,
+        score,
+        strictGate: {
+          approved: strictGate.approved,
+          pending: strictGate.pending,
+          reasons: strictGate.reasons,
+          reasonDetails: strictGate.reasonDetails,
+          warnings: strictGate.warnings,
+          greptile: strictGate.evidence.greptile,
+          readErrors: strictGate.evidence.readErrors
+        }
+      }
+    };
+  }
+  return {
+    verdict: "APPROVE",
+    feedback,
+    reasons,
+    warnings,
+    rawPayload: {
+      pr: options.prState,
+      codeReviews: reviewsPayload,
+      selectedReview,
+      reviewDetails,
+      comments: commentsPayload,
+      strictGate: {
+        approved: strictGate.approved,
+        pending: strictGate.pending,
+        reasons: strictGate.reasons,
+        reasonDetails: strictGate.reasonDetails,
+        warnings: strictGate.warnings,
+        greptile: strictGate.evidence.greptile,
+        readErrors: strictGate.evidence.readErrors
+      }
+    }
+  };
+}
+async function runGithubGreptileFallbackReviewForPr(options) {
+  const repoName = deriveRepoName(options.projectRoot, options.prState);
+  const prNumber = parsePullRequestNumber(options.prState.url || "");
+  const expectedHeadSha = resolvePrHeadSha(options.projectRoot, options.prState);
+  if (!repoName || !prNumber) {
+    return {
+      verdict: "SKIP",
+      feedback: "",
+      reasons: [],
+      warnings: buildGithubGreptileFallbackWarnings(options),
+      rawPayload: buildGithubGreptileFallbackRawPayload(options)
+    };
+  }
+  let reviews = [];
+  let selectedReview = null;
+  let latestReview = null;
+  let fallbackReview = null;
+  let threads = [];
+  let actionableThreads = [];
+  let checkRollup = [];
+  let checkState = { pending: false, completed: false };
+  for (let attempt = 0;; attempt += 1) {
+    reviews = runGhJson(options.projectRoot, ["api", `repos/${repoName}/pulls/${prNumber}/reviews`]);
+    selectedReview = pickRelevantGithubGreptileReview(reviews, expectedHeadSha);
+    latestReview = pickLatestGithubGreptileReview(reviews);
+    fallbackReview = selectedReview ?? latestReview;
+    threads = loadGithubReviewThreads(options.projectRoot, repoName, prNumber);
+    actionableThreads = filterActionableGithubGreptileThreads(threads);
+    checkRollup = loadGithubPullRequestCheckRollup(options.projectRoot, repoName, prNumber);
+    checkState = classifyGithubGreptileCheckState(checkRollup);
+    const approvedViaReviewedAncestor = !selectedReview && !!fallbackReview?.commit_id && !!expectedHeadSha && isCommitAncestorOfPrHead(options.projectRoot, options.prState, fallbackReview.commit_id, expectedHeadSha);
+    if (!shouldContinueGithubGreptileFallbackPolling({
+      attempt,
+      pollAttempts: options.pollAttempts,
+      checkState,
+      fallbackReview,
+      selectedReview,
+      approvedViaReviewedAncestor
+    })) {
+      break;
+    }
+    await Bun.sleep(options.pollIntervalMs);
+  }
+  const ciGate = evaluatePullRequestCiChecks(checkRollup, repoName, prNumber, { mergeStateStatus: options.prState.mergeStateStatus });
+  if (ciGate.verdict !== "APPROVE") {
+    return {
+      verdict: ciGate.verdict,
+      feedback: "",
+      reasons: ciGate.reasons,
+      warnings: buildGithubGreptileFallbackWarnings(options),
+      rawPayload: { ...buildGithubGreptileFallbackRawPayload(options), reviews, threads, checkRollup }
+    };
+  }
+  const feedback = [
+    `## ${options.prState.repoLabel || repoName} PR Review`,
+    "",
+    `- PR: ${options.prState.url || `${repoName}#${prNumber}`}`,
+    "- Source: GitHub Greptile fallback",
+    fallbackReview?.html_url ? `- Review: ${fallbackReview.html_url}` : "",
+    fallbackReview?.state ? `- Status: ${fallbackReview.state}` : "",
+    "",
+    fallbackReview?.body?.trim() ? stripHtml(fallbackReview.body).trim() : "Greptile MCP was unavailable, so verification used GitHub review threads instead."
+  ].filter(Boolean).join(`
+`);
+  const warnings = buildGithubGreptileFallbackWarnings(options);
+  if (checkState.pending) {
+    return {
+      verdict: "SKIP",
+      feedback,
+      reasons: [
+        `[AI Review] Greptile GitHub review for ${repoName}#${prNumber} is still in progress.`
+      ],
+      warnings,
+      rawPayload: { ...buildGithubGreptileFallbackRawPayload(options), reviews, threads, checkRollup }
+    };
+  }
+  const prUrl = options.prState.url || `https://github.com/${repoName}/pull/${prNumber}`;
+  let strictGate;
+  try {
+    const strictEvidence = await collectStrictPrEvidenceForVerifier({
+      projectRoot: options.projectRoot,
+      taskId: options.taskId,
+      prUrl
+    });
+    strictGate = evaluateStrictPrMergeGate(strictEvidence);
+  } catch (error) {
+    return {
+      verdict: "REJECT",
+      feedback,
+      reasons: [`[AI Review] Strict Greptile evidence collection failed for ${repoName}#${prNumber}: ${error instanceof Error ? error.message : String(error)}`],
+      warnings,
+      rawPayload: {
+        pr: options.prState,
+        selectedReview: fallbackReview,
+        reviews,
+        threads,
+        checkRollup,
+        actionableThreads,
+        ...buildGithubGreptileFallbackRawPayload(options)
+      }
+    };
+  }
+  if (!strictGate.approved) {
+    return {
+      verdict: strictGate.pending ? "SKIP" : "REJECT",
+      feedback,
+      reasons: strictGate.reasons.map((reason) => reason.startsWith("[AI Review]") ? reason : `[AI Review] ${reason}`),
+      warnings: [...warnings, ...strictGate.warnings],
+      rawPayload: {
+        pr: options.prState,
+        selectedReview: fallbackReview,
+        reviews,
+        threads,
+        checkRollup,
+        actionableThreads,
+        strictGate: {
+          approved: strictGate.approved,
+          pending: strictGate.pending,
+          reasons: strictGate.reasons,
+          reasonDetails: strictGate.reasonDetails,
+          warnings: strictGate.warnings,
+          greptile: strictGate.evidence.greptile
+        },
+        ...buildGithubGreptileFallbackRawPayload(options)
+      }
+    };
+  }
+  return {
+    verdict: "APPROVE",
+    feedback,
+    reasons: [],
+    warnings,
+    rawPayload: {
+      pr: options.prState,
+      selectedReview: fallbackReview,
+      reviews,
+      threads,
+      checkRollup,
+      strictGate: {
+        approved: strictGate.approved,
+        pending: strictGate.pending,
+        reasons: strictGate.reasons,
+        reasonDetails: strictGate.reasonDetails,
+        warnings: strictGate.warnings,
+        greptile: strictGate.evidence.greptile
+      },
+      ...buildGithubGreptileFallbackRawPayload(options)
+    }
+  };
+}
+function buildGithubGreptileFallbackWarnings(options) {
+  if (!options.infrastructureError?.trim()) {
+    return [];
+  }
+  return [
+    asGreptileInfrastructureWarning(`Greptile infrastructure failure for ${options.prState.url || options.prState.branch || options.taskId}: ${options.infrastructureError}`)
+  ];
+}
+function buildGithubGreptileFallbackRawPayload(options) {
+  return options.infrastructureError?.trim() ? { pr: options.prState, error: options.infrastructureError } : { pr: options.prState };
+}
+async function callGreptileMcpTool(apiBase, apiKey, name, args) {
+  return callGreptileMcpToolWithTimeout(apiBase, apiKey, name, args, resolveGreptileRequestTimeoutMs(process.env.GREPTILE_REQUEST_TIMEOUT_MS));
+}
+async function callGreptileMcpToolWithTimeout(apiBase, apiKey, name, args, timeoutMs) {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => {
+    controller.abort(new Error(`Greptile MCP tool ${name} timed out after ${timeoutMs}ms.`));
+  }, timeoutMs);
+  let response;
+  try {
+    response = await fetch(apiBase, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: `rig-${name}-${Date.now()}`,
+        method: "tools/call",
+        params: { name, arguments: args }
+      }),
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (controller.signal.aborted) {
+      throw controller.signal.reason instanceof Error ? controller.signal.reason : new Error(`Greptile MCP tool ${name} timed out after ${timeoutMs}ms.`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  const raw = await response.text();
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${raw}`);
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(raw);
+  } catch {
+    throw new Error(`Malformed MCP response: ${raw}`);
+  }
+  if (envelope.error?.message) {
+    throw new Error(envelope.error.message);
+  }
+  const text = (envelope.result?.content || []).filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text || "").join(`
+`).trim();
+  if (!text) {
+    throw new Error(`MCP tool ${name} returned no text payload.`);
+  }
+  return text;
+}
+function resolveGreptileRequestTimeoutMs(rawValue) {
+  const DEFAULT_GREPTILE_REQUEST_TIMEOUT_MS = 30000;
+  const parsed = Number.parseInt(rawValue || `${DEFAULT_GREPTILE_REQUEST_TIMEOUT_MS}`, 10);
+  return Number.isFinite(parsed) && parsed >= 1000 ? parsed : DEFAULT_GREPTILE_REQUEST_TIMEOUT_MS;
+}
+async function callGreptileMcpToolJson(apiBase, apiKey, name, args) {
+  const text = await callGreptileMcpTool(apiBase, apiKey, name, args);
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`MCP tool ${name} returned malformed JSON: ${text}`);
+  }
+}
+function pickRelevantCodeReview(reviews, triggerStartedAt, expectedHeadSha) {
+  const normalized = [...reviews].sort((a, b) => Date.parse(b.createdAt || "") - Date.parse(a.createdAt || ""));
+  const exactSha = normalized.find((review) => expectedHeadSha && review.metadata?.checkHeadSha === expectedHeadSha);
+  if (exactSha) {
+    return exactSha;
+  }
+  const triggered = normalized.find((review) => Date.parse(review.createdAt || "") >= triggerStartedAt - 1000);
+  return triggered || normalized[0] || null;
+}
+function filterActionableGreptileComments(comments) {
+  return comments.filter((comment) => comment.sourceType === "greptile" && typeof comment.filePath === "string" && comment.filePath.trim().length > 0 && comment.addressed === false);
+}
+function findGreptileReviewForHeadSha(reviews, expectedHeadSha) {
+  if (!expectedHeadSha) {
+    return null;
+  }
+  const normalized = [...reviews].sort((a, b) => Date.parse(b.createdAt || "") - Date.parse(a.createdAt || ""));
+  return normalized.find((review) => review.metadata?.checkHeadSha === expectedHeadSha) || null;
+}
+function isGreptileReviewTerminal(status) {
+  return status === "COMPLETED" || status === "FAILED" || status === "SKIPPED";
+}
+function shouldTriggerGreptileReview(existingReview, expectedHeadSha) {
+  if (!existingReview) {
+    return true;
+  }
+  if (!expectedHeadSha) {
+    return true;
+  }
+  if ((existingReview.metadata?.checkHeadSha || "") !== expectedHeadSha) {
+    return true;
+  }
+  return false;
+}
+function shouldContinueGreptileMcpPolling(options) {
+  if (options.githubCheckState.completed) {
+    return false;
+  }
+  if (options.attempt + 1 >= options.pollAttempts) {
+    return false;
+  }
+  if (options.selectedReview && !isGreptileReviewTerminal(options.selectedReview.status)) {
+    return true;
+  }
+  return true;
+}
+function shouldContinueGithubGreptileFallbackPolling(options) {
+  const waitingForVisiblePendingReview = options.checkState.pending && (!options.fallbackReview || !options.selectedReview && !options.approvedViaReviewedAncestor);
+  if (options.attempt + 1 >= options.pollAttempts) {
+    return false;
+  }
+  if (waitingForVisiblePendingReview) {
+    return true;
+  }
+  const reviewNotVisibleYet = !options.fallbackReview && !options.checkState.pending && !options.checkState.completed;
+  if (reviewNotVisibleYet) {
+    return options.attempt + 1 < options.pollAttempts;
+  }
+  return false;
+}
+function resolveGreptilePollSettings(options) {
+  const DEFAULT_POLL_ATTEMPTS = 60;
+  const DEFAULT_POLL_INTERVAL_MS = 5000;
+  const REQUIRED_MODE_MIN_ATTEMPTS = 180;
+  const configuredAttempts = Number.parseInt(options.secrets.GREPTILE_POLL_ATTEMPTS || `${DEFAULT_POLL_ATTEMPTS}`, 10);
+  const configuredIntervalMs = Number.parseInt(options.secrets.GREPTILE_POLL_INTERVAL_MS || `${DEFAULT_POLL_INTERVAL_MS}`, 10);
+  const pollAttempts = Number.isFinite(configuredAttempts) && configuredAttempts > 0 ? configuredAttempts : DEFAULT_POLL_ATTEMPTS;
+  const pollIntervalMs = Number.isFinite(configuredIntervalMs) && configuredIntervalMs > 0 ? configuredIntervalMs : DEFAULT_POLL_INTERVAL_MS;
+  if (options.reviewMode !== "required") {
+    return { pollAttempts, pollIntervalMs };
+  }
+  return {
+    pollAttempts: Math.max(REQUIRED_MODE_MIN_ATTEMPTS, pollAttempts),
+    pollIntervalMs: Math.max(DEFAULT_POLL_INTERVAL_MS, pollIntervalMs)
+  };
+}
+function loadGithubPullRequestState(projectRoot, repoName, prNumber) {
+  const response = runGhJson(projectRoot, [
+    "api",
+    `repos/${repoName}/pulls/${prNumber}`
+  ]);
+  return {
+    state: response.state || "",
+    merged: response.merged,
+    merged_at: response.merged_at ?? null
+  };
+}
+function shouldPreferGithubGreptileFallback(prState) {
+  if ((prState?.state || "").toUpperCase() === "MERGED") {
+    return true;
+  }
+  if (prState?.merged === true) {
+    return true;
+  }
+  return typeof prState?.merged_at === "string" && prState.merged_at.trim().length > 0;
+}
+function parsePullRequestNumber(url) {
+  const match = /\/pull\/(\d+)(?:\/|$)/.exec(url);
+  return match ? Number.parseInt(match[1] || "0", 10) : 0;
+}
+function runGhJson(projectRoot, args) {
+  const result = runCapture(["gh", ...args], projectRoot);
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.stdout || `gh ${args.join(" ")} failed`);
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    throw new Error(`gh ${args.join(" ")} returned malformed JSON: ${result.stdout}`);
+  }
+}
+async function collectStrictPrEvidenceForVerifier(input) {
+  return collectPrReviewEvidence({
+    projectRoot: input.projectRoot,
+    prUrl: input.prUrl,
+    taskId: input.taskId,
+    runId: "verifier",
+    cycle: 0,
+    apiSignals: input.apiSignals ?? [],
+    command: async (args, options) => {
+      const result = runCapture(["gh", ...args], options?.cwd ?? input.projectRoot);
+      return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
+    }
+  });
+}
+function deriveRepoName(projectRoot, prState) {
+  const fromUrl = /github\.com\/([^/]+\/[^/]+)\/pull\/\d+/.exec(prState.url || "");
+  if (fromUrl?.[1]) {
+    return fromUrl[1];
+  }
+  if (prState.target === "monorepo") {
+    return resolveRepoSlug(projectRoot);
+  }
+  return runCapture(["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"], projectRoot).stdout.trim();
+}
+function resolvePrHeadSha(projectRoot, prState) {
+  const repoRoot = resolvePrRepoRoot(projectRoot, prState);
+  return runCapture(["git", "-C", repoRoot, "rev-parse", "HEAD"], projectRoot).stdout.trim();
+}
+function isGreptileGithubLogin(login) {
+  const normalized = (login || "").toLowerCase().replace(/\[bot\]$/, "");
+  return normalized === "greptile" || normalized === "greptile-ai" || normalized === "greptileai" || normalized === "greptile-apps";
+}
+function pickRelevantGithubGreptileReview(reviews, expectedHeadSha) {
+  const matching = sortGithubGreptileReviews(reviews);
+  if (expectedHeadSha) {
+    const exact = matching.find((review) => review.commit_id === expectedHeadSha);
+    if (exact) {
+      return exact;
+    }
+    return null;
+  }
+  return matching[0] || null;
+}
+function pickLatestGithubGreptileReview(reviews) {
+  return sortGithubGreptileReviews(reviews)[0] || null;
+}
+function sortGithubGreptileReviews(reviews) {
+  return reviews.filter((review) => isGreptileGithubLogin(review.user?.login)).sort((left, right) => Date.parse(right.submitted_at || "") - Date.parse(left.submitted_at || ""));
+}
+function loadGithubPullRequestCheckRollup(projectRoot, repoName, prNumber) {
+  const response = runGhJson(projectRoot, [
+    "pr",
+    "view",
+    `${prNumber}`,
+    "--repo",
+    repoName,
+    "--json",
+    "statusCheckRollup"
+  ]);
+  return response.statusCheckRollup || [];
+}
+function evaluatePullRequestCiChecks(checks, repoName, prNumber, options = {}) {
+  const isPendingCheck = (check) => {
+    if ((check.__typename || "") === "CheckRun") {
+      return (check.status || "").toUpperCase() !== "COMPLETED";
+    }
+    const state = (check.state || check.status || "").toUpperCase();
+    return state === "PENDING" || state === "EXPECTED" || state === "QUEUED" || state === "IN_PROGRESS";
+  };
+  const pendingGreptile = checks.filter((check) => {
+    const label = (check.name || check.context || "").toLowerCase();
+    return label.includes("greptile") && isPendingCheck(check);
+  });
+  if (pendingGreptile.length > 0) {
+    return {
+      verdict: "SKIP",
+      reasons: pendingGreptile.map((check) => `[CI] ${repoName}#${prNumber} mandatory Greptile check is still pending: ${check.name || check.context || "unknown"}.`)
+    };
+  }
+  const nonGreptileChecks = checks.filter((check) => {
+    const label = (check.name || check.context || "").toLowerCase();
+    return label.length > 0 && !label.includes("greptile");
+  });
+  const pending = nonGreptileChecks.filter(isPendingCheck);
+  const mergeClean = (options.mergeStateStatus || "").toUpperCase() === "CLEAN";
+  if (pending.length > 0 && !mergeClean) {
+    return {
+      verdict: "SKIP",
+      reasons: pending.map((check) => `[CI] ${repoName}#${prNumber} check is still pending: ${check.name || check.context || "unknown"}.`)
+    };
+  }
+  const failing = nonGreptileChecks.filter((check) => {
+    if ((check.__typename || "") === "CheckRun") {
+      const conclusion = (check.conclusion || "").toUpperCase();
+      return conclusion.length > 0 && !["SUCCESS", "NEUTRAL", "SKIPPED"].includes(conclusion);
+    }
+    const state = (check.state || check.conclusion || "").toUpperCase();
+    return state.length > 0 && !["SUCCESS", "NEUTRAL", "SKIPPED"].includes(state);
+  });
+  if (failing.length > 0) {
+    return {
+      verdict: "REJECT",
+      reasons: failing.map((check) => `[CI] ${repoName}#${prNumber} check failed: ${check.name || check.context || "unknown"} (${check.conclusion || check.state || check.status || "unknown"}).`)
+    };
+  }
+  return { verdict: "APPROVE", reasons: [] };
+}
+function classifyGithubGreptileCheckState(checks) {
+  const greptileChecks = checks.filter((check) => {
+    const label = (check.name || check.context || "").toLowerCase();
+    return label.includes("greptile");
+  });
+  if (greptileChecks.length === 0) {
+    return { pending: false, completed: false };
+  }
+  for (const check of greptileChecks) {
+    if ((check.__typename || "") === "CheckRun") {
+      if ((check.status || "").toUpperCase() !== "COMPLETED") {
+        return { pending: true, completed: false };
+      }
+      return { pending: false, completed: true };
+    }
+    const state = (check.state || "").toUpperCase();
+    if (state === "PENDING" || state === "EXPECTED") {
+      return { pending: true, completed: false };
+    }
+    if (state) {
+      return { pending: false, completed: true };
+    }
+  }
+  return { pending: false, completed: false };
+}
+function isGithubGreptileCheckApproved(_checks) {
+  return false;
+}
+function loadGithubReviewThreads(projectRoot, repoName, prNumber) {
+  const [owner, name] = repoName.split("/");
+  if (!owner || !name) {
+    return [];
+  }
+  const response = runGhJson(projectRoot, [
+    "api",
+    "graphql",
+    "-F",
+    `owner=${owner}`,
+    "-F",
+    `name=${name}`,
+    "-F",
+    `prNumber=${prNumber}`,
+    "-f",
+    "query=query($owner: String!, $name: String!, $prNumber: Int!) { repository(owner:$owner, name:$name) { pullRequest(number:$prNumber) { reviewThreads(first: 100) { nodes { isResolved isOutdated comments(first: 20) { nodes { author { login } body path url createdAt } } } } } } }"
+  ]);
+  return response.data?.repository?.pullRequest?.reviewThreads?.nodes || [];
+}
+function filterActionableGithubGreptileThreads(threads) {
+  return threads.flatMap((thread) => {
+    if (thread.isResolved || thread.isOutdated) {
+      return [];
+    }
+    const comments = thread.comments?.nodes || [];
+    const latestGreptileComment = [...comments].reverse().find((comment) => isGreptileGithubLogin(comment.author?.login));
+    if (!latestGreptileComment?.path?.trim()) {
+      return [];
+    }
+    return [latestGreptileComment];
+  });
+}
+function resolvePrRepoRoot(projectRoot, prState) {
+  const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (prState.target === "monorepo" && runtimeWorkspace && existsSync(resolve(runtimeWorkspace, ".git"))) {
+    return runtimeWorkspace;
+  }
+  const paths = resolveHarnessPaths(projectRoot);
+  return prState.target === "monorepo" ? paths.monorepoRoot : projectRoot;
+}
+function isCommitAncestorOfPrHead(projectRoot, prState, reviewedCommit, headCommit) {
+  if (!reviewedCommit || !headCommit) {
+    return false;
+  }
+  const repoRoot = resolvePrRepoRoot(projectRoot, prState);
+  return runCapture(["git", "-C", repoRoot, "merge-base", "--is-ancestor", reviewedCommit, headCommit], projectRoot).exitCode === 0;
+}
+function summarizeComment(input) {
+  const text = stripHtml(input).replace(/\s+/g, " ").trim();
+  return text.length > 160 ? `${text.slice(0, 157)}...` : text;
+}
+function asGreptileInfrastructureWarning(reason) {
+  return reason.startsWith("[AI Review]") ? reason.replace("[AI Review]", "[AI Review Warning]") : reason;
+}
+function isAiReviewApproved(input) {
+  if (input.aiVerdict === "REJECT" && input.aiReasons.length > 0) {
+    return false;
+  }
+  if (input.reviewMode !== "required") {
+    return true;
+  }
+  return input.aiVerdict === "APPROVE" && input.aiReasons.length === 0;
+}
+var __testOnly = {
+  asGreptileInfrastructureWarning,
+  callGreptileMcpToolWithTimeout,
+  classifyGithubGreptileCheckState,
+  filterActionableGithubGreptileThreads,
+  isGithubGreptileCheckApproved,
+  isAiReviewApproved,
+  parseGreptileScore,
+  pickLatestGithubGreptileReview,
+  pickRelevantGithubGreptileReview,
+  resolveGreptileRequestTimeoutMs,
+  resolveGreptilePollSettings,
+  shouldPreferGithubGreptileFallback,
+  shouldContinueGithubGreptileFallbackPolling,
+  shouldContinueGreptileMcpPolling,
+  shouldTriggerGreptileReview
+};
+export {
+  verifyTask,
+  pickRelevantCodeReview,
+  filterActionableGreptileComments,
+  evaluatePullRequestCiChecks,
+  __testOnly
+};