omp-conductor 0.15.10 → 0.15.12

package/src/store.ts

@@ -31,6 +31,9 @@ import type {
   HeldNotice,
   InterruptCategory,
   HeldNoticeDraft,
+  IntakeDraft,
+  IntakeItem,
+  IntakeState,
   MaterialEvent,
   MaterialEventDraft,
   LabelOp,
@@ -41,6 +44,7 @@ import type {
   ReportKind,
   ReportRecord,
   RecoveryAction,
+  RunPatch,
   RunRecord,
   RunState,
   SessionRole,
@@ -78,6 +82,7 @@ const ACTIVE_PLACEHOLDERS = ACTIVE_STATES.map(() => "?").join(", ");
 const FRICTION_HOLD_REASONS: ReadonlySet<FrictionAdmissionReason> = new Set([
   "failed-attempts",
   "continuations",
+  "stale-base",
   "parent-lookup-error",
   "issue-state-lookup-error",
   "open-pr-lookup-error",
@@ -129,6 +134,7 @@ const UPDATABLE_COLUMNS: Record<string, true> = {
   failureClass: true,
   recoveryAction: true,
   recoveredAt: true,
+  model: true,
 };
 
 /** Everything SQLite will accept from us. */
@@ -165,6 +171,7 @@ interface RunRow {
   failureClass: string | null;
   recoveryAction: string | null;
   recoveredAt: number | null;
+  model: string | null;
 }
 
 /** The `base_health` table exactly as SQLite hands it back. */
@@ -292,6 +299,34 @@ interface MergeLockRow {
   at: number;
 }
 
+/** The `intake_items` table exactly as SQLite hands it back (#299). */
+interface IntakeRow {
+  id: string;
+  project: string;
+  text: string;
+  createdAt: number;
+  state: string;
+  issueUrl: string | null;
+  groomedAt: number | null;
+}
+
+/**
+ * NULL columns become absent properties, matching the other row converters:
+ * a record read back out of the store deep-equals the one that went in.
+ */
+function toIntakeItem(row: IntakeRow): IntakeItem {
+  const item: IntakeItem = {
+    id: row.id,
+    project: row.project,
+    text: row.text,
+    createdAt: row.createdAt,
+    state: row.state as IntakeState,
+    ...(row.issueUrl === null ? {} : { issueUrl: row.issueUrl }),
+    ...(row.groomedAt === null ? {} : { groomedAt: row.groomedAt }),
+  };
+  return item;
+}
+
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS runs (
   id          TEXT    PRIMARY KEY,
@@ -322,7 +357,8 @@ CREATE TABLE IF NOT EXISTS runs (
   report      TEXT,
   failureClass TEXT,
   recoveryAction TEXT,
-  recoveredAt INTEGER
+  recoveredAt INTEGER,
+  model       TEXT
 );
 CREATE INDEX IF NOT EXISTS runs_project_issue ON runs (project, issue);
 CREATE INDEX IF NOT EXISTS runs_project_state ON runs (project, state);
@@ -575,6 +611,23 @@ CREATE TABLE IF NOT EXISTS label_ops (
   lastError     TEXT
 );
 CREATE INDEX IF NOT EXISTS label_ops_project_next ON label_ops (project, nextAttemptAt);
+
+-- Raw ideas captured by the intake command (#299), held durably until
+-- #300 resolves them into issues. A thought from 02:00 must survive a restart
+-- and a reinstall, so it lives here rather than in any process's memory. The
+-- state CHECK keeps the three-state vocabulary exact; issueUrl and groomedAt
+-- stay NULL until an idea becomes (or is dropped instead of) an issue.
+CREATE TABLE IF NOT EXISTS intake_items (
+  id        TEXT    PRIMARY KEY,
+  project   TEXT    NOT NULL,
+  text      TEXT    NOT NULL,
+  createdAt INTEGER NOT NULL,
+  state     TEXT    NOT NULL CHECK (state IN ('pending', 'groomed', 'dismissed')),
+  issueUrl  TEXT,
+  groomedAt INTEGER
+);
+CREATE INDEX IF NOT EXISTS intake_items_project_state
+  ON intake_items (project, state, createdAt);
 `;
 
 /**
@@ -658,6 +711,7 @@ function toRecord(row: RunRow): RunRecord {
   if (row.failureClass !== null) record.failureClass = row.failureClass as FailureClass;
   if (row.recoveryAction !== null) record.recoveryAction = row.recoveryAction as RecoveryAction;
   if (row.recoveredAt !== null) record.recoveredAt = row.recoveredAt;
+  if (row.model !== null) record.model = row.model;
   return record;
 }
 
@@ -937,10 +991,10 @@ export function openStore(dbPath: string): Store {
   if (!columns.some((column) => column.name === "settlementFlags")) {
     db.exec("ALTER TABLE runs ADD COLUMN settlementFlags TEXT");
   }
-  // Rows written before the settlement report was persisted (#199) have no
-  // text to pool across attempts, so a continuation reads empty priors and
-  // audits exactly as it did before this release. No backfill: the bytes only
-  // ever existed in a worker's memory.
+  // The settlement report was first persisted in #199; rows written before it
+  // simply have no report, which is the honest reading of a kill that never
+  // produced one. No backfill: the bytes only ever existed in a worker's
+  // memory.
   if (!columns.some((column) => column.name === "report")) {
     db.exec("ALTER TABLE runs ADD COLUMN report TEXT");
   }
@@ -957,6 +1011,13 @@ export function openStore(dbPath: string): Store {
       db.exec(`ALTER TABLE runs ADD COLUMN ${name} ${type}`);
     }
   }
+  // The model a run dispatched on was first written by the modelFallbacks
+  // failover chain (#286). Rows predating the column are NULL, which is the
+  // honest reading: only a chain-configured project records a model, and the
+  // harness's own downgrade stays on the worker result, never in this column.
+  if (!columns.some((column) => column.name === "model")) {
+    db.exec("ALTER TABLE runs ADD COLUMN model TEXT");
+  }
   // Existing held-notice rows predate exact digest ownership (#274). A NULL
   // report id is truthful for already-digested history and means "still owed"
   // only while digestedAt is also NULL.
@@ -1101,6 +1162,38 @@ export function openStore(dbPath: string): Store {
         AND (state <> 'merged' OR COALESCE(endedAt, startedAt) >= ?)
       ORDER BY startedAt DESC`,
   );
+  // Every attempt that recorded one PR URL, newest first — deliberately NOT the
+  // `recentRuns` newest-attempt-per-issue view. Mediated PR verbs resolve a
+  // PR's owner through this: a requeued continuation hides its predecessor's
+  // PR from `recentRuns` the moment it is created, so ownership must be able
+  // to read past the issue's newest row (#434). Merged rows keep the same
+  // recent-history bound as `recentRuns`.
+  const selectRunsForPr = db.query<RunRow, [string, string, number]>(
+    `SELECT * FROM runs
+      WHERE project = ? AND prUrl = ?
+        AND (state <> 'merged' OR COALESCE(endedAt, startedAt) >= ?)
+      ORDER BY startedAt DESC, rowid DESC`,
+  );
+  // The stats window (#282): rows settling at or after `since` — merged rows
+  // included, so a chain whose PR merged inside the window is an outcome —
+  // plus, for those merged issues, their WHOLE attempt chain even when it
+  // started before the window. A continuation that began weeks ago and merged
+  // today must report one lead time from its first claim, not from the window
+  // start; ordering by issue/startedAt makes the first row of each chain its
+  // first queue-label claim.
+  const selectStatsRuns = db.query<RunRow, [string, number, string, number]>(
+    `SELECT * FROM runs
+      WHERE project = ?
+        AND (
+          COALESCE(endedAt, startedAt) >= ?
+          OR issue IN (
+            SELECT issue FROM runs
+              WHERE project = ? AND state = 'merged'
+                AND COALESCE(endedAt, startedAt) >= ?
+          )
+        )
+      ORDER BY issue ASC, startedAt ASC, rowid ASC`,
+  );
   const selectPendingBaseChecks = db.query<RunRow, [string, number]>(
     `SELECT * FROM runs
       WHERE project = ? AND state = 'merged' AND baseCheck = 'pending'
@@ -1215,6 +1308,14 @@ export function openStore(dbPath: string): Store {
       ORDER BY startedAt DESC, rowid DESC
       LIMIT 1`,
   );
+  // Every attempt for one issue, oldest first. An exhaustion escalation groups
+  // these by `failureClass` to report how the continuation budget was spent
+  // (#439); the numeric `*For` counters cannot reconstruct that on their own.
+  const selectRunsForIssue = db.query<RunRow, [string, number]>(
+    `SELECT * FROM runs
+      WHERE project = ? AND issue = ?
+      ORDER BY startedAt ASC, rowid ASC`,
+  );
   const upsertTurnOverride = db.query<unknown, [string, number, number, number]>(
     `INSERT INTO turn_overrides (project, issue, maxTurns, setAt) VALUES (?, ?, ?, ?)
      ON CONFLICT(project, issue) DO UPDATE SET
@@ -1247,14 +1348,8 @@ export function openStore(dbPath: string): Store {
       ORDER BY setAt DESC, rowid DESC
       LIMIT ?`,
   );
-  // Every attempt that settled with a report, in attempt order. NULLs are the
-  // rows written before #199, or one killed before the worker returned a
-  // report — skipping them makes a continuation read exactly today's priors.
-  const selectAttemptReports = db.query<{ attempt: number; report: string }, [string, number]>(
-    `SELECT attempt, report FROM runs
-      WHERE project = ? AND issue = ? AND report IS NOT NULL
-      ORDER BY attempt`,
-  );
+  // The settlement report row is kept for the audit trail; nothing pools it
+  // across attempts any more (#488).
   const countStartedSince = db.query<{ n: number }, [string, number]>(
     `SELECT COUNT(*) AS n FROM runs WHERE project = ? AND startedAt >= ?`,
   );
@@ -1331,6 +1426,10 @@ export function openStore(dbPath: string): Store {
   const selectGhCalls = db.query<{ source: string; calls: number }, [string]>(
     `SELECT source, calls FROM gh_calls WHERE day = ? ORDER BY source`,
   );
+  const sumGhCallsBetween = db.query<{ total: number }, [string, string]>(
+    `SELECT COALESCE(SUM(calls), 0) AS total FROM gh_calls
+      WHERE day BETWEEN ? AND ?`,
+  );
 
   // The report outbox (#123). Every terminal transition names the attempt it is
   // settling, because a request can come back *after* the stale-`sending` sweep
@@ -1531,12 +1630,20 @@ export function openStore(dbPath: string): Store {
       LIMIT ?`,
   );
   const selectHeldNoticeBacklog = db.query<
-    { count: number; availabilityCount: number | null; oldestAt: number | null },
+    {
+      count: number;
+      availabilityCount: number | null;
+      oldestAt: number | null;
+      digestOldestAt: number | null;
+      availabilityOldestAt: number | null;
+    },
     [string]
   >(
     `SELECT COUNT(*) AS count,
             SUM(CASE WHEN releaseOnAvailable = 1 THEN 1 ELSE 0 END) AS availabilityCount,
-            MIN(createdAt) AS oldestAt
+            MIN(createdAt) AS oldestAt,
+            MIN(CASE WHEN releaseOnAvailable = 0 THEN createdAt END) AS digestOldestAt,
+            MIN(CASE WHEN releaseOnAvailable = 1 THEN createdAt END) AS availabilityOldestAt
        FROM held_notices
       WHERE project = ? AND (
         (digestReportId IS NULL AND digestedAt IS NULL)
@@ -1581,6 +1688,23 @@ export function openStore(dbPath: string): Store {
         OR EXISTS (SELECT 1 FROM reports WHERE reports.id = material_events.digestReportId AND reports.state = 'failed')
       )`,
   );
+  const insertIntake = db.query<unknown, SqlValue[]>(
+    `INSERT INTO intake_items (id, project, text, createdAt, state)
+     VALUES (?, ?, ?, ?, 'pending')`,
+  );
+  const selectPendingIntake = db.query<IntakeRow, [string]>(
+    `SELECT * FROM intake_items
+      WHERE project = ? AND state = 'pending'
+      ORDER BY createdAt ASC, rowid ASC`,
+  );
+  const groomIntake = db.query<unknown, SqlValue[]>(
+    `UPDATE intake_items SET state = 'groomed', issueUrl = ?, groomedAt = ?
+      WHERE id = ? AND state = 'pending'`,
+  );
+  const dismissIntake = db.query<unknown, [string]>(
+    `UPDATE intake_items SET state = 'dismissed', issueUrl = NULL, groomedAt = NULL
+      WHERE id = ? AND state = 'pending'`,
+  );
   // The newest digest dedupe key a project has actually run toward — an
   // `updatedAt`-newest row whose key is a digest prefix and that did not end in
   // failure. The CLI refuses an off-schedule digest by comparing this against
@@ -1949,11 +2073,15 @@ export function openStore(dbPath: string): Store {
       return createRunTx(r);
     },
 
-    updateRun(id: string, patch: Partial<RunRecord>): void {
+    updateRun(id: string, patch: RunPatch): void {
       const assignments: string[] = [];
       const values: SqlValue[] = [];
       for (const [column, value] of Object.entries(patch)) {
-        if (!UPDATABLE_COLUMNS[column]) continue;
+        // An explicitly-`undefined` key is the same as an absent one: a patch
+        // built by spreading a partial result must not widen into columns the
+        // caller did not mean to write (#468). Clearing a column still works by
+        // naming it with an explicit `null`, which `toSql` maps to SQL NULL.
+        if (!UPDATABLE_COLUMNS[column] || value === undefined) continue;
         assignments.push(`${column} = ?`);
         values.push(toSql(value));
       }
@@ -1986,6 +2114,9 @@ export function openStore(dbPath: string): Store {
     recentRuns(project: string, mergedSinceEpochMs: number): RunRecord[] {
       return selectRecentRuns.all(project, mergedSinceEpochMs).map(toRecord);
     },
+    runsForProjectPr(project: string, prUrl: string, mergedSinceEpochMs: number): RunRecord[] {
+      return selectRunsForPr.all(project, prUrl, mergedSinceEpochMs).map(toRecord);
+    },
     runsNeedingBaseCheck(project: string, limit = 20): RunRecord[] {
       return selectPendingBaseChecks.all(project, limit).map(toRecord);
     },
@@ -2041,6 +2172,9 @@ export function openStore(dbPath: string): Store {
       const row = selectLatestRun.get(project, issue);
       return row ? toRecord(row) : undefined;
     },
+    runsForIssue(project: string, issue: number): RunRecord[] {
+      return selectRunsForIssue.all(project, issue).map(toRecord);
+    },
 
     setTurnOverride(project: string, issue: number, maxTurns: number, setAt = Date.now()): void {
       setTurnOverrideTx(project, issue, maxTurns, setAt);
@@ -2066,11 +2200,6 @@ export function openStore(dbPath: string): Store {
       return selectTurnOverrideLedger.all(project, issue, issue, opts.limit ?? 50);
     },
 
-    attemptReports(project: string, issue: number): { attempt: number; report: string }[] {
-      return selectAttemptReports.all(project, issue);
-    },
-
-
     runsStartedSince(project: string, sinceEpochMs: number): number {
       return countStartedSince.get(project, sinceEpochMs)?.n ?? 0;
     },
@@ -2079,6 +2208,10 @@ export function openStore(dbPath: string): Store {
       return sumSpendSince.get(project, sinceEpochMs)?.total ?? 0;
     },
 
+    statsRuns(project: string, sinceEpochMs: number): RunRecord[] {
+      return selectStatsRuns.all(project, sinceEpochMs, project, sinceEpochMs).map(toRecord);
+    },
+
     wasNotified(key: string): boolean {
       return (countNotified.get(key)?.n ?? 0) > 0;
     },
@@ -2203,6 +2336,12 @@ export function openStore(dbPath: string): Store {
         ...(held?.oldestAt === null || held?.oldestAt === undefined
           ? {}
           : { heldNoticeOldestAt: held.oldestAt }),
+        ...(held?.digestOldestAt === null || held?.digestOldestAt === undefined
+          ? {}
+          : { digestHeldNoticeOldestAt: held.digestOldestAt }),
+        ...(held?.availabilityOldestAt === null || held?.availabilityOldestAt === undefined
+          ? {}
+          : { availabilityHeldNoticeOldestAt: held.availabilityOldestAt }),
       };
     },
 
@@ -2226,6 +2365,10 @@ export function openStore(dbPath: string): Store {
       return selectGhCalls.all(day);
     },
 
+    ghCallsBetween(sinceDay: string, untilDay: string): number {
+      return sumGhCallsBetween.get(sinceDay, untilDay)?.total ?? 0;
+    },
+
     pendingFriction(
       project: string,
       sinceEpochMs: number,
@@ -2375,6 +2518,31 @@ export function openStore(dbPath: string): Store {
         .map(toReport);
     },
 
+    /**
+     * One escalation handoff per event while the first has not landed (#347,
+     * #453). The notifications ledger cannot decide this — its rows are
+     * permanent, so an identical retry would be refused forever once the first
+     * occurrence was marked (#453). The question is instead "is the first
+     * handoff still owed?": an escalation report still in the outbox (the
+     * `openReports` pending/sending/failed set) for the same project, category
+     * and folded text, or a held notice of the same category and text that has
+     * not been digested yet. Once the report is delivered, or the notice
+     * digested, the identical text is a new occurrence, not a double-send.
+     * Material reports describe one ordinary outcome each time and never
+     * dedupe.
+     */
+    hasOpenEscalationHandoff(project: string, category: InterruptCategory, body: string): boolean {
+      const flat = body.replace(/\s+/g, " ").trim();
+      return (
+        selectOpenReports
+          .all(project)
+          .some((row) => row.kind === category && row.body.replace(/\s+/g, " ").trim() === flat) ||
+        selectUndigestedNotices
+          .all(project, DIGEST_BACKLOG_LIMIT)
+          .some((row) => row.category === category && row.detail.replace(/\s+/g, " ").trim() === flat)
+      );
+    },
+
     openReports(project: string): ReportRecord[] {
       return selectOpenReports.all(project).map(toReport);
     },
@@ -2421,6 +2589,11 @@ export function openStore(dbPath: string): Store {
       return selectOpenDecisions.all(project).map(toDecision);
     },
 
+    decision(id: string): DecisionRecord | undefined {
+      const row = selectDecision.get(id);
+      return row === null ? undefined : toDecision(row);
+    },
+
     resolveDecision(id: string, state: "answered" | "withdrawn", resolution: string, at: number): boolean {
       return resolveDecisionRow.run(state, resolution, at, id).changes > 0;
     },
@@ -2532,6 +2705,30 @@ export function openStore(dbPath: string): Store {
       return row === null ? undefined : row.createdAt;
     },
 
+    recordIntake(draft: IntakeDraft): IntakeItem {
+      const item: IntakeItem = {
+        id: newReportId(),
+        project: draft.project,
+        text: draft.text,
+        createdAt: draft.at,
+        state: "pending",
+      };
+      insertIntake.run(item.id, item.project, item.text, item.createdAt);
+      return item;
+    },
+
+    pendingIntake(project: string): IntakeItem[] {
+      return selectPendingIntake.all(project).map(toIntakeItem);
+    },
+
+    resolveIntake(id: string, state: "groomed" | "dismissed", issueUrl?: string): boolean {
+      const result =
+        state === "groomed"
+          ? groomIntake.run(issueUrl ?? null, Date.now(), id)
+          : dismissIntake.run(id);
+      return result.changes > 0;
+    },
+
     close(): void {
       db.close(false);
     },

package/src/tracker/github.ts

@@ -24,6 +24,7 @@
 import { credentialedEnv } from "../gitops.ts";
 import { parsePrDiff } from "../diff-flags.ts";
 import type {
+  IssueComment,
   IssueState,
   IssueSnapshot,
   MergedPrInfo,
@@ -136,7 +137,7 @@ export class GhError extends Error {
  * and closed, which is how bodies containing newlines, backticks or a leading
  * `-` reach `gh` without ever being interpolated into argv.
  */
-async function gh(argv: string[], stdin?: string): Promise<string> {
+export async function gh(argv: string[], stdin?: string): Promise<string> {
   const proc = Bun.spawn(["gh", ...argv], {
     // Always a closed stream: commands that do not read stdin see immediate
     // EOF instead of an open pipe nobody ends.
@@ -392,14 +393,33 @@ function checkVerdict(check: GhCheck): CheckVerdict {
  * Verify one `gh pr view --json state,isDraft,headRefOid,statusCheckRollup`
  * payload, optionally against a caller-observed head. A missing rollup is
  * pending rather than green because GitHub may not have created the checks yet.
+ *
+ * By default this answers the merge gate's question — "may this merge" — and a
+ * non-open PR is a refusal (`expected OPEN`), so a mutating verb never acts on
+ * a merged or closed PR. `opts.read` (the `conductor_pr_status` surface) asks
+ * a different question: *what is this PR's state*, and a merged or closed PR
+ * is reported as a fact rather than a failure — the merge gate paths never
+ * pass `read`, so the `expected OPEN` refusal stays exactly where it gates.
  */
-export function prVerificationFrom(raw: string, expectedHead?: string): PrVerification {
+export function prVerificationFrom(
+  raw: string,
+  expectedHead?: string,
+  opts?: { read?: boolean },
+): PrVerification {
   const pr = JSON.parse(raw) as GhPrVerification;
   if (typeof pr.headRefOid !== "string" || pr.headRefOid === "") {
     throw new Error("PR head is unavailable");
   }
   const headSha = pr.headRefOid;
   if (pr.state !== "OPEN") {
+    if (opts?.read === true) {
+      const stateName = pr.state?.toLowerCase() ?? "unknown";
+      return {
+        status: "failed",
+        reason: `PR is ${stateName}; checks are unavailable for a non-open PR`,
+        headSha,
+      };
+    }
     return { status: "failed", reason: `PR is ${pr.state ?? "unknown"}, expected OPEN`, headSha };
   }
   if (pr.isDraft !== false) {
@@ -741,6 +761,36 @@ export function readyIssuesFromRest(raw: string): ReadyIssue[] {
   return issues;
 }
 
+/**
+ * Parse the REST `/repos/{owner}/{repo}/issues/{n}/comments` body — already
+ * projected by jq to `[{author, body}]` — onto {@link IssueComment}.
+ *
+ * The REST endpoint answers chronological order (oldest first), so the array
+ * order is the order the brief renders. Nulls and unrecognizable payloads are
+ * tolerated the same way {@link readyIssuesFromRest} tolerates them: an empty
+ * answer means "no comments", and *only* a thrown read means "could not tell" —
+ * the caller distinguishes the two, because eliding them is the #517 failure.
+ */
+export function commentsFrom(raw: string): IssueComment[] {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw) as unknown;
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const comments: IssueComment[] = [];
+  for (const entry of parsed) {
+    if (entry === null || typeof entry !== "object") continue;
+    const row = entry as { readonly [key: string]: unknown };
+    const author = row["author"];
+    const body = row["body"];
+    if (typeof author !== "string" || typeof body !== "string") continue;
+    comments.push({ author, body });
+  }
+  return comments;
+}
+
 /** One cached page per request URL: the ETag GitHub answered, the raw JSON
  *  body it covered, and whether that page advertised a rel="next" successor.
  *  Module-level default so every makeTracker() in the process (board probe,
@@ -1084,6 +1134,22 @@ export function makeTracker(
       return pages.flatMap(readyIssuesFromRest);
     },
 
+    async listComments(issue: number): Promise<IssueComment[]> {
+      // REST, like `issueSnapshot` — deliberately not `gh issue view
+      // --comments`, whose renderer goes through the interactive pager and
+      // prints nothing on a non-TTY while still exiting 0 (the #517 failure).
+      // `gh api` output is never paged. One page: the brief truncates a huge
+      // thread with an explicit marker rather than paginating.
+      return commentsFrom(
+        await runGh([
+          "api",
+          `repos/${repo}/issues/${issue}/comments`,
+          "--jq",
+          "[.[] | {author: .user.login, body: .body}]",
+        ]),
+      );
+    },
+
     async addLabel(issue: number, label: string): Promise<void> {
       try {
         // REST POST is natively idempotent: re-adding a label the issue already
@@ -1275,7 +1341,11 @@ export function makeTracker(
       }
     },
 
-    async verifyPr(url: string, expectedHead?: string): Promise<PrVerification | undefined> {
+    async verifyPr(
+      url: string,
+      expectedHead?: string,
+      opts?: { read?: boolean },
+    ): Promise<PrVerification | undefined> {
       if (!PR_URL.test(url)) return undefined;
       try {
         const raw = await runGh([
@@ -1285,7 +1355,7 @@ export function makeTracker(
           "--json",
           "state,isDraft,headRefOid,statusCheckRollup",
         ]);
-        const verification = prVerificationFrom(raw, expectedHead);
+        const verification = prVerificationFrom(raw, expectedHead, opts);
         if (verification.status !== "failed") return verification;
 
         const detailsUrl = failedCheck(raw)?.detailsUrl;