dev-loops 0.7.1 → 0.8.0

package/scripts/github/edit-issue.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { buildParseError, formatCliError, isDirectCliRun } from "../_core-helpers.mjs";
+import { parseIssueNumber, requireTokenValue, runChild } from "../_cli-primitives.mjs";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import { parseArgs } from "node:util";
+import { JQ_OUTPUT_PARSE_OPTIONS, JQ_OUTPUT_USAGE, emitResult, matchJqOutputToken } from "../lib/jq-output.mjs";
+
+const USAGE = `Usage: edit-issue.mjs --repo <owner/name> --issue <number> [--title <t>] [--body <b> | --body-file <path>] [--add-assignee <u>] [--remove-assignee <u>] [--milestone <m>]
+Edit issue title/body/assignees/milestone. Thin wrapper over \`gh issue edit\` — use this
+instead of an agent-level raw \`gh issue edit\` so the loop's internal-tooling record
+stays clean (siblings: edit-pr.mjs, comment-issue.mjs).
+Required:
+  --repo <owner/name>           Repository slug (e.g. owner/repo)
+  --issue <number>              Issue number
+At least one edit:
+  --title <t>                   New issue title
+  --body <b>                    New issue body as a single argument
+  --body-file <path>            Read the new body from a file (- reads stdin)
+  --add-assignee <u>            Assignee to add (repeatable)
+  --remove-assignee <u>         Assignee to remove (repeatable)
+  --milestone <m>               Milestone to set (empty string clears it)
+                                (--title/--body/--body-file reject empty or
+                                whitespace-only values; use --milestone "" only
+                                to clear the milestone)
+Output (stdout, JSON):
+  { "ok": true, "repo": "owner/repo", "issue": 17, "edited": ["title", "body", ...] }
+Error output (stderr, JSON):
+  { "ok": false, "error": "...", "usage"?: "..." }
+${JQ_OUTPUT_USAGE}
+Exit codes:
+  0  Success
+  1  Argument error or gh failure
+  2  Invalid --jq filter`.trim();
+const parseError = buildParseError(USAGE);
+
+export function parseEditIssueCliArgs(argv) {
+  const { tokens } = parseArgs({
+    args: [...argv],
+    options: {
+      help: { type: "boolean", short: "h" },
+      repo: { type: "string" },
+      issue: { type: "string" },
+      title: { type: "string" },
+      body: { type: "string" },
+      "body-file": { type: "string" },
+      "add-assignee": { type: "string", multiple: true },
+      "remove-assignee": { type: "string", multiple: true },
+      milestone: { type: "string" },
+      ...JQ_OUTPUT_PARSE_OPTIONS,
+    },
+    allowPositionals: true,
+    strict: false,
+    tokens: true,
+  });
+  const options = {
+    help: false,
+    repo: undefined,
+    issue: undefined,
+    title: undefined,
+    body: undefined,
+    bodyFile: undefined,
+    addAssignees: [],
+    removeAssignees: [],
+    milestone: undefined,
+    jq: undefined,
+    silent: false,
+  };
+  for (const token of tokens) {
+    if (token.kind === "positional") {
+      throw parseError(`Unknown argument: ${token.value}`);
+    }
+    if (token.kind !== "option") {
+      continue;
+    }
+    if (token.name === "help") {
+      options.help = true;
+      return options;
+    }
+    if (token.name === "repo") {
+      options.repo = requireTokenValue(token, parseError).trim();
+      continue;
+    }
+    if (token.name === "issue") {
+      options.issue = parseIssueNumber(requireTokenValue(token, parseError), parseError);
+      continue;
+    }
+    if (token.name === "title") {
+      const title = requireTokenValue(token, parseError);
+      if (title.trim().length === 0) {
+        throw parseError("--title must not be empty or whitespace-only");
+      }
+      options.title = title;
+      continue;
+    }
+    if (token.name === "body") {
+      const body = requireTokenValue(token, parseError);
+      if (body.trim().length === 0) {
+        throw parseError("--body must not be empty or whitespace-only");
+      }
+      options.body = body;
+      continue;
+    }
+    if (token.name === "body-file") {
+      const rawPath = requireTokenValue(token, parseError).trim();
+      if (rawPath.length === 0) {
+        throw parseError("--body-file must be a non-empty path");
+      }
+      options.bodyFile = rawPath;
+      continue;
+    }
+    if (token.name === "add-assignee") {
+      const u = requireTokenValue(token, parseError).trim();
+      if (u.length === 0) throw parseError("--add-assignee must be a non-empty login");
+      options.addAssignees.push(u);
+      continue;
+    }
+    if (token.name === "remove-assignee") {
+      const u = requireTokenValue(token, parseError).trim();
+      if (u.length === 0) throw parseError("--remove-assignee must be a non-empty login");
+      options.removeAssignees.push(u);
+      continue;
+    }
+    if (token.name === "milestone") {
+      // Read the raw token value: an empty string is a valid milestone value
+      // (`gh issue edit --milestone ""` clears it), so this deliberately does NOT
+      // go through requireTokenValue (which rejects empty). Guard only a truly
+      // missing value (`--milestone` with no following token). A whitespace-only
+      // value is neither a clear nor a real milestone name — fail closed rather
+      // than forwarding it to gh for a less actionable error.
+      if (typeof token.value !== "string") {
+        throw parseError("--milestone requires a value (use an empty string to clear)");
+      }
+      if (token.value.length > 0 && token.value.trim().length === 0) {
+        throw parseError('--milestone must be a milestone name or "" to clear (whitespace-only is not allowed)');
+      }
+      options.milestone = token.value;
+      continue;
+    }
+    if (matchJqOutputToken(token, options, (t) => requireTokenValue(t, parseError))) continue;
+    throw parseError(`Unknown argument: ${token.rawName}`);
+  }
+  if (options.repo === undefined || options.issue === undefined) {
+    throw parseError("Editing an issue requires both --repo <owner/name> and --issue <number>");
+  }
+  if (options.body !== undefined && options.bodyFile !== undefined) {
+    throw parseError("--body and --body-file are mutually exclusive; pass only one");
+  }
+  const hasEdit =
+    options.title !== undefined ||
+    options.body !== undefined ||
+    options.bodyFile !== undefined ||
+    options.addAssignees.length > 0 ||
+    options.removeAssignees.length > 0 ||
+    options.milestone !== undefined;
+  if (!hasEdit) {
+    throw parseError("Editing an issue requires at least one of --title/--body/--body-file/--add-assignee/--remove-assignee/--milestone");
+  }
+  try {
+    parseRepoSlug(options.repo);
+  } catch (error) {
+    throw parseError(error instanceof Error ? error.message : String(error));
+  }
+  return options;
+}
+
+async function resolveBody(options) {
+  if (options.bodyFile === undefined) return options.body;
+  // Stdin (fd 0): the fs/promises readFile does NOT accept an integer fd, so read
+  // it synchronously via the callback-style API (which does). A real path stays on
+  // the async promise read.
+  const body =
+    options.bodyFile === "-" ? readFileSync(0, "utf8") : await readFile(options.bodyFile, "utf8");
+  // Fail closed on an empty / whitespace-only file so a blank --body-file cannot
+  // silently clear the issue body (USAGE promises --body/--title reject empties).
+  if (body.trim().length === 0) {
+    throw new Error(`--body-file ${options.bodyFile} is empty`);
+  }
+  return body;
+}
+
+// Build the `gh issue edit` args and the parallel `edited` list (which fields were
+// touched) so callers get a stable summary without re-reading the issue.
+async function buildEditArgs(options) {
+  const args = ["issue", "edit", String(options.issue), "--repo", options.repo];
+  const edited = [];
+  if (options.title !== undefined) {
+    args.push("--title", options.title);
+    edited.push("title");
+  }
+  // resolveBody still runs for validation (reads the file, throws on empty /
+  // whitespace-only). A REAL --body-file path is handed straight to gh so large
+  // bodies avoid command-length limits. But `--body-file -` (stdin) was already
+  // consumed by resolveBody reading fd 0; re-emitting `--body-file -` makes gh
+  // re-read an exhausted stdin and clear the body, so pass the resolved string
+  // inline via --body instead.
+  const body = await resolveBody(options);
+  if (body !== undefined) {
+    if (options.bodyFile !== undefined && options.bodyFile !== "-") {
+      args.push("--body-file", options.bodyFile);
+    } else {
+      args.push("--body", body);
+    }
+    edited.push("body");
+  }
+  for (const u of options.addAssignees) {
+    args.push("--add-assignee", u);
+  }
+  if (options.addAssignees.length > 0) edited.push("add-assignee");
+  for (const u of options.removeAssignees) {
+    args.push("--remove-assignee", u);
+  }
+  if (options.removeAssignees.length > 0) edited.push("remove-assignee");
+  if (options.milestone !== undefined) {
+    args.push("--milestone", options.milestone);
+    edited.push("milestone");
+  }
+  return { args, edited };
+}
+
+export async function editIssue(options, { env = process.env, ghCommand = "gh", run = runChild } = {}) {
+  const { args, edited } = await buildEditArgs(options);
+  const result = await run(ghCommand, args, env);
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || `exit code ${result.code}`;
+    throw new Error(`gh issue edit failed: ${detail}`);
+  }
+  return { ok: true, repo: options.repo, issue: options.issue, edited };
+}
+
+export async function runCli(
+  argv = process.argv.slice(2),
+  { stdout = process.stdout, stderr = process.stderr, env = process.env, ghCommand = "gh", run = runChild } = {},
+) {
+  let options;
+  try {
+    options = parseEditIssueCliArgs(argv);
+  } catch (error) {
+    stderr.write(`${formatCliError(error)}\n`);
+    return 1;
+  }
+  if (options.help) {
+    stdout.write(`${USAGE}\n`);
+    return 0;
+  }
+  let result;
+  try {
+    result = await editIssue(options, { env, ghCommand, run });
+  } catch (error) {
+    stderr.write(`${JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) })}\n`);
+    return 1;
+  }
+  return emitResult(result, { jq: options.jq, silent: options.silent, stdout, stderr });
+}
+
+if (isDirectCliRun(import.meta.url)) {
+  runCli().then((code) => { process.exitCode = code; });
+}

package/scripts/github/list-review-threads.mjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { buildParseError, formatCliError, isDirectCliRun, parseJsonText } from "../_core-helpers.mjs";
+import { parsePrNumber, requireTokenValue, runChild as defaultRunChild } from "../_cli-primitives.mjs";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import { authorMatchesFilter } from "./_review-thread-mutations.mjs";
+import { JQ_OUTPUT_PARSE_OPTIONS, JQ_OUTPUT_USAGE, emitResult, matchJqOutputToken } from "../lib/jq-output.mjs";
+
+// Dedicated query: unlike capture-review-threads.mjs's REVIEW_THREADS_QUERY
+// (all comments, no path/line/isOutdated, no pagination past 100), this tool
+// needs only the FIRST comment per thread (the reply-resolve target) plus the
+// thread-level path/line/isOutdated fields, and must paginate past 100 threads.
+export const LIST_REVIEW_THREADS_QUERY = [
+  "query($owner: String!, $name: String!, $pr: Int!, $after: String) {",
+  "  repository(owner: $owner, name: $name) {",
+  "    pullRequest(number: $pr) {",
+  "      reviewThreads(first: 100, after: $after) {",
+  "        pageInfo {",
+  "          hasNextPage",
+  "          endCursor",
+  "        }",
+  "        nodes {",
+  "          id",
+  "          isResolved",
+  "          isOutdated",
+  "          path",
+  "          line",
+  "          comments(first: 1) {",
+  "            nodes {",
+  "              databaseId",
+  "              body",
+  "              author {",
+  "                login",
+  "              }",
+  "            }",
+  "          }",
+  "        }",
+  "      }",
+  "    }",
+  "  }",
+  "}",
+].join("\n");
+
+// Bounded excerpt so a listing over many threads stays scannable; full body
+// text is available from capture-review-threads.mjs when actually needed.
+const BODY_EXCERPT_MAX_CHARS = 200;
+
+const USAGE = `Usage: list-review-threads.mjs --repo <owner/name> --pr <number> [--unresolved-only] [--author <login>]
+List review threads on a pull request with the thread id + first-comment
+databaseId reply-resolve-review-thread.mjs needs, so a fixer pass can go
+list -> reply-resolve without hand-written GraphQL.
+Required:
+  --repo <owner/name>   Repository slug (e.g. owner/repo)
+  --pr <number>         Pull request number
+Optional:
+  --unresolved-only     Only include threads where isResolved is false
+  --author <login>      Only include threads whose first comment author matches
+                        (case-insensitive; "copilot" matches any Copilot review
+                        login variant; "all" matches every author)
+Output (stdout, JSON):
+  { "ok": true, "repo": "owner/name", "pr": N, "threads": [
+    { "threadId": "...", "commentId": N|null, "author": "..."|null,
+      "body": "...", "isResolved": bool, "isOutdated": bool,
+      "path": "..."|null, "line": N|null }, ...
+  ] }
+Error output (stderr, JSON):
+  Argument/usage errors:
+    { "ok": false, "error": "...", "usage": "..." }
+  gh/runtime failures:
+    { "ok": false, "error": "..." }
+${JQ_OUTPUT_USAGE}
+Exit codes:
+  0  Success
+  1  Argument error or gh failure
+  2  Invalid --jq filter`.trim();
+
+const parseError = buildParseError(USAGE);
+
+export function parseListReviewThreadsCliArgs(argv) {
+  const { tokens } = parseArgs({
+    args: [...argv],
+    options: {
+      help: { type: "boolean", short: "h" },
+      repo: { type: "string" },
+      pr: { type: "string" },
+      "unresolved-only": { type: "boolean" },
+      author: { type: "string" },
+      ...JQ_OUTPUT_PARSE_OPTIONS,
+    },
+    allowPositionals: true,
+    strict: false,
+    tokens: true,
+  });
+  const options = {
+    help: false,
+    repo: undefined,
+    pr: undefined,
+    unresolvedOnly: false,
+    author: undefined,
+  };
+  for (const token of tokens) {
+    if (token.kind === "positional") {
+      throw parseError(`Unknown argument: ${token.value}`);
+    }
+    if (token.kind !== "option") {
+      continue;
+    }
+    if (token.name === "help") {
+      options.help = true;
+      return options;
+    }
+    if (token.name === "repo") {
+      options.repo = requireTokenValue(token, parseError).trim();
+      continue;
+    }
+    if (token.name === "pr") {
+      options.pr = parsePrNumber(requireTokenValue(token, parseError), parseError);
+      continue;
+    }
+    if (token.name === "unresolved-only") {
+      options.unresolvedOnly = true;
+      continue;
+    }
+    if (token.name === "author") {
+      options.author = requireTokenValue(token, parseError).trim();
+      continue;
+    }
+    if (matchJqOutputToken(token, options, (t) => requireTokenValue(t, parseError))) continue;
+    throw parseError(`Unknown argument: ${token.rawName}`);
+  }
+  if (options.repo === undefined || options.pr === undefined) {
+    throw parseError("Listing review threads requires both --repo <owner/name> and --pr <number>");
+  }
+  try {
+    parseRepoSlug(options.repo);
+  } catch (error) {
+    throw parseError(error instanceof Error ? error.message : String(error));
+  }
+  return options;
+}
+
+function buildQueryArgs({ owner, name, pr, after }) {
+  const args = [
+    "api",
+    "graphql",
+    "--field",
+    `owner=${owner}`,
+    "--field",
+    `name=${name}`,
+    "--field",
+    `pr=${pr}`,
+    "--field",
+    `query=${LIST_REVIEW_THREADS_QUERY}`,
+  ];
+  if (typeof after === "string" && after.length > 0) {
+    args.push("--field", `after=${after}`);
+  }
+  return args;
+}
+
+function readThreadsConnection(payload) {
+  const connection = payload?.data?.repository?.pullRequest?.reviewThreads;
+  if (!connection || typeof connection !== "object") {
+    throw new Error("Invalid review-threads GraphQL payload: missing data.repository.pullRequest.reviewThreads");
+  }
+  const nodes = Array.isArray(connection.nodes) ? connection.nodes : [];
+  const pageInfo = connection.pageInfo ?? {};
+  return {
+    nodes,
+    hasNextPage: Boolean(pageInfo.hasNextPage),
+    endCursor: typeof pageInfo.endCursor === "string" ? pageInfo.endCursor : null,
+  };
+}
+
+function excerptBody(rawBody) {
+  const text = typeof rawBody === "string" ? rawBody.trim() : "";
+  if (text.length <= BODY_EXCERPT_MAX_CHARS) {
+    return text;
+  }
+  return `${text.slice(0, BODY_EXCERPT_MAX_CHARS)}…`;
+}
+
+function normalizeThreadNode(node) {
+  const firstComment = node?.comments?.nodes?.[0] ?? null;
+  const commentId = Number.isFinite(firstComment?.databaseId) ? firstComment.databaseId : null;
+  const authorLogin = firstComment?.author?.login;
+  const author = typeof authorLogin === "string" && authorLogin.length > 0 ? authorLogin : null;
+  return {
+    threadId: typeof node?.id === "string" ? node.id : "",
+    commentId,
+    author,
+    body: excerptBody(firstComment?.body),
+    isResolved: Boolean(node?.isResolved),
+    isOutdated: Boolean(node?.isOutdated),
+    path: typeof node?.path === "string" ? node.path : null,
+    line: typeof node?.line === "number" ? node.line : null,
+  };
+}
+
+export async function fetchAllReviewThreads(
+  { repo, pr },
+  { env = process.env, ghCommand = "gh", runChild = defaultRunChild } = {},
+) {
+  const { owner, name } = parseRepoSlug(repo);
+  const threads = [];
+  let after = null;
+  while (true) {
+    const result = await runChild(ghCommand, buildQueryArgs({ owner, name, pr, after }), env);
+    if (result.code !== 0) {
+      const detail = result.stderr.trim() || `exit code ${result.code}`;
+      throw new Error(`gh command failed: ${detail}`);
+    }
+    const payload = parseJsonText(result.stdout);
+    const { nodes, hasNextPage, endCursor } = readThreadsConnection(payload);
+    for (const node of nodes) {
+      threads.push(normalizeThreadNode(node));
+    }
+    if (!hasNextPage) {
+      break;
+    }
+    if (!endCursor) {
+      throw new Error("Invalid review-threads GraphQL payload: pageInfo.hasNextPage is true but endCursor is missing");
+    }
+    after = endCursor;
+  }
+  return threads;
+}
+
+export function filterThreads(threads, { unresolvedOnly = false, author = undefined } = {}) {
+  // "all" is a match-everything sentinel: bypass the author filter entirely so
+  // threads with a missing/ghost first-comment author (author null) still list.
+  // authorMatchesFilter deliberately rejects empty logins for its reply-resolve
+  // callers, so routing "all" through it would drop those threads.
+  const authorFilter = typeof author === "string" && author.trim().toLowerCase() === "all"
+    ? undefined
+    : author;
+  return threads.filter((thread) => {
+    if (unresolvedOnly && thread.isResolved) {
+      return false;
+    }
+    if (authorFilter !== undefined && !authorMatchesFilter(thread.author, authorFilter)) {
+      return false;
+    }
+    return true;
+  });
+}
+
+export async function runCli(
+  argv = process.argv.slice(2),
+  {
+    stdout = process.stdout,
+    stderr = process.stderr,
+    env = process.env,
+    ghCommand = "gh",
+  } = {},
+) {
+  const options = parseListReviewThreadsCliArgs(argv);
+  if (options.help) {
+    stdout.write(`${USAGE}\n`);
+    return 0;
+  }
+  const allThreads = await fetchAllReviewThreads({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+  const threads = filterThreads(allThreads, { unresolvedOnly: options.unresolvedOnly, author: options.author });
+  const result = { ok: true, repo: options.repo, pr: options.pr, threads };
+  return emitResult(result, { jq: options.jq, silent: options.silent, stdout, stderr });
+}
+
+if (isDirectCliRun(import.meta.url)) {
+  runCli().then((code) => {
+    if (typeof code === "number") {
+      process.exitCode = code;
+    }
+  }).catch((error) => {
+    process.stderr.write(`${formatCliError(error)}\n`);
+    process.exitCode = 1;
+  });
+}

package/scripts/github/post-gate-findings.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { parsePrNumber, requireOptionValue, runChild } from "../_cli-primitives.mjs";
-import { formatCliError, isDirectCliRun, parseJsonText } from "../_core-helpers.mjs";
+import { formatCliError, isDirectCliRun, parseJsonText, sanitizeCopilotSummonTokens } from "../_core-helpers.mjs";
 import { loadDevLoopConfig, resolveGatePostFindingsComments } from "@dev-loops/core/config";
 import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
 import { JQ_OUTPUT_USAGE, emitResult } from "../lib/jq-output.mjs";
@@ -215,7 +215,7 @@ export function renderFindingsCommentBody({ gate, headSha, findings }) {
   ];
   if (findings.length === 0) {
     lines.push("No findings. All review angles passed for this head.");
-    return lines.join("\n");
+    return sanitizeCopilotSummonTokens(lines.join("\n"));
   }
   const grouped = new Map();
   for (const sev of SEVERITY_ORDER) {
@@ -261,7 +261,10 @@ export function renderFindingsCommentBody({ gate, headSha, findings }) {
   while (lines.length > 0 && lines[lines.length - 1] === "") {
     lines.pop();
   }
-  return lines.join("\n");
+  // Neutralize any bare @copilot/`/copilot`* tokens a finding summary quotes
+  // (e.g. an excerpt of the anti-summon rule itself) so this comment can never
+  // arm request-copilot-review.mjs's anti-summon guard.
+  return sanitizeCopilotSummonTokens(lines.join("\n"));
 }
 
 async function runGhJson(args, { env, ghCommand }) {

package/scripts/github/probe-ci-status.mjs

@@ -14,6 +14,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). */
@@ -341,8 +343,10 @@ export async function watchCiStatus(
     ghCommand = "gh",
     delayImpl = delay,
     now = Date.now,
+    ensureOwnershipImpl = ensureAsyncRunnerOwnership,
   } = {},
 ) {
+  const leaseCwd = resolveRepoRoot(process.cwd());
   const { headSha: baselineSha, prVisibleCheckNames } = await fetchPrHeadSha(
     { repo: options.repo, pr: options.pr },
     { env, ghCommand },
@@ -382,6 +386,20 @@ export async function watchCiStatus(
               maxPolls: attemptBudget,
             }) + "\n",
           );
+          // The blocking CI 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, never affects the watch.
+          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/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 */ }
           }
         }
       }