dev-loops 0.7.1 → 0.7.2

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/request-copilot-review.mjs

@@ -2,6 +2,7 @@
 import { parseArgs } from "node:util";
 import {
   buildParseError,
+  containsBareCopilotSummon,
   formatCliError,
   isCopilotLogin,
   isDirectCliRun,
@@ -14,7 +15,7 @@ import { parsePrNumber, requireTokenValue, runChild } from "../_cli-primitives.m
 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";
-import { loadDevLoopConfig, resolveRefinement } from "@dev-loops/core/config";
+import { loadDevLoopConfig, resolveEffectiveCopilotRoundCap, resolveRefinement } from "@dev-loops/core/config";
 import { JQ_OUTPUT_PARSE_OPTIONS, JQ_OUTPUT_USAGE, emitResult, matchJqOutputToken } from "../lib/jq-output.mjs";
 const BLOCKED_BY_COPILOT_COMMENT_STATUS = "blocked_by_copilot_comment";
 const SUPPRESSED_SAME_HEAD_CLEAN_STATUS = "suppressed_same_head_clean";
@@ -30,13 +31,19 @@ Optional:
   --force-rerequest-review  Bypass the round cap when new commits exist since
                             the last Copilot review. Refused when the PR head
                             has not changed since the last review.
+  --lightweight             This PR is light-dispatched (#1210): enforce the
+                            composed round cap min(localImplementation.lightMode.
+                            maxCopilotRounds ?? 1, refinement.maxCopilotRounds)
+                            instead of refinement.maxCopilotRounds alone.
 Debug:
   DEVLOOPS_DEBUG=1      Emit stderr traces when best-effort same-head clean
                             convergence detection falls back to unsuppressed behavior
 Output (stdout, JSON):
   { "ok": true, "status": "requested"|"already-requested"|"unavailable"|"suppressed_same_head_clean"|"blocked_by_copilot_comment"|"round_cap_reached"|"no_changes_since_last_review"|"suppressed_draft",
     "repo": "...", "pr": N, "reviewer": "Copilot", "detail"?: "...",
-    "sameHeadCleanConverged"?: true, "violationCommentIds"?: [N], "completedRounds"?: N, "maxRounds"?: N }
+    "sameHeadCleanConverged"?: true, "violationCommentIds"?: [N], "completedRounds"?: N, "maxRounds"?: N,
+    "configWarning"?: "..." (present only when --lightweight and dev-loop config failed to load/validate;
+                             the lightweight default cap of 1 was applied instead of the full-PR default) }
 Request statuses:
   requested                     Copilot review was successfully requested
   already-requested             Copilot review was already observably in progress; no new request needed
@@ -52,9 +59,20 @@ Error output (stderr, JSON):
   gh/runtime failures:
     { "ok": false, "error": "..." }
 ${JQ_OUTPUT_USAGE}
+Status contract: "ok": true means the helper ran without error, NOT that a
+review was placed. Callers MUST branch on "status", never on "ok" truthiness
+alone — every non-"requested" status (including blocked_by_copilot_comment)
+is a caller-must-branch outcome, not a silent success.
+--silent exit code: 0 only when status is "requested" (a new request was just
+placed this run); non-zero for every other status, including
+already-requested/suppressed_same_head_clean/unavailable/blocked_by_copilot_comment/
+round_cap_reached/no_changes_since_last_review/suppressed_draft. Without
+--silent the JSON body always prints regardless of status. --jq combined with
+--silent keeps the shared jq-stream truthiness semantics (exit reflects the
+filtered value) and is exempt from the status-based rule above.
 Exit codes:
-  0  Success (including unavailable)
-  1  Argument error or gh failure
+  0  Success (including unavailable); with --silent, only when status is "requested"
+  1  Argument error, gh failure, or (--silent) any non-"requested" status
   2  Invalid --jq filter`.trim();
 const parseError = buildParseError(USAGE);
 export function parseRequestCliArgs(argv) {
@@ -63,6 +81,7 @@ export function parseRequestCliArgs(argv) {
     options: {
       help: { type: "boolean", short: "h" },
       "force-rerequest-review": { type: "boolean" },
+      lightweight: { type: "boolean" },
       repo: { type: "string" },
       pr: { type: "string" },
       ...JQ_OUTPUT_PARSE_OPTIONS,
@@ -76,6 +95,7 @@ export function parseRequestCliArgs(argv) {
     repo: undefined,
     pr: undefined,
     forceRerequestReview: false,
+    lightweight: false,
   };
   for (const token of tokens) {
     if (token.kind === "positional") {
@@ -92,6 +112,10 @@ export function parseRequestCliArgs(argv) {
       options.forceRerequestReview = true;
       continue;
     }
+    if (token.name === "lightweight") {
+      options.lightweight = true;
+      continue;
+    }
     if (token.name === "repo") {
       options.repo = requireTokenValue(token, parseError).trim();
       continue;
@@ -442,7 +466,9 @@ export async function checkForCopilotComments({ repo, pr }, { env = process.env,
     if (isCopilotLogin(author)) {
       continue;
     }
-    if (/(?:^|\W)(@copilot|\/copilot)(?:$|\W)/i.test(body)) {
+    // Exempt bare-text occurrences inside inline code spans/fenced blocks: a
+    // gate-evidence comment legitimately quotes the anti-summon rule itself.
+    if (containsBareCopilotSummon(body)) {
       violationCommentIds.push(comment.id);
     }
   }
@@ -479,16 +505,47 @@ export async function performCopilotReviewRequest(options, { env = process.env,
   }
   let refinementConfig = { maxCopilotRounds: 5 };
   let maxRounds = 5; // Built-in default; overridden by config when loadable
+  // Lightweight fallback when config is unreadable/invalid: fail toward the
+  // SAFE (smaller) lightweight cap instead of silently inheriting the
+  // full-PR default of 5 above, which would let a light-dispatched PR run
+  // far more review rounds than intended whenever the config can't be read.
+  const LIGHTWEIGHT_DEFAULT_CAP = 1;
+  let configWarning = null;
   try {
     const { config, errors } = await loadDevLoopConfig();
     if (!errors || errors.length === 0) {
       refinementConfig = resolveRefinement(config);
-      if (Number.isFinite(refinementConfig.maxCopilotRounds) && refinementConfig.maxCopilotRounds > 0) {
-        maxRounds = refinementConfig.maxCopilotRounds;
+      // Light-dispatched PRs (#1210) enforce the COMPOSED cap —
+      // min(lightMode.maxCopilotRounds ?? 1, refinement.maxCopilotRounds) — so
+      // this enforcement backstop cannot permit rounds beyond the lightweight cap.
+      const effectiveCap = options.lightweight
+        ? resolveEffectiveCopilotRoundCap(config, { lightweight: true })
+        : refinementConfig.maxCopilotRounds;
+      // >= 0 (not > 0): maxCopilotRounds: 0 is documented as "disable Copilot
+      // rounds"; it must be honored as an immediate refusal, not silently
+      // ignored in favor of the built-in default of 5.
+      if (Number.isFinite(effectiveCap) && effectiveCap >= 0) {
+        maxRounds = effectiveCap;
       }
+      if (options.lightweight) {
+        refinementConfig = { ...refinementConfig, maxCopilotRounds: effectiveCap };
+      }
+    } else if (options.lightweight) {
+      maxRounds = LIGHTWEIGHT_DEFAULT_CAP;
+      refinementConfig = { ...refinementConfig, maxCopilotRounds: LIGHTWEIGHT_DEFAULT_CAP };
+      configWarning = `dev-loop config could not be validated; using the lightweight default cap of ${LIGHTWEIGHT_DEFAULT_CAP} instead of the full-PR default. errors=${JSON.stringify(errors)}`;
+    }
+  } catch (err) {
+    if (options.lightweight) {
+      maxRounds = LIGHTWEIGHT_DEFAULT_CAP;
+      refinementConfig = { ...refinementConfig, maxCopilotRounds: LIGHTWEIGHT_DEFAULT_CAP };
+      configWarning = `dev-loop config could not be loaded; using the lightweight default cap of ${LIGHTWEIGHT_DEFAULT_CAP} instead of the full-PR default. error=${err instanceof Error ? err.message : String(err)}`;
     }
-  } catch {
   }
+  // Every remaining return in this function is config-dependent (round-cap
+  // decisions, the request itself); surface a config-load fallback on all of
+  // them rather than just the path a given test happens to exercise.
+  const withConfigWarning = (result) => (configWarning ? { ...result, configWarning } : result);
   // Reconcile the completed-round count with detect-pr-gate-coordination-state (#896):
   // when the raw count has reached the cap, re-derive it with the draft-gate round
   // reset applied. A clean draft_gate re-pass on an earlier head resets the count, so
@@ -511,7 +568,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
         refinementConfig,
       );
       if (!roundCapAutoRerequest.eligible) {
-        return {
+        return withConfigWarning({
           ok: true,
           status: ROUND_CAP_REACHED_STATUS,
           repo: options.repo,
@@ -520,7 +577,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
           completedRounds,
           maxRounds,
           detail: `Round cap of ${maxRounds} reached with ${completedRounds} completed rounds. No further re-requests will be made.`,
-        };
+        });
       }
     }
     // --force-rerequest-review: only bypass when there are new commits since the last review
@@ -531,7 +588,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
     const canCompare = currentHeadSha !== null && lastReviewSha !== null;
     const hasNewCommits = canCompare && currentHeadSha !== lastReviewSha;
     if (!canCompare) {
-      return {
+      return withConfigWarning({
         ok: true,
         status: ROUND_CAP_REACHED_STATUS,
         repo: options.repo,
@@ -540,10 +597,10 @@ export async function performCopilotReviewRequest(options, { env = process.env,
         detail: `Round cap of ${maxRounds} reached with ${completedRounds} completed rounds. --force-rerequest-review was supplied but commit SHA data is unavailable, so change-since-last-review could not be evaluated.`,
         completedRounds,
         maxRounds,
-      };
+      });
     }
     if (!hasNewCommits) {
-      return {
+      return withConfigWarning({
         ok: true,
         status: NO_CHANGES_SINCE_LAST_REVIEW_STATUS,
         repo: options.repo,
@@ -552,7 +609,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
         detail: "No changes since last Copilot review. --force-rerequest-review requires new commits on the PR head.",
         completedRounds,
         maxRounds,
-      };
+      });
     }
     // Has new commits — bypass the round cap and proceed with the request
   }
@@ -562,7 +619,7 @@ export async function performCopilotReviewRequest(options, { env = process.env,
     before,
   );
   if (sameHeadCleanConverged) {
-    return {
+    return withConfigWarning({
       ok: true,
       status: SUPPRESSED_SAME_HEAD_CLEAN_STATUS,
       repo: options.repo,
@@ -570,35 +627,35 @@ export async function performCopilotReviewRequest(options, { env = process.env,
       reviewer: "Copilot",
       sameHeadCleanConverged: true,
       detail: "Current head already has a clean submitted Copilot review; same-head clean-convergence suppression is always enforced.",
-    };
+    });
   }
   if (before.requested || before.hasPendingReviewOnCurrentHead) {
-    return {
+    return withConfigWarning({
       ok: true,
       status: "already-requested",
       repo: options.repo,
       pr: options.pr,
       reviewer: "Copilot",
-    };
+    });
   }
   const requestResult = await requestCopilotReview(options, { env, ghCommand });
   if (requestResult.status === "unavailable") {
     const after = await fetchCopilotReviewState(options, { env, ghCommand });
     if (after.requested || after.hasPendingReviewOnCurrentHead || after.hasSubmittedReviewOnCurrentHead) {
-      return {
+      return withConfigWarning({
         ok: true,
         status: "already-requested",
         repo: options.repo,
         pr: options.pr,
         reviewer: "Copilot",
-      };
+      });
     }
-    return {
+    return withConfigWarning({
       ...requestResult,
-    };
+    });
   }
   if (requestResult.status === "already-requested") {
-    return requestResult;
+    return withConfigWarning(requestResult);
   }
   const after = await fetchCopilotReviewState(options, { env, ghCommand });
   const reviewCountIncreased = after.copilotReviewIds.length > before.copilotReviewIds.length;
@@ -606,9 +663,9 @@ export async function performCopilotReviewRequest(options, { env = process.env,
   if (!reviewNowObservablyInProgress) {
     throw new Error("Copilot review request did not appear in requested reviewers or fresh/in-progress Copilot reviews after gh pr edit");
   }
-  return {
+  return withConfigWarning({
     ...requestResult,
-  };
+  });
 }
 export async function runCli(
   argv = process.argv.slice(2),
@@ -625,7 +682,16 @@ export async function runCli(
     return;
   }
   const result = await performCopilotReviewRequest(options, { env, ghCommand });
-  process.exitCode = emitResult(result, { jq: options.jq, silent: options.silent, stdout, stderr });
+  // Honest status under --silent: `ok: true` reports "the helper ran without
+  // error", not "a review was placed" — a caller checking only exit-code
+  // truthiness must NOT read a non-`requested` status (blocked_by_copilot_comment,
+  // round_cap_reached, etc.) as a placed request. --silent therefore answers
+  // "was a request just placed" specifically: exit 0 only for `requested`,
+  // non-zero for every other status. Non-silent output is unaffected — the full
+  // JSON body (with `ok: true`) still prints for every documented status; the
+  // caller MUST branch on `.status`, not `.ok`.
+  const silentOk = options.silent ? result.status === "requested" : undefined;
+  process.exitCode = emitResult(result, { jq: options.jq, silent: options.silent, stdout, stderr, ok: silentOk });
 }
 if (isDirectCliRun(import.meta.url)) {
   runCli().catch((error) => {