@wjarka/cezarion 0.16.0 → 0.17.0

package/dist/server/forge/github.js

@@ -1,9 +1,15 @@
+import { defined } from '../../core/defined.js';
+import { activeWorkflowRunsArgs, parseActiveWorkflowRuns } from '../../ci-wait/github.js';
+import { exactLineIndex, nextLineIndex } from '../../contract/index.js';
+import { pullRequestKey } from '../../runs/pull-requests.js';
+import { matchesGithubPullRequest, mergedPullRequestObservations } from '../../merge-observations.js';
 import { randomUUID } from 'node:crypto';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { z } from 'zod';
-import { GITHUB_SEARCH_MAX, REFERENCE_STATUS_MAX } from '../../contract/index.js';
-import { fetchIssueProjects, fetchViewerLogin } from './github-filters.js';
+import { GITHUB_COMMENT_COUNTS_MAX, GITHUB_SEARCH_MAX, REFERENCE_STATUS_MAX } from '../../contract/index.js';
+import { fetchIssueProjects, fetchRepositoryProjects, fetchViewerLogin } from './github-filters.js';
+import { fetchGithubMergeRequirements } from './github-merge-requirements.js';
 import { autosaveCommit } from '../../git-worktree.js';
 /**
  * The GitHub forge driver — all `gh`-CLI logic in one place, moved here from
@@ -168,11 +174,14 @@ const ghPrViewSchema = z.object({
     number: z.number(),
     url: z.string(),
     state: z.string().default('OPEN'),
+    mergedAt: z.unknown().optional(),
     isDraft: z.boolean().default(false),
     statusCheckRollup: ghStatusCheckRollup,
 });
 const mergeCheckSchema = z.object({
-    name: z.string().default('Check'),
+    name: z.string().optional(),
+    context: z.string().optional(),
+    targetUrl: z.string().nullish(),
     state: z.string().nullish(),
     status: z.string().nullish(),
     conclusion: z.string().nullish(),
@@ -183,6 +192,7 @@ const mergePrSchema = z.object({
     title: z.string(),
     url: z.string(),
     state: z.string(),
+    mergedAt: z.unknown().optional(),
     isDraft: z.boolean().default(false),
     headRefName: z.string(),
     baseRefName: z.string(),
@@ -232,112 +242,183 @@ async function gh(repoRoot, args, timeout = 15_000, signal, context) {
     });
     return stdout;
 }
-/** GraphQL's max page size; pagination is capped at 10 pages/kind (1000 rows — the GUI's full
- *  background shot). Rows past the window keep `comments: 0`, which the UI reads as "no badge". */
-export const GH_COUNTS_MAX_PAGES = 10;
-const countsQuery = (root) => `
-query ($owner: String!, $name: String!, $endCursor: String) {
+/** `gh api graphql` argv. `-f` sends every value as a String, and GitHub rejects a String where
+ *  the query declares `Int!` ("Could not coerce value to Int", open-mercato/cezar#1366), so a
+ *  number goes through `-F`. A string never does: `-F` would read `@file` and coerce
+ *  `true`/numerals, which is not what an opaque cursor or a login means. */
+export function ghGraphqlArgs(query, variables = {}) {
+    const args = ['api', 'graphql', '-f', `query=${query}`];
+    for (const [key, value] of Object.entries(variables)) {
+        args.push(typeof value === 'number' ? '-F' : '-f', `${key}=${value}`);
+    }
+    return args;
+}
+/** `owner/name` → `{ owner, name }`, or null when the handle isn't a clean two-part slug. */
+export function parseOwnerName(nameWithOwner) {
+    const [owner, name, ...rest] = nameWithOwner.trim().split('/');
+    return owner && name && rest.length === 0 ? { owner, name } : null;
+}
+// Paged open lists defer comment counts; hydrate them through the counts route after paint.
+/** GitHub GraphQL rejects `first` above 100 (EXCESSIVE_PAGINATION); larger limits walk pages. */
+export const GH_GRAPHQL_PAGE_MAX = 100;
+// Labels up to 100, which is what `gh issue list --json labels` read before the GraphQL page.
+const LIST_NODE_FIELDS = 'number title author { login } createdAt url body labels(first: 100) { nodes { name color } }';
+const listQuery = (side) => `
+query ($owner: String!, $name: String!, $first: Int!, $after: String) {
   repository(owner: $owner, name: $name) {
-    ${root}(first: 100, after: $endCursor, states: OPEN,
-           orderBy: {field: CREATED_AT, direction: DESC}) {
-      nodes { number comments { totalCount } }
+    ${side}(first: $first, after: $after, states: OPEN, orderBy: {field: CREATED_AT, direction: DESC}) {
+      totalCount
       pageInfo { hasNextPage endCursor }
+      nodes { ${LIST_NODE_FIELDS} ${side === 'issues' ? 'assignees(first: 20) { nodes { login } }' : 'isDraft additions deletions'} }
     }
   }
 }`;
-const ghCountsPageSchema = z.object({
-    nodes: z.array(z.object({ number: z.number(), comments: z.object({ totalCount: z.number() }) })),
+/** A GraphQL connection (`{ nodes }`) read as the flat array `gh … --json` used to return. */
+const connectionOf = (item) => z.object({ nodes: z.array(item.nullable()).default([]) }).nullish()
+    .transform((connection) => (connection?.nodes ?? []).filter((node) => node != null));
+const ghListNodeSchema = z.object({
+    number: z.number(),
+    title: z.string(),
+    author: ghAuthor,
+    createdAt: z.string(),
+    url: z.string(),
+    body: z.string().nullish(),
+    labels: connectionOf(ghLabel),
+    assignees: connectionOf(z.object({ login: z.string() })),
+    isDraft: z.boolean().nullish(),
+    additions: z.number().nullish(),
+    deletions: z.number().nullish(),
+});
+const ghListConnectionSchema = z.object({
+    totalCount: z.number().int().nonnegative(),
     pageInfo: z.object({ hasNextPage: z.boolean(), endCursor: z.string().nullish() }),
+    nodes: z.array(ghListNodeSchema.nullable()),
 });
-/** Validate + flatten one gh GraphQL counts response into a `number → count` map plus the page
- *  cursor. Exported for unit tests (the zod boundary + shape). Throws on a malformed envelope. */
-export function parseCountsPage(out, root) {
+function parseListConnection(out, side) {
     const parsed = JSON.parse(out);
-    const page = ghCountsPageSchema.parse(parsed?.data?.repository?.[root]);
-    const counts = {};
-    for (const node of page.nodes)
-        counts[node.number] = node.comments.totalCount;
-    return { counts, hasNextPage: page.pageInfo.hasNextPage, endCursor: page.pageInfo.endCursor ?? null };
+    const message = parsed.errors?.map((e) => e.message).filter(Boolean).join(' ');
+    if (message)
+        throw new Error(message);
+    if (!parsed.data?.repository)
+        throw new Error('GitHub did not resolve this repository');
+    return ghListConnectionSchema.parse(parsed.data.repository[side]);
 }
-async function paginateCounts(runGraphql, owner, name, root, maxPages) {
-    const counts = {};
-    let cursor = null;
-    for (let page = 0; page < maxPages; page++) {
-        const variables = { owner, name };
-        if (cursor)
-            variables.endCursor = cursor;
-        const res = parseCountsPage(await runGraphql(countsQuery(root), variables), root);
-        Object.assign(counts, res.counts);
-        if (!res.hasNextPage || !res.endCursor)
-            break;
-        cursor = res.endCursor;
-    }
-    return counts;
-}
-/** Comment counts for open issues and PRs as `number → count` maps. Two independent paginated
- *  queries (issues and PRs need separate cursors) run in parallel; any failure degrades the whole
- *  thing to empty maps so the tab is never held up by counts. Exported for unit tests. */
-export async function fetchCommentCounts(runGraphql, owner, name, maxPages = GH_COUNTS_MAX_PAGES) {
-    try {
-        const [issues, prs] = await Promise.all([
-            paginateCounts(runGraphql, owner, name, 'issues', maxPages),
-            paginateCounts(runGraphql, owner, name, 'pullRequests', maxPages),
-        ]);
-        return { issues, prs };
-    }
-    catch {
-        return { issues: {}, prs: {} };
+/**
+ * One side of the open list: up to `limit` rows from `cursor`, in requests of at most
+ * `GH_GRAPHQL_PAGE_MAX`. `nextCursor` is where the rows stop, or `null` once the side is
+ * exhausted. `done` asks for `first: 0`, which still answers `totalCount`, so an exhausted side
+ * keeps a fresh total without ever restarting from its first page (open-mercato/cezar#1366
+ * restarted it while the other side paged).
+ */
+export async function fetchListConnection(run, owner, name, side, limit, cursor, done = false) {
+    const query = listQuery(side);
+    if (done) {
+        const page = parseListConnection(await run(query, { owner, name, first: 0 }), side);
+        return { totalCount: page.totalCount, nodes: [], nextCursor: null };
+    }
+    const nodes = [];
+    let after = cursor;
+    for (;;) {
+        const first = Math.min(GH_GRAPHQL_PAGE_MAX, limit - nodes.length);
+        const page = parseListConnection(await run(query, { owner, name, first, ...(after ? { after } : {}) }), side);
+        const rows = page.nodes.filter((node) => node !== null);
+        nodes.push(...rows);
+        const next = page.pageInfo.hasNextPage ? page.pageInfo.endCursor ?? null : null;
+        // An empty page that claims more would loop forever; read it as the end of the side.
+        if (next === null || rows.length === 0)
+            return { totalCount: page.totalCount, nodes, nextCursor: null };
+        if (next === after)
+            throw new Error('GitHub list cursor did not advance');
+        // A short page with more behind it still ends this request: the cursor resumes it exactly.
+        if (nodes.length >= limit || rows.length < first)
+            return { totalCount: page.totalCount, nodes, nextCursor: next };
+        after = next;
     }
 }
-/** `owner/name` → `{ owner, name }`, or null when the handle isn't a clean two-part slug. */
-export function parseOwnerName(nameWithOwner) {
-    const [owner, name, ...rest] = nameWithOwner.trim().split('/');
-    return owner && name && rest.length === 0 ? { owner, name } : null;
-}
 /* Reads degrade to `available: false` with a hint — never an error (plan rule
    7): no `gh`, no remote, offline all land on the same quiet path. A short
    cache keeps tab switches from hammering the GitHub API; a cached fetch with
    a bigger limit than asked serves fine (it's a superset). Keyed by repository/host/account context
-   (multi-project workspace, step 2.6): one project's — possibly private —
-   issues/PRs must never be served under another project's scope. Bounded like
-   `commentsCache` so an unbounded workspace can't grow it without limit. */
+   (multi-project workspace, step 2.6) plus the page asked for: one project's — possibly private —
+   issues/PRs must never be served under another project's scope, and page 2 is never page 1.
+   Bounded like `commentsCache` so an unbounded workspace can't grow it without limit. */
 let listRequestOrder = 0;
+/** Per context, the order of the newest page-1 refresh. A refresh drops the context's later
+ *  pages (their cursors were cut from the old first page), and a later page that started before
+ *  it may answer its caller but never re-enters the cache. Bounded with `listCache`. */
+const listRefreshOrder = new Map();
 const listCache = new Map();
 const LIST_CACHE_MAX = 50;
 const CACHE_MS = 60_000;
+/** Which page key holds a projects generation, so `fetchGithubProjects` never scans the cache.
+ *  Installed and evicted in step with `listCache`, so it shares its bound. */
+const projectGenerations = new Map();
+/** Board discovery (the `projectsV2` walk) per context: page 2 pays for membership only. A
+ *  failed discovery is dropped, so the next page or refresh asks again. */
+const repositoryProjectsCache = new Map();
+function dropListEntry(key) {
+    const generation = listCache.get(key)?.data.projectsGeneration;
+    if (generation && projectGenerations.get(generation) === key)
+        projectGenerations.delete(generation);
+    listCache.delete(key);
+}
+function discoverRepositoryProjects(contextKey, refresh, start) {
+    const hit = repositoryProjectsCache.get(contextKey);
+    if (!refresh && hit && Date.now() - hit.at < CACHE_MS)
+        return hit.projects;
+    const projects = start();
+    const entry = { at: Date.now(), projects };
+    repositoryProjectsCache.delete(contextKey);
+    repositoryProjectsCache.set(contextKey, entry);
+    projects.catch(() => {
+        if (repositoryProjectsCache.get(contextKey) === entry)
+            repositoryProjectsCache.delete(contextKey);
+    });
+    while (repositoryProjectsCache.size > LIST_CACHE_MAX) {
+        const oldest = repositoryProjectsCache.keys().next().value;
+        if (oldest === undefined)
+            break;
+        repositoryProjectsCache.delete(oldest);
+    }
+    return projects;
+}
 export const GH_MAX_LIMIT = 1000;
-export async function fetchGithub(repoRoot, refresh = false, limit = 30) {
+function listPageKey(contextKey, page) {
+    return JSON.stringify([contextKey, page.issuesCursor ?? null, page.prsCursor ?? null, !!page.issuesDone, !!page.prsDone]);
+}
+export async function fetchGithub(repoRoot, refresh = false, limit = 30, page = {}) {
     if (process.env.CEZ_DRY_RUN === '1')
-        return mockGithub();
+        return mockGithubPage(limit, page);
     const context = githubContext(repoRoot);
     const capped = Math.min(Math.max(limit, 1), GH_MAX_LIMIT);
-    const hit = listCache.get(context.key);
+    const key = listPageKey(context.key, page);
+    const hit = listCache.get(key);
     if (!refresh && hit && Date.now() - hit.at < CACHE_MS && hit.limit >= capped) {
         return hit.data;
     }
     const order = ++listRequestOrder;
+    if (refresh && !page.issuesCursor && !page.prsCursor && !page.issuesDone && !page.prsDone) {
+        listRefreshOrder.delete(context.key);
+        listRefreshOrder.set(context.key, order);
+        while (listRefreshOrder.size > LIST_CACHE_MAX) {
+            const oldest = listRefreshOrder.keys().next().value;
+            if (oldest === undefined)
+                break;
+            listRefreshOrder.delete(oldest);
+        }
+        for (const [cached, entry] of [...listCache]) {
+            if (entry.contextKey === context.key && cached !== key)
+                dropListEntry(cached);
+        }
+    }
     try {
-        // No `comments` field — `gh … --json comments` ships full comment bodies.
-        // No `statusCheckRollup` either (#664): the CI rollup for every open PR was the
-        // dominant cost — it forced the 60 s budget below — and is now hydrated lazily per
-        // on-screen PR row via `fetchGithubChecks`. A big list still gets a little more wall
-        // clock than the default 30, but nothing like the old rollup walk.
+        // No `statusCheckRollup` (#664): it is hydrated lazily per on-screen PR row via
+        // `fetchGithubChecks`. A big aggregate list still gets a little more wall clock.
         const timeout = capped > 100 ? 30_000 : 15_000;
-        const fields = 'number,title,author,createdAt,labels,body,url';
-        // The repo handle first (cheap) so the counts GraphQL query — which needs owner/name —
-        // can run parallel to the two expensive list calls below.
         const ownerName = await resolveRepoHandleStrict(repoRoot, context);
-        const runGraphql = (query, variables) => {
-            const args = ['api', 'graphql', '-f', `query=${query}`];
-            for (const [key, value] of Object.entries(variables))
-                args.push('-f', `${key}=${value}`);
-            return gh(repoRoot, args, timeout, undefined, context);
-        };
-        // Bound the counts pagination to the rows actually being fetched: a page is 100, so
-        // `ceil(capped / 100)` pages (still capped at GH_COUNTS_MAX_PAGES) cover exactly the visible
-        // window and no more — the default 30-item load pays ONE counts round-trip, not ten. Rows
-        // beyond the window keep `comments: 0`, which the UI reads as "no badge" (same as before).
-        const countsMaxPages = Math.min(GH_COUNTS_MAX_PAGES, Math.max(1, Math.ceil(capped / 100)));
+        if (!ownerName)
+            return { available: false, reason: 'Could not resolve this repository on GitHub.', issues: [], prs: [] };
+        const runGraphql = (query, variables) => gh(repoRoot, ghGraphqlArgs(query, variables), timeout, undefined, context);
         // Optional project queries have one shared wall-clock budget. A missing scope, a cap,
         // or malformed metadata must never turn an otherwise working list into unavailable.
         const deadline = Date.now() + 15_000;
@@ -345,24 +426,18 @@ export async function fetchGithub(repoRoot, refresh = false, limit = 30) {
             const remaining = deadline - Date.now();
             if (remaining <= 0)
                 return Promise.reject(new Error('Project lookup timed out'));
-            const args = ['api', 'graphql', '-f', `query=${query}`];
-            for (const [key, value] of Object.entries(variables))
-                args.push('-f', `${key}=${value}`);
-            return gh(repoRoot, args, Math.min(remaining, 8_000), undefined, context);
+            return gh(repoRoot, ghGraphqlArgs(query, variables), Math.min(remaining, 8_000), undefined, context);
         };
-        const issueList = gh(repoRoot, ['issue', 'list', '--limit', String(capped), '--json', `${fields},assignees`], timeout, undefined, context);
-        const projectLookup = ownerName
-            ? fetchIssueProjects(projectGraphql, ownerName.owner, ownerName.name, async () => z.array(ghIssueSchema).parse(JSON.parse(await issueList)).map(i => i.number))
-            : Promise.resolve({ projectsReason: 'Project boards unavailable for this repository.' });
-        const [issuesOut, prsOut, counts, viewerLogin] = await Promise.all([
-            issueList,
-            gh(repoRoot, ['pr', 'list', '--limit', String(capped), '--json', `${fields},isDraft,additions,deletions`], timeout, undefined, context),
-            // Real comment counts (#499). Degrades to empty maps on its own — a failure here leaves
-            // every count at 0, never fails the tab. Skipped entirely if the handle isn't parseable.
-            ownerName
-                ? fetchCommentCounts(runGraphql, ownerName.owner, ownerName.name, countsMaxPages)
-                : Promise.resolve({ issues: {}, prs: {} }),
-            fetchViewerLogin((query) => gh(repoRoot, ['api', 'graphql', '-f', `query=${query}`], 8_000, undefined, context)),
+        const firstPage = !page.issuesCursor && !page.prsCursor && !page.issuesDone && !page.prsDone;
+        const issueSide = fetchListConnection(runGraphql, ownerName.owner, ownerName.name, 'issues', capped, page.issuesCursor, page.issuesDone);
+        const projectLookup = fetchIssueProjects(projectGraphql, ownerName.owner, ownerName.name, async () => (await issueSide).nodes.map((node) => node.number), () => discoverRepositoryProjects(context.key, refresh, () => fetchRepositoryProjects(projectGraphql, ownerName.owner, ownerName.name)));
+        const [issuesPage, prsPage, viewerLogin] = await Promise.all([
+            issueSide,
+            fetchListConnection(runGraphql, ownerName.owner, ownerName.name, 'pullRequests', capped, page.prsCursor, page.prsDone),
+            // The viewer is the same on every page; only the first one asks.
+            firstPage
+                ? fetchViewerLogin((query) => gh(repoRoot, ghGraphqlArgs(query), 8_000, undefined, context))
+                : Promise.resolve(undefined),
         ]);
         // One repo-wide label→color map, filled as we flatten each item's labels.
         const labelColors = {};
@@ -370,7 +445,7 @@ export async function fetchGithub(repoRoot, refresh = false, limit = 30) {
             if (l.color && !labelColors[l.name])
                 labelColors[l.name] = l.color;
         };
-        const issues = z.array(ghIssueSchema).parse(JSON.parse(issuesOut)).map((i) => {
+        const issues = issuesPage.nodes.map((i) => {
             i.labels.forEach(recordColor);
             return {
                 kind: 'issue',
@@ -381,32 +456,33 @@ export async function fetchGithub(repoRoot, refresh = false, limit = 30) {
                 labels: i.labels.map((l) => l.name),
                 body: (i.body ?? '').slice(0, 8_000),
                 url: i.url,
-                comments: counts.issues[i.number] ?? 0,
+                comments: 0,
                 assignees: i.assignees.map(a => a.login),
             };
         });
-        const prs = z.array(ghPrSchema).parse(JSON.parse(prsOut)).map((p) => {
+        const prs = prsPage.nodes.map((p) => {
             p.labels.forEach(recordColor);
+            const isDraft = p.isDraft ?? false;
             return {
                 kind: 'pr',
                 number: p.number,
                 title: p.title,
                 author: p.author?.login ?? '?',
                 createdAt: p.createdAt,
-                labels: [...p.labels.map((l) => l.name), ...(p.isDraft ? ['draft'] : [])],
+                labels: [...p.labels.map((l) => l.name), ...(isDraft ? ['draft'] : [])],
                 body: (p.body ?? '').slice(0, 8_000),
                 url: p.url,
-                comments: counts.prs[p.number] ?? 0,
-                isDraft: p.isDraft,
-                additions: p.additions,
-                deletions: p.deletions,
+                comments: 0,
+                isDraft,
+                additions: p.additions ?? 0,
+                deletions: p.deletions ?? 0,
                 // Hydrated lazily by `fetchGithubChecks` for on-screen rows (#664) — the list no
                 // longer pays for the CI rollup of every open PR.
                 checks: null,
             };
         });
         // Only verified values from the same repository may survive a refresh.
-        const previous = ownerName && hit?.data.repo === `${ownerName.owner}/${ownerName.name}` ? hit.data : undefined;
+        const previous = hit?.data.repo === `${ownerName.owner}/${ownerName.name}` ? hit.data : undefined;
         for (const issue of issues) {
             const known = previous?.issues.find(row => row.number === issue.number)?.projectIds;
             if (known !== undefined)
@@ -415,7 +491,7 @@ export async function fetchGithub(repoRoot, refresh = false, limit = 30) {
         const generation = randomUUID();
         const data = {
             available: true,
-            ...(ownerName ? { repo: `${ownerName.owner}/${ownerName.name}` } : {}),
+            repo: `${ownerName.owner}/${ownerName.name}`,
             syncedAt: new Date().toISOString(),
             issues,
             prs,
@@ -424,12 +500,17 @@ export async function fetchGithub(repoRoot, refresh = false, limit = 30) {
             projectsState: 'refreshing',
             projectsGeneration: generation,
             ...(previous?.projects ? { projects: previous.projects } : {}),
+            issuesTotal: issuesPage.totalCount,
+            prsTotal: prsPage.totalCount,
+            issuesNextCursor: issuesPage.nextCursor,
+            prsNextCursor: prsPage.nextCursor,
+            commentsDeferred: true,
         };
         const projects = projectLookup.then((result) => {
             const metadata = 'membership' in result
                 ? { generation, state: 'ready', projects: result.projects, membership: result.membership }
                 : { generation, state: 'unavailable', reason: result.projectsReason };
-            const current = listCache.get(context.key);
+            const current = listCache.get(key);
             if (current?.data.projectsGeneration === generation) {
                 current.data = {
                     ...current.data,
@@ -444,30 +525,50 @@ export async function fetchGithub(repoRoot, refresh = false, limit = 30) {
         });
         // Concurrent refreshes may finish in reverse order. An older list must not evict
         // the newer generation (and invalidate the newer client's metadata follow-up).
-        if ((listCache.get(context.key)?.order ?? -1) < order) {
-            listCache.delete(context.key); // re-insert so this key becomes the newest
-            listCache.set(context.key, { order, at: Date.now(), limit: capped, data, projects });
+        if ((listCache.get(key)?.order ?? -1) < order && order >= (listRefreshOrder.get(context.key) ?? 0)) {
+            dropListEntry(key); // re-insert so this key becomes the newest
+            listCache.set(key, { contextKey: context.key, order, at: Date.now(), limit: capped, data, projects });
+            projectGenerations.set(generation, key);
         }
         while (listCache.size > LIST_CACHE_MAX) {
             const oldest = listCache.keys().next().value;
             if (oldest === undefined)
                 break;
-            listCache.delete(oldest);
+            dropListEntry(oldest);
         }
         return data;
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const reason = /ENOENT/.test(message)
-            ? 'gh CLI not found — install it and run `gh auth login`'
-            : firstLine(message);
-        return { available: false, reason, issues: [], prs: [] };
-    }
+        return { available: false, reason: ghFailureReason(err), issues: [], prs: [] };
+    }
+}
+/** A `gh` failure as one readable line. GitHub's own words come on stderr; the Node message
+ *  starts with the whole argv, and a GraphQL argv is a multi-line query, so its first line is
+ *  a fragment of that query rather than the reason (open-mercato/cezar#1366). */
+export function ghFailureReason(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/ENOENT/.test(message))
+        return 'gh CLI not found — install it and run `gh auth login`';
+    const failure = (err ?? {});
+    const stderr = typeof failure.stderr === 'string' ? failure.stderr : '';
+    if (stderr.trim()) {
+        const lines = stderr.split('\n').map((line) => line.trim()).filter(Boolean);
+        return lines.find((line) => !/^Command failed:/i.test(line)) ?? lines[0];
+    }
+    if (failure.killed === true || typeof failure.signal === 'string')
+        return 'GitHub did not answer in time. Refresh to try again.';
+    // Without stderr, everything after "Command failed:" is the argv, which is query text.
+    if (/^Command failed:/i.test(message))
+        return 'GitHub request failed. Refresh to try again.';
+    return message.split('\n').map((line) => line.trim()).find(Boolean) ?? 'gh failed';
 }
 /** Bounded lookup already started by the list. Never launch work for an expired generation. */
 export async function fetchGithubProjects(repoRoot, generation) {
-    const entry = listCache.get(githubContext(repoRoot).key);
-    if (!entry || entry.data.projectsGeneration !== generation) {
+    const key = projectGenerations.get(generation);
+    const entry = key === undefined ? undefined : listCache.get(key);
+    // A generation from another repository, host or account never resolves here, even when
+    // its UUID is known: the context is part of what the generation was issued for.
+    if (!entry || entry.contextKey !== githubContext(repoRoot).key || entry.data.projectsGeneration !== generation) {
         return { generation, state: 'unavailable', reason: 'Project metadata expired. Refresh to try again.' };
     }
     return entry.projects;
@@ -475,14 +576,7 @@ export async function fetchGithubProjects(repoRoot, generation) {
 function firstLine(s) {
     return s.split('\n').find((l) => l.trim().length > 0)?.trim() ?? 'gh failed';
 }
-// ---- search across states (#730) -------------------------------------------
-// `fetchGithub` above lists the OPEN set only (`gh issue/pr list` defaults to `--state open`),
-// and the tab's search is an in-memory filter over exactly that payload — so a closed or merged
-// item is not "past the window", it was never fetched at all and no amount of scrolling reaches
-// it. This tier asks GitHub instead of re-filtering what we already hold. It is deliberately a
-// SECOND, on-demand path rather than widening the list to `--state all`: the list is the tab's
-// hot path, and making every load pay for hundreds of closed rows to serve an occasional lookup
-// would trade a search bug for a performance one.
+// On-demand cross-state search stays separate from the hot open list.
 /** Hits per search. `gh search`'s own default is 30; 50 matches the page size the incremental-
  *  loading spec settled on and keeps one search to a single `gh` round-trip. */
 export const GH_SEARCH_MAX = GITHUB_SEARCH_MAX;
@@ -513,6 +607,8 @@ const ghSearchHitSchema = ghIssueSchema.extend({
 /** `gh {issue,pr} view <n> --json …` — the exact-number path. Shares `ghIssueSchema`'s core;
  *  `isDraft`/`additions`/`deletions` are PR-only and default harmlessly for issues. */
 const ghViewHitSchema = ghIssueSchema.extend({
+    state: z.string().optional(),
+    mergedAt: z.unknown().optional(),
     assignees: z.array(z.object({ login: z.string() })).optional(),
     isDraft: z.boolean().default(false),
     additions: z.number().default(0),
@@ -565,9 +661,15 @@ async function viewGithubHit(repoRoot, kind, number) {
             'view',
             String(number),
             '--json',
-            kind === 'pr' ? `${SEARCH_FIELDS},isDraft,additions,deletions` : `${SEARCH_FIELDS},assignees`,
+            kind === 'pr' ? `${SEARCH_FIELDS},isDraft,additions,deletions,state,mergedAt` : `${SEARCH_FIELDS},assignees`,
         ]);
-        return ghViewHitSchema.parse(JSON.parse(out));
+        const hit = ghViewHitSchema.parse(JSON.parse(out));
+        if (kind === 'pr' && hit.state === 'MERGED') {
+            const handle = await resolveRepoHandle(repoRoot);
+            if (handle)
+                mergedPullRequestObservations.observe({ owner: handle.owner, repo: handle.name, number }, hit);
+        }
+        return hit;
     }
     catch (err) {
         if (MISSING_ITEM_RE.test(err instanceof Error ? err.message : String(err)))
@@ -591,22 +693,8 @@ export async function viewGithubItem(repoRoot, kind, number, labelColors = {}) {
     return hit ? finishViewHit(repoRoot, kind, number, hit, labelColors) : null;
 }
 /**
- * Find issues/PRs in ANY state (#730).
- *
- * Two query shapes, because they want different GitHub calls:
- *  - **A bare number** (`4507`, `#4507`) is a lookup, not a search: `gh {pr,issue} view <n>` is
- *    one cheap, state-agnostic call that finds a PR merged two years ago as readily as one opened
- *    today. GitHub's search index cannot be relied on to surface an exact number at all.
- *  - **Anything else** is a text search: `gh search {prs,issues} <query> --repo owner/name`, with
- *    `--state` deliberately OMITTED — the flag only accepts `open|closed`, and leaving it off is
- *    what searches every state.
- *
- * A numeric query that resolves to nothing (wrong repo, deleted, or simply a number the user meant
- * as text) falls through to the text path rather than reporting "not found" — `4507` should still
- * find a PR whose title contains it.
- *
- * Never throws: every failure lands on `{available: false, reason}`, the same quiet degrade the
- * rest of the tab uses. Exported for unit tests.
+ * Search any state: exact numbers try a direct lookup, then text fallback; text search omits
+ * state restriction. Return availability and a reason on failure instead of throwing.
  */
 export async function searchGithubItems(repoRoot, kind, query, limit = GH_SEARCH_MAX) {
     const trimmed = query.trim();
@@ -721,9 +809,7 @@ async function hydrateSearchProjects(repoRoot, kind, data) {
         const remaining = deadline - Date.now();
         if (remaining <= 0)
             return Promise.reject(new Error('Project lookup timed out'));
-        const args = ['api', 'graphql', '-f', `query=${query}`];
-        for (const [key, value] of Object.entries(variables))
-            args.push('-f', `${key}=${value}`);
+        const args = ghGraphqlArgs(query, variables);
         return gh(repoRoot, args, Math.min(remaining, 8_000));
     };
     const projects = await fetchIssueProjects(run, handle.owner, handle.name, data.items.map(item => item.number));
@@ -731,6 +817,32 @@ async function hydrateSearchProjects(repoRoot, kind, data) {
         return { ...data, projectsReason: projects.projectsReason };
     return { ...data, items: data.items.map(item => ({ ...item, projectIds: projects.membership[item.number] ?? [] })) };
 }
+/** The dry-run catalog, paged like the real list: numeric offset cursors per side, done flags
+ *  honored, exact totals, and counts deferred to the counts route (hearsay-tools/cezarion#1183). */
+function mockGithubPage(limit, page) {
+    const full = mockGithub();
+    const side = (rows, cursor, done) => {
+        const start = done ? rows.length : Number(cursor ?? 0);
+        const slice = rows.slice(start, start + Math.max(limit, 1));
+        const end = start + slice.length;
+        return { rows: slice.map((row) => ({ ...row, comments: 0 })), next: end < rows.length ? String(end) : null };
+    };
+    const issues = side(full.issues, page.issuesCursor, page.issuesDone);
+    const prs = side(full.prs, page.prsCursor, page.prsDone);
+    const firstPage = !page.issuesCursor && !page.prsCursor && !page.issuesDone && !page.prsDone;
+    const { viewerLogin, ...rest } = full;
+    return {
+        ...rest,
+        ...(firstPage && viewerLogin ? { viewerLogin } : {}),
+        issues: issues.rows,
+        prs: prs.rows,
+        issuesTotal: full.issues.length,
+        prsTotal: full.prs.length,
+        issuesNextCursor: issues.next,
+        prsNextCursor: prs.next,
+        commentsDeferred: true,
+    };
+}
 /** CEZ_DRY_RUN=1 — a small fixed catalog so the GitHub tab is demoable offline. */
 function mockGithub() {
     const mk = (over) => ({
@@ -879,7 +991,7 @@ export const THREAD_ENTRY_CAP = 200;
 const COMMENT_BODY_CAP = 8_000;
 /** `gh api …/issues/{n}/comments` JSON → `ForgeComment[]`. Exported for unit tests. */
 export function normalizeComments(raw) {
-    return z.array(ghIssueCommentSchema).parse(raw).map((c) => ({
+    return z.array(ghIssueCommentSchema).parse(raw).map((c) => defined({
         id: c.id,
         author: c.user?.login ?? '?',
         avatarUrl: c.user?.avatar_url ?? undefined,
@@ -901,7 +1013,7 @@ export function normalizeReviews(raw) {
         const emptyBody = (r.body ?? '').trim().length === 0;
         return !(emptyBody && (state === 'COMMENTED' || state === 'PENDING'));
     })
-        .map((r) => ({
+        .map((r) => defined({
         id: r.id,
         author: r.user?.login ?? '?',
         avatarUrl: r.user?.avatar_url ?? undefined,
@@ -1367,6 +1479,101 @@ export async function fetchPrChecks(runGraphql, owner, name, numbers, chunkSize
     }
     return out;
 }
+const itemDetailSchema = z.object({
+    body: z.string().nullish(),
+    additions: z.number().int().nonnegative().optional(),
+    deletions: z.number().int().nonnegative().optional(),
+});
+/** One item's body (and a PR's diffstat), or `undefined` on any failure. */
+async function fetchItemDetail(repoRoot, kind, number) {
+    try {
+        const out = await gh(repoRoot, [kind, 'view', String(number), '--json', kind === 'pr' ? 'body,additions,deletions' : 'body']);
+        const parsed = itemDetailSchema.parse(JSON.parse(out));
+        return {
+            body: (parsed.body ?? '').slice(0, COMMENT_BODY_CAP),
+            ...(kind === 'pr' && parsed.additions !== undefined ? { additions: parsed.additions } : {}),
+            ...(kind === 'pr' && parsed.deletions !== undefined ? { deletions: parsed.deletions } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+// Per-item comment counts (hearsay-tools/cezarion#1183): the list defers them, and the cockpit
+// asks for its loaded rows after paint. Keyed `context␀kind␀number`, same TTL and bound as checks.
+const commentCountsCache = new Map();
+const commentCountsSchema = z.object({
+    data: z.object({
+        repository: z.record(z.string(), z.object({ comments: z.object({ totalCount: z.number().int().nonnegative() }) }).nullable()),
+    }),
+});
+/**
+ * Comment counts for the given issue or PR numbers, in one aliased GraphQL query. A number GitHub
+ * does not know is absent (unknown), never 0. Degrades to `{ available: false, reason }` — never a
+ * throw. Numbers are de-duplicated, validated and capped at `GITHUB_COMMENT_COUNTS_MAX`.
+ */
+export async function fetchGithubCommentCounts(repoRoot, kind, numbers, refresh = false) {
+    if (process.env.CEZ_DRY_RUN === '1')
+        return mockGithubCommentCounts(kind, numbers);
+    const context = githubContext(repoRoot);
+    const wanted = [...new Set(numbers)].filter((n) => Number.isSafeInteger(n) && n > 0).slice(0, GITHUB_COMMENT_COUNTS_MAX);
+    const counts = {};
+    const misses = [];
+    const now = Date.now();
+    const keyOf = (n) => `${context.key}\0${kind}\0${n}`;
+    for (const n of wanted) {
+        const hit = commentCountsCache.get(keyOf(n));
+        if (!refresh && hit && now - hit.at < CACHE_MS)
+            counts[n] = hit.count;
+        else
+            misses.push(n);
+    }
+    if (misses.length === 0)
+        return { available: true, counts };
+    try {
+        const handle = await resolveRepoHandleStrict(repoRoot, context);
+        if (!handle)
+            return { available: false, reason: 'Could not resolve this repository on GitHub.' };
+        // Integers only in the aliases; owner and name travel as variables.
+        const fields = misses.map((n) => `n${n}: issueOrPullRequest(number: ${n}) {
+      ... on Issue { comments { totalCount } }
+      ... on PullRequest { comments { totalCount } }
+    }`).join('\n');
+        // A number GitHub does not know comes back NOT_FOUND and makes `gh` exit 1 with the rest of
+        // the batch on stdout; `refStatusGraphql` keeps that partial answer.
+        const raw = await refStatusGraphql(repoRoot, context)(`query($owner: String!, $name: String!) { repository(owner: $owner, name: $name) { ${fields} } }`, { owner: handle.owner, name: handle.name });
+        const rows = commentCountsSchema.parse(JSON.parse(raw)).data.repository;
+        for (const n of misses) {
+            const count = rows[`n${n}`]?.comments.totalCount;
+            if (count === undefined)
+                continue; // unknown number: absent, and asked again next time
+            counts[n] = count;
+            commentCountsCache.delete(keyOf(n));
+            commentCountsCache.set(keyOf(n), { at: now, count });
+        }
+        while (commentCountsCache.size > CHECKS_CACHE_MAX) {
+            const oldest = commentCountsCache.keys().next().value;
+            if (oldest === undefined)
+                break;
+            commentCountsCache.delete(oldest);
+        }
+        return { available: true, counts };
+    }
+    catch (err) {
+        return { available: false, reason: ghFailureReason(err) };
+    }
+}
+/** CEZ_DRY_RUN=1 — the catalog's own counts, so the offline list shows its badges. */
+function mockGithubCommentCounts(kind, numbers) {
+    const rows = kind === 'pr' ? mockGithub().prs : mockGithub().issues;
+    const counts = {};
+    for (const n of numbers) {
+        const row = rows.find((item) => item.number === n);
+        if (row)
+            counts[n] = row.comments;
+    }
+    return { available: true, counts };
+}
 // Per-PR checks cache: keyed `repoRoot␀number`, same 60 s TTL as the list cache but BOUNDED. Lets
 // a repeated visible-window hydration within a minute serve cached glyphs instead of re-querying.
 const checksCache = new Map();
@@ -1403,9 +1610,7 @@ export async function fetchGithubChecks(repoRoot, numbers) {
         if (!ownerName)
             return { available: false, reason: 'repository handle unavailable' };
         const runGraphql = (query, variables) => {
-            const args = ['api', 'graphql', '-f', `query=${query}`];
-            for (const [key, value] of Object.entries(variables))
-                args.push('-f', `${key}=${value}`);
+            const args = ghGraphqlArgs(query, variables);
             return gh(repoRoot, args);
         };
         const fetched = await fetchPrChecks(runGraphql, ownerName.owner, ownerName.name, misses);
@@ -1464,6 +1669,8 @@ function reviewerKey(ref) {
 const ghRefStatusPrSchema = z
     .object({
     state: z.string(),
+    url: z.unknown().optional(),
+    mergedAt: z.unknown().optional(),
     isDraft: z.boolean().nullish(),
     reviewDecision: z.string().nullish(),
     /** `MERGEABLE` | `CONFLICTING` | `UNKNOWN` — GitHub computes it in the background, so
@@ -1546,85 +1753,19 @@ const ghRefStatusIssueSchema = z.object({ state: z.string(), stateReason: z.stri
 // `commits` silently removed.
 const ghRefStatusSchema = z.record(z.string(), z.unknown());
 /**
- * One alias per NUMBER, asking `issueOrPullRequest` rather than `pullRequest`/`issue`.
- *
- * Issues and pull requests share one numbering space in a repository, so a number is exactly one
- * of the two and asking which is a question the forge can answer — where asking `issue(number:)`
- * about a pull request is a question with no answer, and GitHub says so with a NOT_FOUND *error*
- * rather than a null. That mattered far more than it looks: `gh api graphql` exits non-zero the
- * moment a response carries an `errors` array, so one mis-guessed kind used to fail the whole
- * batch and report every reference in it as "not found" (see `refStatusGraphql`).
- *
- * It also fixes the reference whose kind the cockpit guessed wrong — `taskReferences` infers it
- * from which field carried the number, and a bare `#774` can land in either — because the answer
- * carries `__typename` and is filed under what the number REALLY is.
- *
- * `committedDate`, the head commit's `parents.totalCount` (`first: 0` — the COUNT is the whole
- * question, so no parent is fetched) and the last CHANGES_REQUESTED review's `submittedAt` cost
- * nothing extra, riding the same node, and are what let the precedence tell a review the author has
- * already responded to from one still about the code on screen. The last `ReviewRequestedEvent` is
- * asked for the same reason: `reviewRequests` says only THAT someone is on the hook, never since
- * when, and the difference between a request made before the review and one made after it is the
- * difference between a reviewer who has not looked yet and an author who has answered.
- *
- * `mergeable` rides it too, and is the reason the batch can answer "this one conflicts" without
- * the per-PR probe `prMergeState` runs for the merge box. It is NOT folded into the status: see
- * `conflicts` in the contract for why the two stay separate axes.
+ * Query issueOrPullRequest once per number and use __typename for the actual kind. Include
+ * branch-work and review timestamps for freshness decisions.
  */
 function refStatusQuery(numbers) {
     const aliases = numbers
-        .map((n, i) => `    r${i}: issueOrPullRequest(number: ${n}) { __typename ... on PullRequest { state isDraft reviewDecision mergeable commits(last: 1) { nodes { commit { committedDate parents(first: 1) { totalCount nodes { committedDate } } statusCheckRollup { state } } } } reviews(last: 1, states: CHANGES_REQUESTED) { nodes { submittedAt } } reviewRequests(first: 20) { totalCount nodes { requestedReviewer { __typename ... on User { login } ... on Bot { login } ... on Team { slug } } } } timelineItems(last: 20, itemTypes: [REVIEW_REQUESTED_EVENT]) { nodes { ... on ReviewRequestedEvent { createdAt requestedReviewer { __typename ... on User { login } ... on Bot { login } ... on Team { slug } } } } } } ... on Issue { state stateReason } }`)
+        .map((n, i) => `    r${i}: issueOrPullRequest(number: ${n}) { __typename ... on PullRequest { url mergedAt state isDraft reviewDecision mergeable commits(last: 1) { nodes { commit { committedDate parents(first: 1) { totalCount nodes { committedDate } } statusCheckRollup { state } } } } reviews(last: 1, states: CHANGES_REQUESTED) { nodes { submittedAt } } reviewRequests(first: 20) { totalCount nodes { requestedReviewer { __typename ... on User { login } ... on Bot { login } ... on Team { slug } } } } timelineItems(last: 20, itemTypes: [REVIEW_REQUESTED_EVENT]) { nodes { ... on ReviewRequestedEvent { createdAt requestedReviewer { __typename ... on User { login } ... on Bot { login } ... on Team { slug } } } } } } ... on Issue { state stateReason } }`)
         .join('\n');
-    return `query ($owner: String!, $name: String!) {\n  repository(owner: $owner, name: $name) {\n${aliases}\n  }\n}`;
+    return `query ($owner: String!, $name: String!) {\n  repository(owner: $owner, name: $name) {\nnameWithOwner\n${aliases}\n  }\n}`;
 }
 /**
- * The one place a PR's signals collapse into a single word.
- *
- * The question the chip answers is "what is this waiting on RIGHT NOW", so the ranking is by
- * freshness of the signal, not by how heavy a blocker it is:
- *
- * Read the ranking as **whose move is it**, which is the question a table is scanned for:
- *
- *  1. `merged` / `closed` — nobody's. Terminal, whatever checks or reviews say.
- *  2. `draft` — the author's, and they have said so themselves.
- *  3. `checks-pending` — the machine's. CI running means a commit was JUST pushed, the newest
- *     thing that has happened to this PR, so it outranks a requested change unconditionally.
- *  4. `changes-requested` — the AUTHOR's, and only while that is still true: the review must be
- *     about the code that is there now, with no re-review already asked for.
- *  5. `checks-failing` — the author's again. A reviewer cannot approve a red PR anyway.
- *  6. `review-required` — the REVIEWER's: they have been asked, or the author has answered and
- *     the merge is now blocked on someone coming back to look.
- *  7. `ready` — open, not a draft, nothing failing, nothing running, nobody waited on.
- *
- * The subtle one is (4) → (6), and it is not a preference but a data finding. `reviewDecision`
- * stays `CHANGES_REQUESTED` after the author has responded — GitHub does not clear it until a
- * reviewer submits again — so on its own it points at the author forever. Two signals say the ball
- * has moved back:
- *
- *  - **a review request made AFTER the review**, which is the author clicking re-request.
- *    Authoritative, and observed live alongside a stale `CHANGES_REQUESTED` and an EMPTY
- *    `latestReviews` — the case that has no other tell.
- *  - **a non-merge commit newer than the review**, the fallback for an author who pushed without
- *    clicking anything. Merges are excluded because GitHub's "Update branch" button writes one,
- *    dated now, that answers nothing — the reflexive click on a stale PR must not clear a
- *    rejection.
- *
- * The "after" in the first one is load-bearing, and its absence was a reported bug. A request that
- * PREDATES the review is a reviewer who has not looked yet, and on a PR where several people were
- * asked and one of them rejected it the others stay listed forever — so a bare
- * `reviewRequests.totalCount > 0` reads a live "changes requested" as answered and hides it behind
- * "waiting for review" (observed live: three reviewers asked at 10:28, changes requested
- * the next day, one reviewer still pending).
- *
- * Either way the words change from "you owe edits" to "they owe a look", and so does the colour:
- * danger is the author's move, info is the reviewer's.
- *
- * Both timestamps are optional and their ABSENCE is conservative: with no dates to compare and no
- * re-request, a review counts as current, and the chip keeps pointing at the author.
- *
- * `reviewDecision` is null on a repo with no review policy, which is exactly why `ready` is not
- * spelled "approved": on such a repo a green PR IS ready, and no approval will ever arrive — but a
- * requested reviewer still moves it to `review-required`, because someone was explicitly asked.
+ * Derive whose action is pending: terminal, draft, pending checks, current requested changes,
+ * failing checks, review, then ready. Use dated review/work evidence; mergeability remains a
+ * separate axis.
  */
 export function derivePrReferenceStatus(pr) {
     const state = pr.state.toUpperCase();
@@ -1734,6 +1875,10 @@ export async function fetchRefStatuses(runGraphql, owner, name, numbers, chunkSi
                     const pr = ghRefStatusPrSchema.parse(node);
                     if (!pr)
                         return;
+                    if ((!raw.errors || (Array.isArray(raw.errors) && raw.errors.length === 0)) &&
+                        typeof repository.nameWithOwner === 'string' && repository.nameWithOwner.toLowerCase() === `${owner}/${name}`.toLowerCase()) {
+                        mergedPullRequestObservations.observe({ owner, repo: name, number }, { ...pr, number });
+                    }
                     const head = pr.commits?.nodes[0]?.commit;
                     const rollup = head?.statusCheckRollup;
                     const mergeability = mergeabilityOf(pr.state, pr.mergeable);
@@ -1805,19 +1950,8 @@ export function __seedRefStatusCacheForTests(repoRoot, entries) {
     }
 }
 /**
- * Forget what we knew about one reference, so the next read asks GitHub again.
- *
- * Called where cezar itself CHANGES a pull request — it merges one, it opens one — because those
- * are the only forge changes this process can know about without asking. Everything else has to
- * be polled (GitHub cannot push to a cockpit with no public endpoint), but waiting out a TTL to
- * notice our own merge is a self-inflicted staleness: for up to a minute every chip would keep
- * showing the pre-merge status of a pull request the user watched this server merge.
- *
- * Deleting rather than overwriting with a guessed `merged`: the forge is the authority on what a
- * reference is, and a mutation that reports success is still not the same as having read the
- * result. The next reader pays one query and gets the truth — after which the answer is `merged`,
- * `recheckAfterMs` goes null, and the cockpit stops polling that batch entirely. Invalidating here
- * therefore REDUCES long-run traffic rather than adding to it.
+ * Invalidate one reference after a known mutation. Let the next forge read establish status
+ * rather than caching a guessed result.
  */
 export function forgetRefStatus(repoRoot, number) {
     refStatusCache.delete(refStatusKey(repoRoot, number));
@@ -1848,7 +1982,7 @@ export function readCachedRefStatuses(repoRoot, numbers) {
     return out;
 }
 // The `#N` in a forge URL. Defined beside the run search matcher, which reads it too (#864).
-export { refNumberFromUrl } from '../../runs/run-search.js';
+export { refNumberFromUrl } from '../../contract/index.js';
 /** A closed issue or an abandoned PR can be REOPENED, so this is long rather than forever — but
  *  it is the rare event, and re-asking a hundred settled references every minute to catch it is
  *  the wrong trade. */
@@ -1929,28 +2063,12 @@ const MERGEABILITY_UNKNOWN_WINDOW_MS = 60_000;
  *  thing. Five minutes is the same order as the cockpit's own reconnect cadence. */
 const REF_STATUS_RETRY_MS = 5 * 60_000;
 /**
- * GraphQL through `gh`, tolerating a PARTIALLY failed response.
- *
- * `gh api graphql` exits non-zero whenever the reply carries an `errors` array — even when `data`
- * is fully populated for every alias that DID resolve. With one alias per reference that is not an
- * edge case, it is the normal case: a single number that no longer exists (or never did, having
- * been scraped from a transcript that named another repository) makes GitHub answer
- * `{data: {...everything else...}, errors: [NOT_FOUND]}` and `gh` exit 1.
- *
- * `execFile` rejects on a non-zero exit, so that used to throw away a whole batch's worth of
- * perfectly good statuses and report every reference in it as "not found" — including, in the bug
- * that produced this function, an open pull request in the project's own repository.
- *
- * So: a non-zero exit whose stdout still carries a usable `data.repository` is a partial success
- * and is used as-is. Anything else — no stdout, unparseable stdout, or a null `repository`, which
- * means the repo handle itself did not resolve — rethrows, so a real failure still degrades to
- * `{available: false}` instead of masquerading as "none of these exist".
+ * Use failed gh GraphQL stdout only when it contains usable data.repository. Preserve successful
+ * aliases in partial responses; rethrow malformed or unresolved-repository failures.
  */
 function refStatusGraphql(repoRoot, context = githubContext(repoRoot)) {
     return async (query, variables) => {
-        const args = ['api', 'graphql', '-f', `query=${query}`];
-        for (const [key, value] of Object.entries(variables))
-            args.push('-f', `${key}=${value}`);
+        const args = ghGraphqlArgs(query, variables);
         try {
             return await gh(repoRoot, args, 15_000, undefined, context);
         }
@@ -2170,7 +2288,7 @@ function mockGithubRefStatus(prs, issues) {
  */
 export async function fetchGithubComments(repoRoot, kind, number, refresh = false) {
     if (process.env.CEZ_DRY_RUN === '1')
-        return mockGithubComments(kind);
+        return mockGithubComments(kind, number);
     // NUL separator: cannot appear in a filesystem path, so roots can never alias.
     const key = `${repoRoot}\0${kind}#${number}`;
     const hit = commentsCache.get(key);
@@ -2178,6 +2296,10 @@ export async function fetchGithubComments(repoRoot, kind, number, refresh = fals
         return hit.data;
     // PR conversation comments live on the issues endpoint too — always use it for the body thread.
     const legacyComments = () => gh(repoRoot, ['api', `repos/{owner}/{repo}/issues/${number}/comments`, '--paginate']);
+    // The detail tier (hearsay-tools/cezarion#1183): the list no longer has to carry a body, so
+    // the pane asks for it here, in parallel with the thread. It is attached only to a thread
+    // that loaded, and a failed view never costs the thread.
+    const detail = fetchItemDetail(repoRoot, kind, number);
     try {
         let commentRows = [];
         let events;
@@ -2245,17 +2367,17 @@ export async function fetchGithubComments(repoRoot, kind, number, refresh = fals
             const handle = await resolveRepoHandle(repoRoot);
             if (handle) {
                 const runGraphql = (query, variables) => {
-                    const args = ['api', 'graphql', '-f', `query=${query}`];
-                    for (const [k, v] of Object.entries(variables))
-                        args.push('-f', `${k}=${v}`);
+                    const args = ghGraphqlArgs(query, variables);
                     return gh(repoRoot, args);
                 };
                 const checks = await fetchCommitChecks(runGraphql, handle.owner, handle.name, commitShas);
                 for (const event of events ?? []) {
                     if (event.kind !== 'committed' || !event.sha)
                         continue;
-                    if (event.sha in checks)
-                        event.checks = checks[event.sha];
+                    if (event.sha in checks) {
+                        delete event.checks;
+                        Object.assign(event, defined({ checks: checks[event.sha] }));
+                    }
                 }
             }
         }
@@ -2265,15 +2387,18 @@ export async function fetchGithubComments(repoRoot, kind, number, refresh = fals
             parts.push(normalizeReviews(JSON.parse(reviewsOut)));
         }
         const { comments, truncated } = mergeThread(parts);
-        const data = {
+        const data = defined({
             available: true,
             comments,
             // OR-folded exactly as before, so the pre-existing >200-comments trigger is preserved
             // rather than replaced.
             truncated: truncated || eventsTruncated || stoppedShort || undefined,
-        };
+        });
         if (events)
             data.events = events;
+        const itemDetail = await detail;
+        if (itemDetail)
+            data.detail = itemDetail;
         cacheComments(key, data);
         return data;
     }
@@ -2289,7 +2414,7 @@ export async function fetchGithubComments(repoRoot, kind, number, refresh = fals
 }
 /** CEZ_DRY_RUN=1 — a small fixed thread (one image-bearing comment, plus a review for PRs) so
  *  the whole feature is demoable and e2e-testable offline. */
-function mockGithubComments(kind) {
+function mockGithubComments(kind, number) {
     const base = Date.now() - 3_600_000;
     const at = (offset) => new Date(base + offset).toISOString();
     const comments = [
@@ -2396,7 +2521,14 @@ function mockGithubComments(kind) {
             createdAt: at(1_800_000),
         });
     }
-    return { available: true, comments, events };
+    // The detail tier (hearsay-tools/cezarion#1183): the catalog row's own body and diffstat.
+    const row = number === undefined ? undefined
+        : (kind === 'pr' ? mockGithub().prs : mockGithub().issues).find((item) => item.number === number);
+    const detail = row ? {
+        body: row.body ?? '',
+        ...(kind === 'pr' ? { additions: row.additions ?? 0, deletions: row.deletions ?? 0 } : {}),
+    } : undefined;
+    return { available: true, comments, events, ...(detail ? { detail } : {}) };
 }
 // ---- draft-PR creation (review gate, spec 009) ------------------------------
 // Final autosave-commit → `git push -u origin cez/<id8>` → `gh pr create
@@ -2470,23 +2602,20 @@ export async function createDraftPr(input) {
  */
 export function buildPrBody(handoffText, task) {
     const goal = section(handoffText, '## Goal') || task.trim();
-    const progress = section(handoffText, '## Progress log')
-        .split('\n')
-        .filter((l) => l.trim())
-        .slice(0, PROGRESS_LINES_MAX)
-        .join('\n');
+    const progress = section(handoffText, '## Progress log').split('\n').filter((l) => l.trim()).slice(0, PROGRESS_LINES_MAX).join('\n');
     const parts = ['## Goal', '', goal];
     if (progress)
         parts.push('', '## Progress log', '', progress);
     parts.push('', '---', '', '🤖 made with cezar');
     return parts.join('\n');
 }
-/** Text of one `## Header` section, up to the next `## ` header. */
+/** Text of one `## Header` section, up to the next `## ` header, with LF line endings. The header
+ *  is a whole line (hearsay-tools/cezarion#1147), so a Goal that quotes one is never taken for it. */
 function section(text, header) {
-    const start = text.indexOf(`${header}\n`);
+    const start = exactLineIndex(text, header);
     if (start < 0)
         return '';
-    const rest = text.slice(start + header.length + 1);
+    const rest = text.slice(nextLineIndex(text, start)).replaceAll('\r\n', '\n');
     const next = rest.indexOf('\n## ');
     return (next >= 0 ? rest.slice(0, next) : rest).trim();
 }
@@ -2616,21 +2745,32 @@ export function normalizeMergeState(raw, policyRaw, requirements = {
             ? 'changes-requested'
             : pr.reviewDecision?.toUpperCase() === 'REVIEW_REQUIRED'
                 ? 'review-required'
-                : 'unknown';
-    const checks = (pr.statusCheckRollup ?? []).map((check) => ({
-        name: check.name,
-        state: mergeCheckState(check),
-        required: requirements.readable ? requirements.requiredChecks.includes(check.name) : null,
-        ...(check.detailsUrl?.startsWith('https://') || check.detailsUrl?.startsWith('http://')
-            ? { url: check.detailsUrl }
-            : {}),
-    }));
+                : !pr.reviewDecision?.trim() && requirements.readable && requirements.requiredApprovingReviews === 0
+                    ? 'not-required'
+                    : 'unknown';
+    const checks = (pr.statusCheckRollup ?? []).map((check) => {
+        const name = check.name ?? check.context ?? 'Check';
+        const url = check.detailsUrl ?? check.targetUrl;
+        return {
+            name,
+            state: mergeCheckState(check),
+            required: requirements.readable ? requirements.requiredChecks.includes(name) : null,
+            ...(url?.startsWith('https://') || url?.startsWith('http://') ? { url } : {}),
+        };
+    });
+    if (requirements.readable) {
+        for (const name of requirements.requiredChecks) {
+            if (!checks.some((check) => check.name === name))
+                checks.push({ name, state: 'pending', required: true });
+        }
+    }
     const methods = [];
-    if (policy.allow_squash_merge)
+    const methodAllowed = (method) => requirements.allowedMergeMethods?.includes(method) ?? true;
+    if (policy.allow_squash_merge && methodAllowed('squash'))
         methods.push('squash');
-    if (policy.allow_merge_commit)
+    if (policy.allow_merge_commit && methodAllowed('merge'))
         methods.push('merge');
-    if (policy.allow_rebase_merge)
+    if (policy.allow_rebase_merge && methodAllowed('rebase'))
         methods.push('rebase');
     const defaultMethod = policy.squash_merge_commit_title && methods.includes('squash')
         ? 'squash'
@@ -2659,7 +2799,13 @@ export function normalizeMergeState(raw, policyRaw, requirements = {
         eligibility = 'blocked';
         blockers.push({ code: 'reviews', message: reviewDecision === 'changes-requested' ? 'Changes were requested.' : 'A required review is missing.' });
     }
-    else if (reviewDecision === 'unknown' || !requirements.readable) {
+    else if ((requirements.unresolvedThreads ?? 0) > 0) {
+        eligibility = 'blocked';
+        blockers.push({ code: 'review-threads', message: 'Required review threads must be resolved before merging.' });
+    }
+    else if (reviewDecision === 'unknown' || !requirements.readable ||
+        (requirements.requiresThreadResolution && requirements.unresolvedThreads == null) ||
+        checks.some((check) => check.required === true && check.state === 'unknown')) {
         eligibility = 'unknown';
         blockers.push({
             code: 'rules-unknown',
@@ -2669,6 +2815,7 @@ export function normalizeMergeState(raw, policyRaw, requirements = {
     else if (checks.some((check) => check.state === 'pending') || pr.mergeStateStatus?.toUpperCase() === 'UNSTABLE') {
         eligibility = 'pending';
         blockers.push({ code: 'pending', message: 'Checks or GitHub mergeability are still pending.' });
+        // GitHub's aggregate still enforces other rules and required check provider identities.
     }
     else if (mergeable !== 'mergeable' ||
         !['CLEAN', 'HAS_HOOKS'].includes(pr.mergeStateStatus?.toUpperCase() ?? '') ||
@@ -2731,23 +2878,19 @@ async function fetchPrMergeState(repoRoot, repoRef, number, refresh = false) {
     try {
         const prOut = await gh(repoRoot, [
             'pr', 'view', String(number), '--json',
-            'number,title,url,state,isDraft,headRefName,baseRefName,headRefOid,mergeable,mergeStateStatus,reviewDecision,statusCheckRollup',
+            'number,title,url,state,isDraft,headRefName,baseRefName,headRefOid,mergeable,mergeStateStatus,reviewDecision,statusCheckRollup,mergedAt',
         ]);
         const parsedPr = mergePrSchema.parse(JSON.parse(prOut));
-        const [policyOut, requiredChecks] = await Promise.all([
+        if (!matchesGithubPullRequest({ ...repoRef, number }, parsedPr))
+            return { available: false, reason: 'GitHub returned a different pull request.' };
+        mergedPullRequestObservations.observe({ ...repoRef, number }, parsedPr);
+        const [policyOut, requirements] = await Promise.all([
             gh(repoRoot, ['api', `repos/${repoRef.owner}/${repoRef.repo}`]),
-            gh(repoRoot, [
-                'api',
-                `repos/${repoRef.owner}/${repoRef.repo}/branches/${encodeURIComponent(parsedPr.baseRefName)}/protection/required_status_checks`,
-                '--jq',
-                '[.contexts[]?, .checks[]?.context] | unique',
-            ])
-                .then((output) => ({ readable: true, requiredChecks: z.array(z.string()).parse(JSON.parse(output)) }))
-                .catch(() => ({ readable: false, requiredChecks: [] })),
+            fetchGithubMergeRequirements((args) => gh(repoRoot, args), repoRef.owner, repoRef.repo, parsedPr.baseRefName, number),
         ]);
         const value = {
             available: true,
-            mergeState: normalizeMergeState(parsedPr, JSON.parse(policyOut), requiredChecks),
+            mergeState: normalizeMergeState(parsedPr, JSON.parse(policyOut), requirements),
         };
         mergeStateCache.set(key, { at: Date.now(), value });
         return value;
@@ -2757,7 +2900,16 @@ async function fetchPrMergeState(repoRoot, repoRef, number, refresh = false) {
     }
 }
 export function evictGithubProjectCaches(repoRoot) {
-    listCache.delete(githubContext(repoRoot).key);
+    const contextKey = githubContext(repoRoot).key;
+    listCache.forEach((entry, key) => {
+        if (entry.contextKey === contextKey)
+            dropListEntry(key);
+    });
+    repositoryProjectsCache.delete(contextKey);
+    commentCountsCache.forEach((_value, key) => {
+        if (key.startsWith(`${contextKey}\0`))
+            commentCountsCache.delete(key);
+    });
     mergeStateCache.forEach((_value, key) => {
         if (key.startsWith(`${repoRoot}:`))
             mergeStateCache.delete(key);
@@ -2777,29 +2929,53 @@ async function mergePullRequest(repoRoot, repoRef, number, input) {
         return { merged: false, status: 409, error: 'A merge is already in progress.', code: 'concurrent' };
     mergeInflight.add(key);
     try {
+        if (input.canProceed?.() === false)
+            return { merged: false, status: 409, error: 'Automatic merging was cancelled.', code: 'cancelled' };
         const fresh = await fetchPrMergeState(repoRoot, repoRef, number, true);
+        if (input.canProceed?.() === false)
+            return { merged: false, status: 409, error: 'Automatic merging was cancelled.', code: 'cancelled' };
         if (!fresh.available)
             return { merged: false, status: 502, error: fresh.reason };
         const current = fresh.mergeState;
         if (current.headSha !== input.expectedHeadSha) {
             return { merged: false, status: 409, error: 'The pull request head changed. Review the new commits before merging.', code: 'stale-head', current };
         }
+        if (input.expectedHeadRef !== undefined && current.headRef !== input.expectedHeadRef) {
+            return { merged: false, status: 409, error: 'The pull request branch changed.', code: 'stale-branch', current };
+        }
+        if (input.requirePassingChecks && (current.checks.length === 0 || current.checks.some(check => check.state !== 'passing'))) {
+            return { merged: false, status: 409, error: 'Automatic merging requires at least one check and every current-head check passing.', code: 'checks-not-passing', current };
+        }
         if (!current.methods.includes(input.method)) {
             return { merged: false, status: 409, error: 'That merge method is no longer enabled.', code: 'disabled-method', current };
         }
-        if (!mergePreflightAllowed(current, input.overrideRules)) {
+        if (!mergePreflightAllowed(current, !input.requirePassingChecks && input.overrideRules)) {
             return { merged: false, status: 409, error: current.blockers[0]?.message ?? 'The pull request is not eligible to merge.', code: current.eligibility, current };
         }
+        if (input.requirePassingChecks && process.env.CEZ_DRY_RUN !== '1') {
+            if (!repoRef)
+                return { merged: false, status: 404, error: 'GitHub repository not found.' };
+            const active = parseActiveWorkflowRuns(await gh(repoRoot, activeWorkflowRunsArgs({
+                repository: `${repoRef.owner}/${repoRef.repo}`, headSha: current.headSha,
+            })));
+            if (input.canProceed?.() === false)
+                return { merged: false, status: 409, error: 'Automatic merging was cancelled.', code: 'cancelled' };
+            if (active)
+                return { merged: false, status: 409, error: 'Waiting for active CI workflows on the current PR head.', code: 'checks-active', current };
+        }
         if (process.env.CEZ_DRY_RUN === '1') {
             evictGithubProjectCaches(repoRoot);
             return { merged: true, number, url: current.url, method: input.method, mergeCommitSha: 'abcdef0123456789abcdef0123456789abcdef01' };
         }
         if (!repoRef)
             return { merged: false, status: 404, error: 'GitHub repository not found.' };
+        if (input.canProceed?.() === false)
+            return { merged: false, status: 409, error: 'Automatic merging was cancelled.', code: 'cancelled' };
         const out = await gh(repoRoot, [
             'api', '--method', 'PUT', `repos/${repoRef.owner}/${repoRef.repo}/pulls/${number}/merge`,
             '-f', `merge_method=${input.method}`, '-f', `sha=${input.expectedHeadSha}`,
         ]);
+        // Once GitHub accepted the mutation, report its real outcome even if intent changed in flight.
         const result = ghMergeResultSchema.parse(JSON.parse(out));
         if (!result.merged)
             return { merged: false, status: 409, error: result.message ?? 'GitHub refused the merge.', code: 'github-blocked', current };
@@ -2818,6 +2994,61 @@ async function mergePullRequest(repoRoot, repoRef, number, input) {
 export function mergePreflightAllowed(current, overrideRules = false) {
     return current.canMerge || (overrideRules && current.canOverride);
 }
+/** gh has no compare-and-swap ready operation. Check ownership immediately before marking ready,
+ * then refresh again; the later merge has its own head guard and GitHub's atomic SHA check. */
+async function readyPullRequest(repoRoot, repoRef, number, input) {
+    if (!Number.isSafeInteger(number) || number < 1 || !/^[0-9a-f]{40}$/.test(input.expectedHeadSha) || !input.expectedHeadRef) {
+        return { available: false, reason: 'A valid pull request, head SHA and task branch are required.' };
+    }
+    const key = `${repoRoot}:${number}`;
+    if (mergeInflight.has(key))
+        return { available: false, reason: 'A pull request mutation is already in progress.' };
+    mergeInflight.add(key);
+    try {
+        if (input.canProceed?.() === false)
+            return { available: false, reason: 'Marking the pull request ready was cancelled.' };
+        const dryRun = process.env.CEZ_DRY_RUN === '1';
+        if (!dryRun) {
+            if (!repoRef)
+                return { available: false, reason: 'GitHub remote could not be resolved' };
+            const pr = mergePrSchema.pick({ number: true, url: true, state: true, isDraft: true, headRefName: true, headRefOid: true }).parse(JSON.parse(await gh(repoRoot, [
+                'pr', 'view', String(number), '--json', 'number,url,state,isDraft,headRefName,headRefOid',
+            ])));
+            if (input.canProceed?.() === false)
+                return { available: false, reason: 'Marking the pull request ready was cancelled.' };
+            if (!matchesGithubPullRequest({ ...repoRef, number }, pr))
+                return { available: false, reason: 'GitHub returned a different pull request.' };
+            if (pr.headRefOid !== input.expectedHeadSha)
+                return { available: false, reason: 'The pull request head changed.' };
+            if (pr.headRefName !== input.expectedHeadRef)
+                return { available: false, reason: 'The pull request branch changed.' };
+            if (pr.state !== 'OPEN')
+                return { available: false, reason: 'The pull request is no longer open.' };
+            if (pr.isDraft) {
+                if (input.canProceed?.() === false)
+                    return { available: false, reason: 'Marking the pull request ready was cancelled.' };
+                await gh(repoRoot, ['pr', 'ready', String(number), '--repo', `github.com/${repoRef.owner}/${repoRef.repo}`]);
+                evictGithubProjectCaches(repoRoot);
+                if (input.canProceed?.() === false)
+                    return { available: false, reason: 'Marking the pull request ready was cancelled.' };
+            }
+        }
+        const fresh = await fetchPrMergeState(repoRoot, repoRef, number, true);
+        if (input.canProceed?.() === false)
+            return { available: false, reason: 'Marking the pull request ready was cancelled.' };
+        if (fresh.available && fresh.mergeState.headSha !== input.expectedHeadSha)
+            return { available: false, reason: 'The pull request head changed.' };
+        if (fresh.available && fresh.mergeState.headRef !== input.expectedHeadRef)
+            return { available: false, reason: 'The pull request branch changed.' };
+        return fresh;
+    }
+    catch {
+        return { available: false, reason: 'GitHub could not mark the pull request ready for review.' };
+    }
+    finally {
+        mergeInflight.delete(key);
+    }
+}
 const GH_PR_STATES = {
     MERGED: 'merged',
     CLOSED: 'closed',
@@ -2827,8 +3058,8 @@ export function createGithubDriver(repoRoot, repoRef) {
         kind: 'github',
         detect: () => detectGithub(repoRoot),
         detectCached: () => detectGithubCached(repoRoot),
-        listIssues: async (opts) => (await fetchGithub(repoRoot, opts?.refresh, opts?.limit)).issues,
-        listPRs: async (opts) => (await fetchGithub(repoRoot, opts?.refresh, opts?.limit)).prs,
+        listIssues: async (opts) => (await fetchGithub(repoRoot, opts?.refresh, opts?.limit, opts)).issues,
+        listPRs: async (opts) => (await fetchGithub(repoRoot, opts?.refresh, opts?.limit, opts)).prs,
         // The open-only list tier's escape hatch (#730) — this is the only path that can reach a
         // closed or merged item.
         searchItems: (kind, query, opts) => searchGithubItems(repoRoot, kind, query, opts?.limit),
@@ -2841,8 +3072,10 @@ export function createGithubDriver(repoRoot, repoRef) {
             if (process.env.CEZ_DRY_RUN === '1')
                 return null;
             try {
-                const out = await gh(repoRoot, ['pr', 'view', branch, '--json', 'number,url,state,isDraft,statusCheckRollup']);
+                const out = await gh(repoRoot, ['pr', 'view', branch, '--json', 'number,url,state,isDraft,statusCheckRollup,mergedAt']);
                 const pr = ghPrViewSchema.parse(JSON.parse(out));
+                if (repoRef)
+                    mergedPullRequestObservations.observe({ ...repoRef, number: pr.number }, pr);
                 return {
                     number: pr.number,
                     url: pr.url,
@@ -2856,6 +3089,7 @@ export function createGithubDriver(repoRoot, repoRef) {
             }
         },
         prMergeState: (number, opts) => fetchPrMergeState(repoRoot, repoRef, number, opts?.refresh),
+        readyPR: (number, input) => readyPullRequest(repoRoot, repoRef, number, input),
         mergePR: (number, input) => mergePullRequest(repoRoot, repoRef, number, input),
         viewUrl: (kind, ref) => {
             if (!repoRef)
@@ -2878,4 +3112,89 @@ export function createGithubDriver(repoRoot, repoRef) {
         },
     };
 }
+/** A missing alias must not poison unrelated families. Discard partial data and requery only
+ * unaffected aliases once; archive authority still comes from an error-free response. */
+async function mergedPullRequestChunk(runGraphql, initial) {
+    let chunk = initial;
+    for (let attempt = 0; attempt < 2 && chunk.length; attempt++) {
+        const query = `query($owner: String!, $name: String!) { repository(owner: $owner, name: $name) { nameWithOwner ${chunk.map(pr => `pr${pr.number}: pullRequest(number: ${pr.number}) { number url state mergedAt }`).join(' ')} } }`;
+        let response;
+        let failure;
+        try {
+            response = JSON.parse(await runGraphql(query, { owner: chunk[0].owner, name: chunk[0].repo }));
+        }
+        catch (error) {
+            // gh exits 1 on GraphQL errors, with the structured envelope on stdout. Neither stderr
+            // nor timeout/abort output is evidence that one particular alias was missing.
+            const rejected = z.object({ code: z.literal(1), stdout: z.string() }).safeParse(error);
+            if (!rejected.success)
+                throw error;
+            try {
+                response = JSON.parse(rejected.data.stdout);
+            }
+            catch {
+                throw error;
+            }
+            failure = error;
+        }
+        const partial = z.object({
+            errors: z.array(z.object({ type: z.literal('NOT_FOUND'), path: z.tuple([z.literal('repository'), z.string()]) })).nonempty(),
+            data: z.object({ repository: z.object({ nameWithOwner: z.string() }) }),
+        }).safeParse(response);
+        const aliases = new Set(chunk.map(pr => `pr${pr.number}`));
+        if (attempt === 0 && partial.success &&
+            partial.data.data.repository.nameWithOwner.toLowerCase() === `${chunk[0].owner}/${chunk[0].repo}`.toLowerCase() &&
+            partial.data.errors.every(error => aliases.has(error.path[1]))) {
+            const missing = new Set(partial.data.errors.map(error => error.path[1]));
+            chunk = chunk.filter(pr => !missing.has(`pr${pr.number}`));
+            continue;
+        }
+        if (failure)
+            throw failure;
+        return response;
+    }
+    return undefined;
+}
+/** Strict archive authority: no partial GraphQL success, redirects, guessed identity or date. */
+export async function fetchMergedPullRequests(runGraphql, identities) {
+    const repositories = new Map();
+    for (const identity of new Map(identities.map(pr => [pullRequestKey(pr), pr])).values()) {
+        const key = `${identity.owner}/${identity.repo}`;
+        repositories.set(key, [...(repositories.get(key) ?? []), identity]);
+    }
+    const merged = [];
+    for (const [repository, prs] of repositories) {
+        for (let offset = 0; offset < prs.length; offset += 25) {
+            const chunk = prs.slice(offset, offset + 25);
+            const response = await mergedPullRequestChunk(runGraphql, chunk);
+            const parsed = z.object({ errors: z.array(z.unknown()).optional(), data: z.object({ repository: z.object({ nameWithOwner: z.string() }).passthrough().nullable() }) }).safeParse(response);
+            if (!parsed.success || parsed.data.errors?.length || parsed.data.data.repository?.nameWithOwner.toLowerCase() !== repository.toLowerCase())
+                continue;
+            for (const pr of chunk) {
+                const fact = mergedPullRequestObservations.observe(pr, parsed.data.data.repository[`pr${pr.number}`]);
+                if (fact)
+                    merged.push(fact);
+            }
+        }
+    }
+    return merged;
+}
+export async function lookupMergedPullRequests(repoRoot, identities, signal) {
+    signal.throwIfAborted();
+    if (process.env.CEZ_DRY_RUN === '1')
+        return [];
+    const unique = [...new Map(identities.map(pr => [pullRequestKey(pr), pr])).values()];
+    const known = unique.flatMap(pr => mergedPullRequestObservations.get(pr) ?? []);
+    const missing = unique.filter(pr => !mergedPullRequestObservations.get(pr));
+    if (missing.length === 0)
+        return known;
+    const context = githubContext(repoRoot);
+    const fetched = await fetchMergedPullRequests(async (query, variables) => {
+        const args = ['api', 'graphql', '--hostname', 'github.com', '-f', `query=${query}`];
+        for (const [key, value] of Object.entries(variables))
+            args.push('-f', `${key}=${value}`);
+        return gh(repoRoot, args, 15_000, signal, context);
+    }, missing);
+    return [...known, ...fetched];
+}
 //# sourceMappingURL=github.js.map