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

package/dist/src/control-plane/pr-automation.js

@@ -0,0 +1,638 @@
+// @bun
+// packages/bundle-default-lifecycle/src/control-plane/pr-automation.ts
+import { assertSafeGitBranchName } from "@rig/shared/safe-identifiers";
+import { runStrictPrMergeGate } from "@rig/pr-review-plugin";
+import {
+  strictMergeHeadShaFromGate
+} from "@rig/contracts";
+var UPLOADED_SNAPSHOT_PR_MARKER = "<!-- rig:uploaded-snapshot -->";
+function positiveInt(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function resolvePrAutomationLimits(config) {
+  return {
+    maxPrFixIterations: positiveInt(config?.automation?.maxPrFixIterations, 100500)
+  };
+}
+function buildPrAutomationBody(input) {
+  const lines = [
+    input.summary?.trim() || "Rig completed this task autonomously.",
+    "",
+    `Run: ${input.runId}`
+  ];
+  if (/^\d+$/.test(input.taskId)) {
+    lines.push("", `Closes #${input.taskId}`);
+  }
+  if (input.uploadedSnapshot) {
+    lines.push("", UPLOADED_SNAPSHOT_PR_MARKER, "This PR was seeded from an uploaded local working-tree snapshot. Review local snapshot provenance before merging if repository policy requires it.");
+  }
+  return lines.join(`
+`);
+}
+function wildcardToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function isAllowedFailure(name, allowedFailures) {
+  return allowedFailures.some((pattern) => wildcardToRegExp(pattern).test(name));
+}
+function isPendingCheck(check) {
+  const conclusion = String(check.conclusion ?? "").toLowerCase();
+  const state = String(check.state ?? check.status ?? "").toLowerCase();
+  return ["pending", "queued", "in_progress", "waiting", "requested", "expected", "action_required"].includes(conclusion) || ["pending", "queued", "in_progress", "waiting", "requested", "expected"].includes(state);
+}
+function isPassingCheck(check) {
+  const conclusion = String(check.conclusion ?? "").toLowerCase();
+  const state = String(check.state ?? check.status ?? "").toLowerCase();
+  return ["success", "successful", "passed", "neutral", "skipped"].includes(conclusion) || ["success", "successful", "passed", "completed"].includes(state);
+}
+function isFailingCheck(check) {
+  const conclusion = String(check.conclusion ?? "").toLowerCase();
+  const state = String(check.state ?? check.status ?? "").toLowerCase();
+  return ["failure", "failed", "timed_out", "action_required", "cancelled", "error"].includes(conclusion) || ["failure", "failed", "timed_out", "action_required", "cancelled", "error"].includes(state);
+}
+function collectPendingPrChecks(input) {
+  const allowedFailures = input.allowedFailures ?? [];
+  const pending = [];
+  for (const check of input.checks ?? []) {
+    const name = check.name.trim();
+    if (!name || isAllowedFailure(name, allowedFailures))
+      continue;
+    if (isPendingCheck(check) && !isPassingCheck(check))
+      pending.push(name);
+  }
+  return pending;
+}
+function collectActionablePrFeedback(input) {
+  const allowedFailures = input.allowedFailures ?? [];
+  const feedback = [];
+  for (const check of input.checks ?? []) {
+    const name = check.name.trim();
+    if (!name || !isFailingCheck(check) || isAllowedFailure(name, allowedFailures))
+      continue;
+    feedback.push(`Check failed: ${name}${check.detailsUrl ? ` (${check.detailsUrl})` : ""}`);
+  }
+  for (const thread of input.reviewThreads ?? []) {
+    if (thread.resolved === true)
+      continue;
+    const body = thread.body.trim();
+    if (!body)
+      continue;
+    feedback.push(`Review feedback from ${thread.author?.trim() || "reviewer"}: ${body}`);
+  }
+  return feedback;
+}
+function parseJsonArray(value) {
+  if (!value?.trim())
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function parsePrChecks(value) {
+  return parseJsonArray(value).flatMap((entry) => {
+    if (!entry || typeof entry !== "object")
+      return [];
+    const record = entry;
+    const name = typeof record.name === "string" ? record.name : "";
+    if (!name.trim())
+      return [];
+    return [{
+      name,
+      status: typeof record.status === "string" ? record.status : null,
+      state: typeof record.state === "string" ? record.state : null,
+      conclusion: typeof record.conclusion === "string" ? record.conclusion : null,
+      detailsUrl: typeof record.detailsUrl === "string" ? record.detailsUrl : typeof record.link === "string" ? record.link : null
+    }];
+  });
+}
+function parsePrViewStatusCheckRollup(value) {
+  if (!value?.trim())
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    const rollup = Array.isArray(parsed.statusCheckRollup) ? parsed.statusCheckRollup : [];
+    return rollup.flatMap((entry) => {
+      if (!entry || typeof entry !== "object")
+        return [];
+      const record = entry;
+      const name = typeof record.name === "string" ? record.name : "";
+      if (!name.trim())
+        return [];
+      return [{
+        name,
+        status: typeof record.status === "string" ? record.status : null,
+        state: typeof record.state === "string" ? record.state : null,
+        conclusion: typeof record.conclusion === "string" ? record.conclusion : null,
+        detailsUrl: typeof record.detailsUrl === "string" ? record.detailsUrl : typeof record.link === "string" ? record.link : null
+      }];
+    });
+  } catch {
+    return [];
+  }
+}
+async function readPrChecks(input) {
+  const checks = await input.command(["pr", "checks", input.prUrl, "--json", "name,state,link"], input.cwd ? { cwd: input.cwd } : undefined);
+  if (checks.exitCode === 0) {
+    return parsePrChecks(checks.stdout);
+  }
+  const combined = `${checks.stderr ?? ""}
+${checks.stdout ?? ""}`;
+  if (!/unknown flag.*--json|unknown flag: --json|unknown shorthand flag/i.test(combined)) {
+    throw new Error(`gh pr checks ${input.prUrl} --json name,state,link failed (${checks.exitCode}): ${checks.stderr ?? checks.stdout ?? ""}`.trim());
+  }
+  const view = await runChecked(input.command, ["pr", "view", input.prUrl, "--json", "statusCheckRollup"], input.cwd, "gh");
+  return parsePrViewStatusCheckRollup(view.stdout);
+}
+function parsePrViewReviewThreads(value) {
+  if (!value?.trim())
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    const feedback = [];
+    const reviewThreads = parsed.reviewThreads;
+    if (Array.isArray(reviewThreads)) {
+      feedback.push(...reviewThreads.flatMap((entry) => {
+        if (!entry || typeof entry !== "object")
+          return [];
+        const record = entry;
+        const body = typeof record.body === "string" ? record.body : null;
+        if (!body)
+          return [];
+        return [{
+          id: typeof record.id === "string" ? record.id : null,
+          body,
+          resolved: typeof record.resolved === "boolean" ? record.resolved : false,
+          author: typeof record.author === "string" ? record.author : null
+        }];
+      }));
+    }
+    const reviews = parsed.reviews;
+    if (Array.isArray(reviews)) {
+      feedback.push(...reviews.flatMap((entry) => {
+        if (!entry || typeof entry !== "object")
+          return [];
+        const record = entry;
+        const state = typeof record.state === "string" ? record.state.toUpperCase() : "";
+        if (state !== "CHANGES_REQUESTED")
+          return [];
+        const body = typeof record.body === "string" && record.body.trim() ? record.body : "Changes requested by reviewer.";
+        const author = record.author && typeof record.author === "object" ? record.author.login : null;
+        return [{
+          id: typeof record.id === "string" ? record.id : null,
+          body,
+          resolved: false,
+          author: typeof author === "string" ? author : null
+        }];
+      }));
+    }
+    const reviewDecision = typeof parsed.reviewDecision === "string" ? parsed.reviewDecision.toUpperCase() : "";
+    if (reviewDecision === "CHANGES_REQUESTED" && feedback.length === 0) {
+      feedback.push({ body: "Changes requested by reviewer.", resolved: false });
+    }
+    return feedback;
+  } catch {
+    return [];
+  }
+}
+function findPrUrl(output) {
+  return output?.split(/\s+/).map((part) => part.trim()).find((part) => /^https?:\/\/\S+\/pull\/\d+$/i.test(part)) ?? null;
+}
+function normalizePrUrl(stdout) {
+  const url = findPrUrl(stdout);
+  if (!url)
+    throw new Error("gh pr create did not return a PR URL");
+  return url;
+}
+function parseGitHubPullRequestUrl(prUrl) {
+  try {
+    const parsed = new URL(prUrl);
+    const [owner, repo, kind, number] = parsed.pathname.split("/").filter(Boolean);
+    if (!owner || !repo || kind !== "pull" || !number || !/^\d+$/.test(number))
+      return null;
+    return { owner, repo, number };
+  } catch {
+    return null;
+  }
+}
+async function ensureExistingPrBodyHasRigMarkers(input) {
+  const view = await input.command(["pr", "view", input.prUrl, "--json", "body"], input.cwd ? { cwd: input.cwd } : undefined);
+  if (view.exitCode !== 0) {
+    throw new Error(`gh pr view ${input.prUrl} --json body failed (${view.exitCode}): ${view.stderr ?? view.stdout ?? ""}`.trim());
+  }
+  let currentBody = "";
+  try {
+    const parsed = JSON.parse(view.stdout ?? "{}");
+    currentBody = typeof parsed.body === "string" ? parsed.body : "";
+  } catch {
+    currentBody = "";
+  }
+  const requiredBlocks = input.body.split(/\n{2,}/).map((block) => block.trim()).filter((block) => /^Run: /i.test(block) || /^Closes #\d+/i.test(block));
+  const missing = requiredBlocks.filter((block) => {
+    if (/^Run: /i.test(block))
+      return !/^Run: \S+/im.test(currentBody);
+    return !currentBody.includes(block);
+  });
+  if (missing.length === 0)
+    return;
+  const nextBody = [currentBody.trim(), ...missing].filter(Boolean).join(`
+
+`);
+  const pr = parseGitHubPullRequestUrl(input.prUrl);
+  if (!pr)
+    throw new Error(`Cannot update existing PR body for unrecognized PR URL: ${input.prUrl}`);
+  const edit = await input.command(["api", `repos/${pr.owner}/${pr.repo}/issues/${pr.number}`, "-X", "PATCH", "-f", `body=${nextBody}`], input.cwd ? { cwd: input.cwd } : undefined);
+  if (edit.exitCode !== 0) {
+    throw new Error(`gh api repos/${pr.owner}/${pr.repo}/issues/${pr.number} -X PATCH -f body=<redacted> failed (${edit.exitCode}): ${edit.stderr ?? edit.stdout ?? ""}`.trim());
+  }
+}
+async function runChecked(command, args, cwd, label = "gh") {
+  const result = await command(args, cwd ? { cwd } : undefined);
+  if (result.exitCode !== 0) {
+    throw new Error(`${label} ${args.join(" ")} failed (${result.exitCode}): ${result.stderr ?? result.stdout ?? ""}`.trim());
+  }
+  return result;
+}
+var RIG_RUNTIME_COMMIT_EXCLUDES = [
+  ".rig",
+  "artifacts",
+  "node_modules"
+];
+function statusPathFromShortLine(line) {
+  const rawPath = line.length > 3 ? line.slice(3).trim() : "";
+  const renamedPath = rawPath.includes(" -> ") ? rawPath.split(" -> ").at(-1).trim() : rawPath;
+  if (renamedPath.startsWith('"') && renamedPath.endsWith('"')) {
+    try {
+      return JSON.parse(renamedPath);
+    } catch {
+      return renamedPath.slice(1, -1);
+    }
+  }
+  return renamedPath;
+}
+function isRuntimeCommitExcludedPath(path) {
+  const normalized = path.replace(/^\.\/+/, "").replace(/\/+$/, "");
+  return RIG_RUNTIME_COMMIT_EXCLUDES.some((excluded) => normalized === excluded || normalized.startsWith(`${excluded}/`));
+}
+function committableRunChangePaths(statusText) {
+  const seen = new Set;
+  const paths = [];
+  for (const line of statusText.split(/\r?\n/)) {
+    const path = statusPathFromShortLine(line);
+    if (!path || isRuntimeCommitExcludedPath(path) || seen.has(path))
+      continue;
+    seen.add(path);
+    paths.push(path);
+  }
+  return paths;
+}
+function hasCommittableRunChanges(statusText) {
+  return committableRunChangePaths(statusText).length > 0;
+}
+async function commitRunChanges(input) {
+  const status = await runChecked(input.command, ["status", "--short", "--untracked-files=all"], input.cwd, "git");
+  const statusText = status.stdout ?? "";
+  const committablePaths = committableRunChangePaths(statusText);
+  if (!statusText.trim() || committablePaths.length === 0) {
+    return { committed: false, status: statusText };
+  }
+  await runChecked(input.command, ["add", "-A", "--", ...committablePaths], input.cwd, "git");
+  const staged = await input.command(["diff", "--cached", "--quiet"], { cwd: input.cwd });
+  if (staged.exitCode === 0) {
+    return { committed: false, status: statusText };
+  }
+  if (staged.exitCode !== 1) {
+    throw new Error(`git diff --cached --quiet failed (${staged.exitCode}): ${staged.stderr ?? staged.stdout ?? ""}`.trim());
+  }
+  await runChecked(input.command, ["commit", "-m", input.message], input.cwd, "git");
+  return { committed: true, status: statusText };
+}
+async function closeIssueAfterMergedPr(input) {
+  await input.updateTaskSource(input.projectRoot, {
+    taskId: input.taskId,
+    sourceTask: input.sourceTask,
+    update: {
+      status: "closed",
+      comment: [
+        "<!-- rig:status-comment -->",
+        "### Rig status: closed",
+        "",
+        "Rig PR merged and closed this task.",
+        "",
+        `- Run: ${input.runId}`,
+        `- PR merged: ${input.prUrl}`
+      ].join(`
+`)
+    }
+  });
+}
+function parseGitHubRepoFromPrUrl(prUrl) {
+  const match = /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/\d+\/?$/i.exec(prUrl.trim());
+  return match ? { owner: match[1], repo: match[2] } : null;
+}
+async function resolveRepoDefaultMergeFlag(input) {
+  const repo = parseGitHubRepoFromPrUrl(input.prUrl);
+  if (!repo)
+    throw new Error(`Cannot resolve GitHub repository from PR URL: ${input.prUrl}`);
+  const result = await input.command(["api", `repos/${repo.owner}/${repo.repo}`], input.cwd ? { cwd: input.cwd } : undefined);
+  if (result.exitCode !== 0) {
+    throw new Error(`Could not read repository merge policy for ${repo.owner}/${repo.repo}: ${result.stderr ?? result.stdout ?? "gh api failed"}`.trim());
+  }
+  try {
+    const parsed = JSON.parse(result.stdout ?? "{}");
+    if (parsed.allow_merge_commit !== false)
+      return "--merge";
+    if (parsed.allow_squash_merge !== false)
+      return "--squash";
+    if (parsed.allow_rebase_merge !== false)
+      return "--rebase";
+  } catch (error) {
+    throw new Error(`Could not parse repository merge policy for ${repo.owner}/${repo.repo}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  throw new Error(`Repository ${repo.owner}/${repo.repo} has no enabled merge method for repo-default merge.`);
+}
+async function runRepoDefaultMerge(input) {
+  const merge = input.config?.merge ?? {};
+  if (merge.mode === "off")
+    return;
+  const requireGreptile = (input.config?.review?.provider ?? "greptile") === "greptile";
+  const matchHeadSha = strictMergeHeadShaFromGate(input.strictGate, input.prUrl, requireGreptile);
+  const method = merge.method ?? "repo-default";
+  const args = ["pr", "merge", input.prUrl];
+  if (method === "repo-default") {
+    args.push(await resolveRepoDefaultMergeFlag({ prUrl: input.prUrl, command: input.command, cwd: input.cwd }));
+  } else {
+    args.push(`--${method}`);
+  }
+  args.push("--match-head-commit", matchHeadSha);
+  if (merge.deleteBranch === true) {
+    args.push("--delete-branch");
+  }
+  if (merge.bypass === true) {
+    args.push("--admin");
+  }
+  await runChecked(input.command, args, input.cwd);
+}
+function shouldAttemptRigMerge(config) {
+  const mode = config?.merge?.mode;
+  return mode !== "off" && mode !== "pr-ready";
+}
+function isPendingOnlyGate(result) {
+  return result.pending && result.reasonDetails.length > 0 && result.reasonDetails.every((reason) => reason.reasonClass === "pending" && reason.suggestedAction === "wait");
+}
+function gateNeedsGreptileRereview(result) {
+  if (result.approved)
+    return false;
+  const staleShaEvidence = result.reasonDetails.some((reason) => reason.surface === "greptile" && (reason.code === "greptile_stale" || reason.code === "greptile_not_current_head" && !!reason.reviewedSha && reason.reviewedSha !== reason.headSha));
+  const hasParseableGreptileScore = !!result.evidence.greptile.score;
+  const greptileNeedsPrompt = !hasParseableGreptileScore && result.reasonDetails.some((reason) => reason.surface === "greptile" && reason.suggestedAction === "ask_greptile" && (reason.code === "greptile_not_current_head" || reason.code === "greptile_score_missing" || reason.code === "greptile_mapping_unproven"));
+  const greptileStillRunning = result.reasonDetails.some((reason) => reason.code === "greptile_pending" || reason.code === "greptile_missing");
+  return (staleShaEvidence || greptileNeedsPrompt) && !greptileStillRunning;
+}
+var GREPTILE_REREVIEW_MARKER_PREFIX = "rig:greptile-rereview";
+async function requestGreptileRereview(input) {
+  const sha = input.headSha?.trim() || "unknown";
+  const marker = `<!-- ${GREPTILE_REREVIEW_MARKER_PREFIX}:${sha} -->`;
+  const existing = await input.command(["pr", "view", input.prUrl, "--json", "comments"], input.cwd ? { cwd: input.cwd } : undefined);
+  if (existing.exitCode === 0 && (existing.stdout ?? "").includes(marker)) {
+    return false;
+  }
+  await runChecked(input.command, [
+    "pr",
+    "comment",
+    input.prUrl,
+    "--body",
+    `${marker}
+@greptileai review
+
+Rig strict merge gate: Greptile evidence is bound to an older commit. Requesting a fresh review of the current head (${sha}). Merge waits until Greptile re-reviews this exact commit.`
+  ], input.cwd);
+  return true;
+}
+async function pushBranchSyncedWithOrigin(input) {
+  const branch = assertSafeGitBranchName(input.branch, "PR branch");
+  const fetched = await input.gitCommand(["fetch", "origin", branch], { cwd: input.projectRoot });
+  if (fetched.exitCode === 0) {
+    const originRef = `origin/${branch}`;
+    const behind = await input.gitCommand(["rev-list", "--count", `HEAD..${originRef}`], { cwd: input.projectRoot });
+    const behindCount = Number.parseInt((behind.stdout ?? "").trim(), 10);
+    if (behind.exitCode === 0 && Number.isFinite(behindCount) && behindCount > 0) {
+      await runChecked(input.gitCommand, ["rebase", "--autostash", originRef], input.projectRoot, "git");
+    }
+  }
+  const pushed = await input.gitCommand(["push", "--set-upstream", "origin", branch], { cwd: input.projectRoot });
+  if (pushed.exitCode !== 0) {
+    await runChecked(input.gitCommand, ["push", "--set-upstream", "--force-with-lease", "origin", branch], input.projectRoot, "git");
+  }
+}
+async function syncBranchAfterPrFeedback(input) {
+  if (!input.gitCommand)
+    return;
+  const branch = assertSafeGitBranchName(input.branch, "PR branch");
+  await commitRunChanges({
+    cwd: input.projectRoot,
+    message: `rig: address PR feedback for task ${input.taskId}`,
+    command: input.gitCommand
+  });
+  await pushBranchSyncedWithOrigin({ projectRoot: input.projectRoot, branch, gitCommand: input.gitCommand });
+}
+async function runPrAutomation(input) {
+  const branch = assertSafeGitBranchName(input.branch, "PR branch");
+  const prConfig = input.config?.pr ?? {};
+  const requireGreptile = (input.config?.review?.provider ?? "greptile") === "greptile";
+  if (prConfig.mode === "off" || prConfig.mode === "ask") {
+    return { status: "skipped", iterations: 0, actionableFeedback: [] };
+  }
+  const body = buildPrAutomationBody({
+    taskId: input.taskId,
+    runId: input.runId,
+    summary: input.sourceTask?.title ? `Rig completed: ${input.sourceTask.title}` : null,
+    uploadedSnapshot: input.uploadedSnapshot
+  });
+  if (input.gitCommand) {
+    await pushBranchSyncedWithOrigin({ projectRoot: input.projectRoot, branch, gitCommand: input.gitCommand });
+  }
+  const createArgs = [
+    "pr",
+    "create",
+    "--head",
+    branch,
+    "--title",
+    input.sourceTask?.title?.trim() || `Rig task ${input.taskId}`,
+    "--body",
+    body
+  ];
+  const createResult = await input.command(createArgs, { cwd: input.projectRoot });
+  const existingPrUrl = createResult.exitCode === 0 ? null : /pull request .*already exists/i.test(`${createResult.stderr ?? ""}
+${createResult.stdout ?? ""}`) ? findPrUrl(`${createResult.stderr ?? ""}
+${createResult.stdout ?? ""}`) : null;
+  if (createResult.exitCode !== 0 && !existingPrUrl) {
+    throw new Error(`gh ${createArgs.join(" ")} failed (${createResult.exitCode}): ${createResult.stderr ?? createResult.stdout ?? ""}`.trim());
+  }
+  const prUrl = existingPrUrl ?? normalizePrUrl(createResult.stdout);
+  if (existingPrUrl) {
+    await ensureExistingPrBodyHasRigMarkers({ prUrl, body, command: input.command, cwd: input.projectRoot });
+  }
+  await input.lifecycle?.onPrOpened?.({ prUrl });
+  const { maxPrFixIterations } = resolvePrAutomationLimits(input.config);
+  let latestFeedback = [];
+  let pendingElapsedMs = 0;
+  const shouldMerge = shouldAttemptRigMerge(input.config);
+  for (let iteration = 1;iteration <= maxPrFixIterations; iteration += 1) {
+    await input.lifecycle?.onReviewCiStarted?.({ prUrl, iteration });
+    if (!shouldMerge) {
+      const checks = prConfig.watchChecks === false ? [] : await readPrChecks({ prUrl, command: input.command, cwd: input.projectRoot });
+      const reviewThreads = prConfig.autoFixReview === false ? [] : parsePrViewReviewThreads((await runChecked(input.command, ["pr", "view", prUrl, "--json", "reviewDecision,reviews"], input.projectRoot)).stdout);
+      latestFeedback = collectActionablePrFeedback({
+        checks,
+        reviewThreads,
+        allowedFailures: input.config?.merge?.allowedFailures ?? []
+      });
+      const pendingChecks = collectPendingPrChecks({ checks, allowedFailures: input.config?.merge?.allowedFailures ?? [] });
+      if (latestFeedback.length === 0 && pendingChecks.length > 0) {
+        const timeoutMs = positiveInt(prConfig.pendingTimeoutMs, 600000);
+        const pollMs = positiveInt(prConfig.pendingPollMs, 15000);
+        if (iteration >= maxPrFixIterations || timeoutMs <= 0 || pendingElapsedMs >= timeoutMs) {
+          return { status: "needs_attention", prUrl, iterations: iteration, actionableFeedback: pendingChecks.map((name) => `Check still pending: ${name}`), merged: false };
+        }
+        const sleepMs = Math.min(pollMs, timeoutMs - pendingElapsedMs);
+        await (input.sleep ?? Bun.sleep)(sleepMs);
+        pendingElapsedMs += sleepMs;
+        continue;
+      }
+      if (latestFeedback.length === 0) {
+        pendingElapsedMs = 0;
+        return { status: "opened", prUrl, iterations: iteration, actionableFeedback: [], merged: false };
+      }
+      pendingElapsedMs = 0;
+      if (iteration >= maxPrFixIterations || prConfig.autoFixChecks === false && prConfig.autoFixReview === false) {
+        return { status: "needs_attention", prUrl, iterations: iteration, actionableFeedback: latestFeedback, merged: false };
+      }
+      await input.lifecycle?.onFeedback?.({ prUrl, iteration, feedback: latestFeedback });
+      await input.steerPi([
+        `PR automation found actionable feedback on ${prUrl}.`,
+        `Fix iteration ${iteration + 1}/${maxPrFixIterations}.`,
+        "",
+        ...latestFeedback.map((entry) => `- ${entry}`)
+      ].join(`
+`));
+      await syncBranchAfterPrFeedback({ projectRoot: input.projectRoot, taskId: input.taskId, branch, gitCommand: input.gitCommand });
+      continue;
+    }
+    const gate = await runStrictPrMergeGate({
+      projectRoot: input.projectRoot,
+      prUrl,
+      taskId: input.taskId,
+      runId: input.runId,
+      cycle: iteration,
+      command: input.command,
+      artifactRoot: input.artifactRoot,
+      allowedFailures: input.config?.merge?.allowedFailures ?? [],
+      greptileApi: requireGreptile ? input.greptileApi : undefined,
+      requireGreptile
+    });
+    latestFeedback = [...gate.actionableFeedback];
+    if (requireGreptile && gateNeedsGreptileRereview(gate)) {
+      const requested = await requestGreptileRereview({
+        prUrl,
+        headSha: gate.evidence.headSha ?? null,
+        command: input.command,
+        cwd: input.projectRoot
+      });
+      if (requested) {
+        await input.lifecycle?.onFeedback?.({
+          prUrl,
+          iteration,
+          feedback: [`Requested a fresh Greptile review for current head ${gate.evidence.headSha ?? "unknown"}; merge stays blocked until Greptile re-reviews it.`]
+        });
+      }
+      const timeoutMs = positiveInt(prConfig.pendingTimeoutMs, 600000);
+      const pollMs = positiveInt(prConfig.pendingPollMs, 15000);
+      if (iteration >= maxPrFixIterations || timeoutMs <= 0 || pendingElapsedMs >= timeoutMs) {
+        return { status: "needs_attention", prUrl, iterations: iteration, actionableFeedback: latestFeedback, merged: false };
+      }
+      const sleepMs = Math.min(pollMs, timeoutMs - pendingElapsedMs);
+      await (input.sleep ?? Bun.sleep)(sleepMs);
+      pendingElapsedMs += sleepMs;
+      continue;
+    }
+    if (gate.approved) {
+      pendingElapsedMs = 0;
+      const finalGate = await runStrictPrMergeGate({
+        projectRoot: input.projectRoot,
+        prUrl,
+        taskId: input.taskId,
+        runId: input.runId,
+        cycle: iteration,
+        command: input.command,
+        artifactRoot: input.artifactRoot,
+        allowedFailures: input.config?.merge?.allowedFailures ?? [],
+        greptileApi: requireGreptile ? input.greptileApi : undefined,
+        requireGreptile,
+        final: true
+      });
+      if (finalGate.approved) {
+        await input.lifecycle?.onMergeStarted?.({ prUrl });
+        await runRepoDefaultMerge({ prUrl, config: input.config, command: input.command, cwd: input.projectRoot, strictGate: finalGate });
+        await input.lifecycle?.onMerged?.({ prUrl });
+        return { status: "merged", prUrl, iterations: iteration, actionableFeedback: [], merged: true };
+      }
+      latestFeedback = [...finalGate.actionableFeedback];
+      if (isPendingOnlyGate(finalGate)) {
+        const timeoutMs = positiveInt(prConfig.pendingTimeoutMs, 600000);
+        const pollMs = positiveInt(prConfig.pendingPollMs, 15000);
+        if (iteration >= maxPrFixIterations || timeoutMs <= 0 || pendingElapsedMs >= timeoutMs) {
+          return { status: "needs_attention", prUrl, iterations: iteration, actionableFeedback: latestFeedback, merged: false };
+        }
+        const sleepMs = Math.min(pollMs, timeoutMs - pendingElapsedMs);
+        await (input.sleep ?? Bun.sleep)(sleepMs);
+        pendingElapsedMs += sleepMs;
+        continue;
+      }
+      if (iteration >= maxPrFixIterations || prConfig.autoFixChecks === false && prConfig.autoFixReview === false) {
+        return { status: "needs_attention", prUrl, iterations: iteration, actionableFeedback: latestFeedback, merged: false };
+      }
+      await input.lifecycle?.onFeedback?.({ prUrl, iteration, feedback: latestFeedback });
+      await input.steerPi(finalGate.steeringPrompt);
+      await syncBranchAfterPrFeedback({ projectRoot: input.projectRoot, taskId: input.taskId, branch, gitCommand: input.gitCommand });
+      continue;
+    }
+    if (isPendingOnlyGate(gate)) {
+      const timeoutMs = positiveInt(prConfig.pendingTimeoutMs, 600000);
+      const pollMs = positiveInt(prConfig.pendingPollMs, 15000);
+      if (iteration >= maxPrFixIterations || timeoutMs <= 0 || pendingElapsedMs >= timeoutMs) {
+        return { status: "needs_attention", prUrl, iterations: iteration, actionableFeedback: latestFeedback, merged: false };
+      }
+      const sleepMs = Math.min(pollMs, timeoutMs - pendingElapsedMs);
+      await (input.sleep ?? Bun.sleep)(sleepMs);
+      pendingElapsedMs += sleepMs;
+      continue;
+    }
+    pendingElapsedMs = 0;
+    if (iteration >= maxPrFixIterations || prConfig.autoFixChecks === false && prConfig.autoFixReview === false) {
+      return { status: "needs_attention", prUrl, iterations: iteration, actionableFeedback: latestFeedback, merged: false };
+    }
+    await input.lifecycle?.onFeedback?.({ prUrl, iteration, feedback: latestFeedback });
+    await input.steerPi(gate.steeringPrompt);
+    await syncBranchAfterPrFeedback({ projectRoot: input.projectRoot, taskId: input.taskId, branch, gitCommand: input.gitCommand });
+  }
+  return { status: "needs_attention", prUrl, iterations: maxPrFixIterations, actionableFeedback: latestFeedback, merged: false };
+}
+export {
+  runRepoDefaultMerge,
+  runPrAutomation,
+  resolvePrAutomationLimits,
+  requestGreptileRereview,
+  pushBranchSyncedWithOrigin,
+  hasCommittableRunChanges,
+  gateNeedsGreptileRereview,
+  commitRunChanges,
+  collectPendingPrChecks,
+  collectActionablePrFeedback,
+  closeIssueAfterMergedPr,
+  buildPrAutomationBody,
+  UPLOADED_SNAPSHOT_PR_MARKER
+};

package/dist/src/control-plane/task-verify.d.ts

@@ -0,0 +1 @@
+export declare function taskVerify(projectRoot: string, taskId?: string): Promise<boolean>;