dev-loops 0.7.2 → 0.8.0

package/scripts/github/probe-copilot-review.mjs

@@ -9,6 +9,8 @@ import {
   DEFAULT_POLL_INTERVAL_MS,
   COPILOT_REVIEW_WAIT_TIMEOUT_MS,
 } from "@dev-loops/core/loop/policy-constants";
+import { ensureAsyncRunnerOwnership } from "../loop/_pr-runner-coordination.mjs";
+import { resolveRepoRoot } from "../loop/_repo-root-resolver.mjs";
 
 /** Maximum interval between heartbeat outputs during watch delays.
  *  Must be shorter than pi-subagents default needsAttentionAfterMs (60s). */
@@ -275,14 +277,18 @@ export async function watchCopilotReview(
   {
     env = process.env,
     ghCommand = "gh",
+    delayImpl = delay,
+    now = Date.now,
+    ensureOwnershipImpl = ensureAsyncRunnerOwnership,
   } = {},
 ) {
+  const leaseCwd = resolveRepoRoot(process.cwd());
   const baseline = parseCopilotActivity(await fetchGithubCopilotActivityPayload(
     { repo: options.repo, pr: options.pr },
     { env, ghCommand },
   ));
   const attemptBudget = buildAttemptBudget(options.timeoutMs, options.pollIntervalMs);
-  const watchStartedAtMs = Date.now();
+  const watchStartedAtMs = now();
   for (let attempt = 1; attempt <= attemptBudget; attempt += 1) {
     if (!(options.timeoutMs === 0 && attempt === 1)) {
       const pollDelayMs = buildPollDelayMs(
@@ -290,15 +296,16 @@ export async function watchCopilotReview(
         options.timeoutMs,
         options.pollIntervalMs,
         attempt,
+        now(),
       );
       if (pollDelayMs > 0) {
         let remainingMs = pollDelayMs;
         while (remainingMs > 0) {
           const chunkMs = Math.min(WATCH_HEARTBEAT_MS, remainingMs);
-          await delay(chunkMs);
+          await delayImpl(chunkMs);
           remainingMs -= chunkMs;
           if (remainingMs > 0) {
-            const nowMs = Date.now();
+            const nowMs = now();
             process.stderr.write(
               JSON.stringify({
                 ok: true,
@@ -309,6 +316,20 @@ export async function watchCopilotReview(
                 maxPolls: attemptBudget,
               }) + "\n",
             );
+            // The blocking review wait can span the full watch budget, which
+            // equals the runner-coordination stale window; refresh the lease
+            // alongside each heartbeat so the claim stays fresh for every caller
+            // of this engine. No-ops without DEVLOOPS_RUN_ID; best-effort.
+            try {
+              await ensureOwnershipImpl({
+                repo: options.repo,
+                pr: options.pr,
+                env,
+                cwd: leaseCwd,
+                claimIfMissing: true,
+                requireExisting: false,
+              });
+            } catch { /* best-effort: never affect the watch */ }
           }
         }
       }

package/scripts/github/reconcile-draft-gate.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { parseArgs } from "node:util";
 import { buildParseError, formatCliError, isDirectCliRun, parseJsonText } from "../_core-helpers.mjs";
-import { parsePrNumber, requireTokenValue, runChild } from "../_cli-primitives.mjs";
+import { parsePrNumber, requireTokenValue, runChild as defaultRunChild } from "../_cli-primitives.mjs";
 import { loadDevLoopConfig, resolveGateConfig } from "@dev-loops/core/config";
 import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
 import { detectCheckpointEvidence } from "./detect-checkpoint-evidence.mjs";
@@ -105,7 +105,7 @@ const PR_ID_QUERY = [
   "  }",
   "}",
 ].join("\n");
-async function resolvePrNodeId({ repo, pr }, { env, ghCommand }) {
+async function resolvePrNodeId({ repo, pr }, { env, ghCommand, runChild = defaultRunChild }) {
   const [owner, name] = repo.split("/");
   const result = await runChild(ghCommand, [
     "api", "graphql",
@@ -128,8 +128,8 @@ async function resolvePrNodeId({ repo, pr }, { env, ghCommand }) {
   }
   return { id: prData.id, isDraft: prData.isDraft };
 }
-export async function convertPrToDraft({ repo, pr }, { env, ghCommand }) {
-  const resolvedPr = await resolvePrNodeId({ repo, pr }, { env, ghCommand });
+export async function convertPrToDraft({ repo, pr }, { env, ghCommand, runChild = defaultRunChild }) {
+  const resolvedPr = await resolvePrNodeId({ repo, pr }, { env, ghCommand, runChild });
   if (resolvedPr.isDraft === true) {
     return {
       ...resolvedPr,
@@ -158,7 +158,7 @@ export async function convertPrToDraft({ repo, pr }, { env, ghCommand }) {
     alreadyDraft: false,
   };
 }
-export async function markPrReady({ repo, pr }, { env, ghCommand }) {
+export async function markPrReady({ repo, pr }, { env, ghCommand, runChild = defaultRunChild }) {
   const result = await runChild(ghCommand, [
     "pr", "ready", String(pr),
     "--repo", repo,
@@ -201,7 +201,7 @@ function summarizeBlockingChecks(blockingChecks) {
     .map((check) => `${check.name || "unnamed-check"}=${check.bucket}`)
     .join(", ");
 }
-async function checkCiStatus({ repo, pr, headSha }, { env, ghCommand }) {
+async function checkCiStatus({ repo, pr, headSha }, { env, ghCommand, runChild = defaultRunChild }) {
   const result = await runChild(ghCommand, [
     "pr", "checks", String(pr),
     "--repo", repo,
@@ -244,12 +244,12 @@ async function checkCiStatus({ repo, pr, headSha }, { env, ghCommand }) {
       : `Blocking CI/check state on head ${headSha.slice(0, 7)}: ${summarizeBlockingChecks(blockingChecks)}.`,
   };
 }
-export async function reconcileDraftGate(options, { env = process.env, ghCommand = "gh", repoRoot = process.cwd() } = {}) {
+export async function reconcileDraftGate(options, { env = process.env, ghCommand = "gh", repoRoot = process.cwd(), runChild = defaultRunChild } = {}) {
   const { config } = await loadDevLoopConfig({ repoRoot });
   const draftGateConfig = resolveGateConfig(config, "draft");
   const initialEvidence = await detectCheckpointEvidence(
     { repo: options.repo, pr: options.pr },
-    { env, ghCommand }
+    { env, ghCommand, runChild }
   );
   const headSha = initialEvidence.currentHeadSha;
   if (!headSha) {
@@ -271,7 +271,7 @@ export async function reconcileDraftGate(options, { env = process.env, ghCommand
   if (draftGateConfig.requireCi) {
     const ciStatus = await checkCiStatus(
       { repo: options.repo, pr: options.pr, headSha },
-      { env, ghCommand }
+      { env, ghCommand, runChild }
     );
     if (ciStatus.status !== "success") {
       throw new Error(
@@ -280,7 +280,7 @@ export async function reconcileDraftGate(options, { env = process.env, ghCommand
       );
     }
   }
-  const draftConversion = await convertPrToDraft({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+  const draftConversion = await convertPrToDraft({ repo: options.repo, pr: options.pr }, { env, ghCommand, runChild });
   let gateResult;
   try {
     gateResult = await upsertCheckpointVerdict({
@@ -294,17 +294,17 @@ export async function reconcileDraftGate(options, { env = process.env, ghCommand
         ? "Reconciled non-draft PR — draft gate auto-reconciled (CI green)."
         : "Reconciled non-draft PR — draft gate auto-reconciled (CI optional by config).",
       nextAction: "Mark ready for review (auto-reconciled).",
-    }, { env, ghCommand, repoRoot });
+    }, { env, ghCommand, repoRoot, runChild });
   } catch (error) {
     if (draftConversion.alreadyDraft !== true) {
       try {
-        await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+        await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand, runChild });
       } catch {
       }
     }
     throw error;
   }
-  await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+  await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand, runChild });
   return {
     ok: true,
     action: "reconciled",

package/scripts/github/request-copilot-review.mjs

@@ -11,7 +11,7 @@ import {
   summarizeCopilotReviews,
   summarizeGateReviewComments,
 } from "../_core-helpers.mjs";
-import { parsePrNumber, requireTokenValue, runChild } from "../_cli-primitives.mjs";
+import { parsePrNumber, requireTokenValue, runChild as defaultRunChild } from "../_cli-primitives.mjs";
 import { fetchGithubReviewThreadsPayload } from "./capture-review-threads.mjs";
 import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
 import { buildSnapshotFromPrFacts, interpretLoopState } from "@dev-loops/core/loop/copilot-loop-state";
@@ -176,7 +176,7 @@ function parseReviewsPayload(text, { draftGateResetAtMs = null } = {}) {
     completedCopilotReviewRounds: reviewSummary.completedCopilotReviewRounds,
   };
 }
-async function fetchRequestedReviewers({ repo, pr }, { env = process.env, ghCommand = "gh" } = {}) {
+async function fetchRequestedReviewers({ repo, pr }, { env = process.env, ghCommand = "gh", runChild = defaultRunChild } = {}) {
   const result = await runChild(
     ghCommand,
     ["api", `repos/${repo}/pulls/${pr}/requested_reviewers`],
@@ -188,7 +188,7 @@ async function fetchRequestedReviewers({ repo, pr }, { env = process.env, ghComm
   }
   return parseRequestedReviewersPayload(result.stdout);
 }
-async function fetchCopilotReviewIds({ repo, pr }, { env = process.env, ghCommand = "gh" } = {}) {
+async function fetchCopilotReviewIds({ repo, pr }, { env = process.env, ghCommand = "gh", runChild = defaultRunChild } = {}) {
   const result = await runChild(
     ghCommand,
     ["pr", "view", String(pr), "--repo", repo, "--json", "headRefOid,isDraft,state,number,reviews,statusCheckRollup"],
@@ -213,7 +213,7 @@ async function fetchCopilotReviewIds({ repo, pr }, { env = process.env, ghComman
 // detector uses for the latest clean draft_gate marker), not the full checkpoint-
 // evidence pipeline, to keep the added surface minimal. Best-effort: a fetch failure
 // falls back to the raw count, so the cap is never silently disabled.
-async function resolveDraftGateAdjustedRounds(options, { env = process.env, ghCommand = "gh" } = {}, before) {
+async function resolveDraftGateAdjustedRounds(options, { env = process.env, ghCommand = "gh", runChild = defaultRunChild } = {}, before) {
   try {
     const currentHeadSha = typeof before?.prData?.headRefOid === "string" && before.prData.headRefOid.trim().length > 0
       ? before.prData.headRefOid.trim()
@@ -386,7 +386,7 @@ function classifyRequestFailure(detail) {
   }
   return undefined;
 }
-async function requestCopilotReview({ repo, pr }, { env = process.env, ghCommand = "gh" } = {}) {
+async function requestCopilotReview({ repo, pr }, { env = process.env, ghCommand = "gh", runChild = defaultRunChild } = {}) {
   const result = await runChild(
     ghCommand,
     ["pr", "edit", String(pr), "--repo", repo, "--add-reviewer", "@copilot"],
@@ -398,7 +398,7 @@ async function requestCopilotReview({ repo, pr }, { env = process.env, ghCommand
     if (classified === "unavailable") {
       let existing;
       try {
-        existing = await fetchCopilotReviewIds({ repo, pr }, { env, ghCommand });
+        existing = await fetchCopilotReviewIds({ repo, pr }, { env, ghCommand, runChild });
       } catch {
         // Best-effort: if gh pr view fails transiently (rate limit, network, auth),
         // return unavailable rather than throwing — the 422 failure is already stable.
@@ -439,7 +439,7 @@ async function requestCopilotReview({ repo, pr }, { env = process.env, ghCommand
     reviewer: "Copilot",
   };
 }
-export async function checkForCopilotComments({ repo, pr }, { env = process.env, ghCommand = "gh" } = {}) {
+export async function checkForCopilotComments({ repo, pr }, { env = process.env, ghCommand = "gh", runChild = defaultRunChild } = {}) {
   const result = await runChild(
     ghCommand,
     ["api", `repos/${repo}/issues/${pr}/comments`, "--paginate", "--jq", ".[]"],
@@ -477,8 +477,9 @@ export async function checkForCopilotComments({ repo, pr }, { env = process.env,
     violationCommentIds,
   };
 }
-export async function performCopilotReviewRequest(options, { env = process.env, ghCommand = "gh" } = {}) {
-  const before = await fetchCopilotReviewState(options, { env, ghCommand });
+export async function performCopilotReviewRequest(options, { env = process.env, ghCommand = "gh", runChild = defaultRunChild } = {}) {
+  const runtime = { env, ghCommand, runChild };
+  const before = await fetchCopilotReviewState(options, runtime);
   if (before.prData?.isDraft) {
     return {
       ok: true,
@@ -490,7 +491,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
     };
   }
   if (!env.GH_SEQUENCE_PATH) {
-    const copilotCommentCheck = await checkForCopilotComments(options, { env, ghCommand });
+    const copilotCommentCheck = await checkForCopilotComments(options, runtime);
     if (copilotCommentCheck.blocked) {
       return {
         ok: true,
@@ -555,7 +556,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
   if (completedRounds >= maxRounds
       && !before.requested
       && !before.hasPendingReviewOnCurrentHead) {
-    completedRounds = await resolveDraftGateAdjustedRounds(options, { env, ghCommand }, before);
+    completedRounds = await resolveDraftGateAdjustedRounds(options, runtime, before);
   }
   if (completedRounds >= maxRounds
       && !before.requested
@@ -563,7 +564,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
     if (!options.forceRerequestReview) {
       const roundCapAutoRerequest = await detectRoundCapAutoRerequestEligibility(
         options,
-        { env, ghCommand },
+        runtime,
         before,
         refinementConfig,
       );
@@ -615,7 +616,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
   }
   const sameHeadCleanConverged = await detectSameHeadCleanConvergence(
     options,
-    { env, ghCommand },
+    runtime,
     before,
   );
   if (sameHeadCleanConverged) {
@@ -638,9 +639,9 @@ export async function performCopilotReviewRequest(options, { env = process.env,
       reviewer: "Copilot",
     });
   }
-  const requestResult = await requestCopilotReview(options, { env, ghCommand });
+  const requestResult = await requestCopilotReview(options, runtime);
   if (requestResult.status === "unavailable") {
-    const after = await fetchCopilotReviewState(options, { env, ghCommand });
+    const after = await fetchCopilotReviewState(options, runtime);
     if (after.requested || after.hasPendingReviewOnCurrentHead || after.hasSubmittedReviewOnCurrentHead) {
       return withConfigWarning({
         ok: true,
@@ -657,7 +658,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
   if (requestResult.status === "already-requested") {
     return withConfigWarning(requestResult);
   }
-  const after = await fetchCopilotReviewState(options, { env, ghCommand });
+  const after = await fetchCopilotReviewState(options, runtime);
   const reviewCountIncreased = after.copilotReviewIds.length > before.copilotReviewIds.length;
   const reviewNowObservablyInProgress = after.requested || after.hasPendingReviewOnCurrentHead || reviewCountIncreased;
   if (!reviewNowObservablyInProgress) {

package/scripts/github/upsert-checkpoint-verdict.mjs

@@ -5,7 +5,7 @@ import { loadDevLoopConfig, resolveEffectiveCopilotRoundCap, resolveGateAngleCon
 import { checkFanoutAngleCoverage } from "@dev-loops/core/loop/gate-fanin";
 import { parseArgs } from "node:util";
 import { JQ_OUTPUT_PARSE_OPTIONS, JQ_OUTPUT_USAGE, emitResult, matchJqOutputToken } from "../lib/jq-output.mjs";
-import { parsePrNumber, requireTokenValue, runChild } from "../_cli-primitives.mjs";
+import { parsePrNumber, requireTokenValue, runChild as defaultRunChild } from "../_cli-primitives.mjs";
 import { truncateText } from "@dev-loops/core/bash-exit-one";
 import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
 import { loadPrGateCoordinationContext } from "../loop/detect-pr-gate-coordination-state.mjs";
@@ -839,7 +839,7 @@ function detectStaleGateCommentWarning({ strict, headSha, gate }) {
   }
   return `A gate comment for \`${gate}\` already exists on a different head SHA \`${strict.headSha}\` (comment ${strict.commentId}). The old comment is stale for the current head.`;
 }
-async function runGhJson(args, { env, ghCommand }) {
+async function runGhJson(args, { env, ghCommand, runChild = defaultRunChild }) {
   const result = await runChild(ghCommand, args, env);
   if (result.code !== 0) {
     const detail = result.stderr.trim() || `exit code ${result.code}`;
@@ -857,18 +857,18 @@ function parseCommentMutationResponse(payload) {
   }
   return { commentId, commentUrl };
 }
-async function createComment({ repo, pr, body }, { env, ghCommand }) {
-  const payload = await runGhJson(["api", "repos/" + repo + "/issues/" + pr + "/comments", "-f", `body=${body}`], { env, ghCommand });
+async function createComment({ repo, pr, body }, { env, ghCommand, runChild = defaultRunChild }) {
+  const payload = await runGhJson(["api", "repos/" + repo + "/issues/" + pr + "/comments", "-f", `body=${body}`], { env, ghCommand, runChild });
   return parseCommentMutationResponse(payload);
 }
-async function updateComment({ repo, commentId, body }, { env, ghCommand }) {
-  const payload = await runGhJson(["api", "-X", "PATCH", `repos/${repo}/issues/comments/${commentId}`, "-f", `body=${body}`], { env, ghCommand });
+async function updateComment({ repo, commentId, body }, { env, ghCommand, runChild = defaultRunChild }) {
+  const payload = await runGhJson(["api", "-X", "PATCH", `repos/${repo}/issues/comments/${commentId}`, "-f", `body=${body}`], { env, ghCommand, runChild });
   return parseCommentMutationResponse(payload);
 }
 
-async function verifyComment({ repo, commentId }, { env, ghCommand }) {
+async function verifyComment({ repo, commentId }, { env, ghCommand, runChild = defaultRunChild }) {
   try {
-    const payload = await runGhJson(["api", `repos/${repo}/issues/comments/${commentId}`], { env, ghCommand });
+    const payload = await runGhJson(["api", `repos/${repo}/issues/comments/${commentId}`], { env, ghCommand, runChild });
     return payload?.id != null;
   } catch {
     return false;
@@ -895,13 +895,13 @@ async function verifyComment({ repo, commentId }, { env, ghCommand }) {
 // markPrReady mutations are individually idempotent, so concurrent cooperating
 // runners cause at most a transient draft flicker (not a stuck draft) — only a hard
 // crash mid-transition can leave the PR drafted until a subsequent run.
-async function postDraftGateViaDraftTransition(options, { env, ghCommand, repoRoot }) {
+async function postDraftGateViaDraftTransition(options, { env, ghCommand, repoRoot, runChild = defaultRunChild }) {
   const { convertPrToDraft, markPrReady } = await import("./reconcile-draft-gate.mjs");
   process.stderr.write(
     `[draft_gate] ${options.repo}#${options.pr} is ready but needs clean draft_gate evidence; ` +
     `temporarily converting to draft to post the verdict, then restoring ready.\n`,
   );
-  const conversion = await convertPrToDraft({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+  const conversion = await convertPrToDraft({ repo: options.repo, pr: options.pr }, { env, ghCommand, runChild });
   let result;
   try {
     // The PR is now a draft, so RUN_DRAFT_GATE is the legal action. Re-enter with
@@ -912,12 +912,12 @@ async function postDraftGateViaDraftTransition(options, { env, ghCommand, repoRo
     // with a clear error instead of recursing indefinitely (exit 13). (#1020)
     result = await upsertCheckpointVerdict(
       { ...options, _draftTransitionInProgress: true },
-      { env, ghCommand, repoRoot },
+      { env, ghCommand, repoRoot, runChild },
     );
   } catch (error) {
     if (conversion.alreadyDraft !== true) {
       try {
-        await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+        await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand, runChild });
         process.stderr.write(`[draft_gate] restored ${options.repo}#${options.pr} to ready after a failed verdict post.\n`);
       } catch (restoreError) {
         // Best-effort restore; surface the original error but log the restore failure
@@ -932,7 +932,7 @@ async function postDraftGateViaDraftTransition(options, { env, ghCommand, repoRo
   }
   if (conversion.alreadyDraft !== true) {
     try {
-      await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+      await markPrReady({ repo: options.repo, pr: options.pr }, { env, ghCommand, runChild });
     } catch (restoreError) {
       // The verdict WAS posted successfully; only the ready-restore failed. Make that
       // explicit so the caller does not re-post the gate (the comment already exists)
@@ -949,7 +949,8 @@ async function postDraftGateViaDraftTransition(options, { env, ghCommand, repoRo
   return { ...result, draftTransition: true };
 }
 
-export async function upsertCheckpointVerdict(options, { env = process.env, ghCommand = "gh", repoRoot = process.cwd() } = {}) {
+export async function upsertCheckpointVerdict(options, { env = process.env, ghCommand = "gh", repoRoot = process.cwd(), runChild = defaultRunChild } = {}) {
+  const gh = { env, ghCommand, repoRoot, runChild };
   // Root cause 1: allow resurrected sessions to claim ownership when the previous
   // run's coordination record is stale. Without this, a new run ID is rejected even
   // though the old run is dead, forcing manual file deletion.
@@ -968,7 +969,7 @@ export async function upsertCheckpointVerdict(options, { env = process.env, ghCo
   // Thread the light-dispatch signal (#1210) so the context interpreter and the
   // maxCopilotRounds resolution below both use the composed lightweight cap —
   // the two must never disagree at the cap boundary (#1126).
-  const coordinationContext = await loadPrGateCoordinationContext({ repo: options.repo, pr: options.pr, lightweight: options.lightweight === true }, { env, ghCommand });
+  const coordinationContext = await loadPrGateCoordinationContext({ repo: options.repo, pr: options.pr, lightweight: options.lightweight === true }, gh);
   const evidence = coordinationContext.gateEvidence;
   const canonicalHeadSha = resolveRequestedHeadSha(options.headSha, evidence.currentHeadSha);
   const { config } = await loadDevLoopConfig({ repoRoot });
@@ -982,7 +983,7 @@ export async function upsertCheckpointVerdict(options, { env = process.env, ghCo
   // without requiring an external Copilot review cycle.
   let reviewMode = null;
   try {
-    const internalResult = await detectInternalOnly({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+    const internalResult = await detectInternalOnly({ repo: options.repo, pr: options.pr }, gh);
     if (internalResult?.ok && internalResult.internalOnly) {
       reviewMode = "internal_only";
     }
@@ -1010,6 +1011,7 @@ export async function upsertCheckpointVerdict(options, { env = process.env, ghCo
     draftGateRequireCi: draftGateConfig.requireCi,
     draftGate: coordinationContext.gateEvidence.draftGate,
     draftGateMarker: coordinationContext.gateEvidence.draftGateMarker,
+    refinementArtifact: coordinationContext.refinementArtifact,
     preApprovalGate: coordinationContext.gateEvidence.preApprovalGate,
     preApprovalGateMarker: coordinationContext.gateEvidence.preApprovalGateMarker,
     ...(reviewMode ? { reviewMode } : {}),
@@ -1089,7 +1091,7 @@ export async function upsertCheckpointVerdict(options, { env = process.env, ghCo
     && !coordination.draftGateAlreadySatisfied
     && coordination.allowedNextActions.includes(PR_CHECKPOINT_ACTION.RECONCILE_DRAFT_GATE)
   ) {
-    return await postDraftGateViaDraftTransition(options, { env, ghCommand, repoRoot });
+    return await postDraftGateViaDraftTransition(options, { env, ghCommand, repoRoot, runChild });
   }
   // Fail closed on a lagged draft-state read: we are re-entering FROM
   // postDraftGateViaDraftTransition (which just converted the PR to draft) yet the
@@ -1296,15 +1298,15 @@ export async function upsertCheckpointVerdict(options, { env = process.env, ghCo
     };
   }
   if (existing) {
-    const updated = await updateComment({ repo: options.repo, commentId: existing.commentId, body: desiredBody }, { env, ghCommand });
+    const updated = await updateComment({ repo: options.repo, commentId: existing.commentId, body: desiredBody }, gh);
     // Post-update verification: verify the updated comment is visible via direct API fetch by comment ID.
     // A run id is set (production context) — DEVLOOPS_RUN_ID.
     let updateVerificationWarning = null;
     if (envRunId) {
-      let verified = await verifyComment({ repo: options.repo, commentId: updated.commentId }, { env, ghCommand });
+      let verified = await verifyComment({ repo: options.repo, commentId: updated.commentId }, gh);
       if (!verified) {
         await new Promise((resolve) => setTimeout(resolve, 2000));
-        verified = await verifyComment({ repo: options.repo, commentId: updated.commentId }, { env, ghCommand });
+        verified = await verifyComment({ repo: options.repo, commentId: updated.commentId }, gh);
       }
       updateVerificationWarning = !verified
         ? `Post-update verification failed: comment ${updated.commentId} not retrievable after retry.`
@@ -1327,7 +1329,7 @@ export async function upsertCheckpointVerdict(options, { env = process.env, ghCo
       ...(updateVerificationWarning ? { verificationWarning: updateVerificationWarning } : {}),
     };
   }
-  const created = await createComment({ repo: options.repo, pr: options.pr, body: desiredBody }, { env, ghCommand });
+  const created = await createComment({ repo: options.repo, pr: options.pr, body: desiredBody }, gh);
   // Post-creation verification: verify the comment is retrievable before returning.
   // GitHub API can have brief eventual-consistency windows where a just-posted
   // comment is not yet returned by paginated list endpoints. A direct fetch
@@ -1337,11 +1339,11 @@ export async function upsertCheckpointVerdict(options, { env = process.env, ghCo
   let verified = true;
   let verificationWarning = null;
   if (envRunId) {
-    verified = await verifyComment({ repo: options.repo, commentId: created.commentId }, { env, ghCommand });
+    verified = await verifyComment({ repo: options.repo, commentId: created.commentId }, gh);
     if (!verified) {
       // Brief wait then retry — eventual consistency should resolve within ~2s.
       await new Promise((resolve) => setTimeout(resolve, 2000));
-      verified = await verifyComment({ repo: options.repo, commentId: created.commentId }, { env, ghCommand });
+      verified = await verifyComment({ repo: options.repo, commentId: created.commentId }, gh);
     }
     verificationWarning = !verified
       ? `Post-creation verification failed: comment ${created.commentId} not retrievable after retry. The comment was created (API confirmed) but may not appear in list endpoints immediately.`