@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/lib/github/project-prs.js

@@ -1,41 +1,19 @@
-/**
- * `agents projects prs <PROJECT>` — every OPEN pull request across a project's
- * attached repositories, as one machine-readable envelope for AGI Menu.
- *
- * Why this exists: `agents projects status`'s `openPrs` only carries the PRs the
- * fleet's own SESSIONS opened (the session rollup), so a project's board of open
- * PRs — drafts, other people's PRs, anything not tied to a live session — is
- * invisible to it. This reads the truth straight from GitHub.
- *
- * Design constraints (see docs conventions + the contract in
- * `.agents/scratch/contracts-status.json`):
- *   - Repos come ONLY from the ProjectDef's own attached slugs
- *     ({@link projectRepoSlugs}); `--repo` is refused unless it is one of them.
- *   - The list is REST + paginated (`gh api repos/{repo}/pulls?state=open
- *     --paginate`), includes drafts, and applies NO author filter — it is the
- *     whole open board, not this user's mergeable set. REST is the budget the
- *     fleet's GraphQL poll loops do not drain (PHNX-3501).
- *   - `checks` / `reviewDecision` are null in the list; `--number N` enriches
- *     exactly that one PR against its live head SHA (checks via REST
- *     {@link rollupForSha}, reviewDecision via a single lazy `gh pr view`).
- *   - A per-repo fetch failure is reported as `repositories[].error` and flips
- *     `partial` — it is NEVER relabeled as "zero open PRs".
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import { ghExec, canonicalizeRepo, projectRepoSlugs } from './pr-mergeable.js';
-import { rollupForSha } from './rest.js';
+import { isRateLimitError, rollupForSha } from './rest.js';
+import { cachedViewer, fetchViewerProfile } from './viewer.js';
 import { repoPathClaims } from '../projects.js';
 import { getCacheDir } from '../state.js';
 import { atomicWriteFileSync } from '../fs-atomic.js';
-/** The jq projection that flattens a REST PR object into {@link ProjectPr}'s scalars. */
+import { npmView as defaultNpmView, readLatestTag, withMergesSince } from './release-drift.js';
 const PR_JQ = '{number, title, url: .html_url, isDraft: (.draft // false), ' +
     'state: (.state // "" | ascii_upcase), createdAt: (.created_at // ""), updatedAt: (.updated_at // ""), ' +
     'login: (.user.login // ""), avatarUrl: (.user.avatar_url // ""), ' +
     'headRefName: (.head.ref // ""), baseRefName: (.base.ref // ""), ' +
     'headSha: (.head.sha // ""), body: (.body // ""), ' +
-    'mergeable: .mergeable, mergeableState: .mergeable_state}';
-/** Parse newline-delimited JSON (gh `--jq` streams one object per line/page). */
+    'mergeable: .mergeable, mergeableState: .mergeable_state, ' +
+    'autoMerge: (if .auto_merge then {enabledBy: (.auto_merge.enabled_by.login // ""), method: (.auto_merge.merge_method // "")} else null end)}';
 function parseNdjson(out) {
     const rows = [];
     for (const line of out.split('\n')) {
@@ -46,7 +24,6 @@ function parseNdjson(out) {
     }
     return rows;
 }
-/** Build a {@link ProjectPr} from the flattened jq row. checks/reviewDecision start null. */
 export function rowToProjectPr(row) {
     return {
         number: Number(row.number),
@@ -66,24 +43,24 @@ export function rowToProjectPr(row) {
         mergeableState: typeof row.mergeableState === 'string' ? row.mergeableState : null,
         checks: null,
         reviewDecision: null,
+        ciState: null,
+        failingChecks: [],
+        autoMerge: isRecord(row.autoMerge)
+            ? { enabledBy: String(row.autoMerge.enabledBy ?? ''), method: String(row.autoMerge.method ?? '') }
+            : null,
     };
 }
-/**
- * Every OPEN PR for one repo, over REST, fully paginated, drafts included, no
- * author filter. `--paginate` follows Link headers; `--jq` streams one flattened
- * object per line so a multi-page result stays parseable.
- */
 export async function listOpenPrs(repo, gh = ghExec) {
     const out = await gh([
         'api',
         `repos/${repo}/pulls?state=open&per_page=100`,
         '--paginate',
+        '--cache', '60s',
         '--jq',
         `.[] | ${PR_JQ}`,
     ]);
     return parseNdjson(out).map(rowToProjectPr);
 }
-/** One PR by number, over REST (`GET repos/{repo}/pulls/{n}`). Throws if it is gone. */
 export async function fetchOnePr(repo, number, gh = ghExec) {
     const out = await gh(['api', `repos/${repo}/pulls/${number}`, '--jq', PR_JQ]);
     const rows = parseNdjson(out);
@@ -91,16 +68,6 @@ export async function fetchOnePr(repo, number, gh = ghExec) {
         throw new Error(`no PR ${repo}#${number}`);
     return rowToProjectPr(rows[0]);
 }
-/**
- * GitHub's computed review decision AND the PR's current head oid, from ONE lazy
- * `gh pr view` (GraphQL). reviewDecision is deliberately NOT REST-derived: it is
- * a branch-protection / CODEOWNERS decision REST cannot compute, and
- * approximating it could mislead a merge decision (PHNX-3501 note). `headRefOid`
- * rides the same call so the checks and the review verdict can be anchored to the
- * SAME head — a PR that advanced between the REST read and this call would
- * otherwise pair a stale check rollup with a current review. One call per
- * `--number`, never a poll loop, so it does not drain the shared GraphQL budget.
- */
 export async function fetchReviewAndHead(repo, number, gh = ghExec) {
     const out = (await gh([
         'pr', 'view', String(number), '--repo', repo, '--json', 'reviewDecision,headRefOid',
@@ -111,29 +78,221 @@ export async function fetchReviewAndHead(repo, number, gh = ghExec) {
         headRefOid: parsed.headRefOid || null,
     };
 }
-/**
- * Enrich one PR with its checks + reviewDecision, both anchored to the SAME head.
- * `gh pr view` gives the authoritative current head oid; the check rollup is run
- * against THAT (not the possibly-staler REST head SHA), and `headSha` is updated
- * to match, so checks and reviewDecision can never describe two different heads.
- */
 export async function enrichPr(repo, pr, gh = ghExec) {
     const { reviewDecision, headRefOid } = await fetchReviewAndHead(repo, pr.number, gh);
     const head = headRefOid || pr.headSha;
     const checks = await rollupForSha(repo, head, gh);
-    return { ...pr, headSha: head, checks, reviewDecision };
-}
-/**
- * Resolve which repositories a run targets, restricted to the project's own
- * attached repos. Slugs are canonicalized (a renamed repo lists nothing under
- * its old name — `phnx-labs/agents-cli` → `phnx-labs/agi-cli`). A `--repo` that
- * is not one of the project's attached repos (raw or canonical) is refused.
- */
+    return { ...pr, headSha: head, checks, reviewDecision, ...ciFromRollupItems(checks) };
+}
+export const MERGED_WINDOW_DAYS = 7;
+export const MERGED_LIMIT = 20;
+export const MERGED_PAGE_CAP = 3;
+export const FAILING_CONCLUSIONS = new Set(['FAILURE', 'TIMED_OUT', 'CANCELLED', 'ACTION_REQUIRED', 'STARTUP_FAILURE']);
+export const FAILING_STATES = new Set(['FAILURE', 'ERROR']);
+const NO_CI = { ciState: null, failingChecks: [] };
+const isCheckRun = (item) => item.state === undefined;
+export function ciFromRollupItems(items) {
+    if (items.length === 0)
+        return NO_CI;
+    const failing = [];
+    let failed = false;
+    let pending = false;
+    for (const item of items) {
+        const run = isCheckRun(item);
+        if (run ? FAILING_CONCLUSIONS.has(item.conclusion ?? '') : FAILING_STATES.has(item.state ?? '')) {
+            failing.push(item.name);
+            if (run || item.state === 'FAILURE')
+                failed = true;
+        }
+        else if (run ? item.status !== 'COMPLETED' : item.state === 'PENDING') {
+            pending = true;
+        }
+    }
+    if (failing.length > 0)
+        return { ciState: failed ? 'FAILURE' : 'ERROR', failingChecks: failing };
+    return { ciState: pending ? 'PENDING' : 'SUCCESS', failingChecks: [] };
+}
+const PASSING_CONCLUSIONS = new Set(['SUCCESS', 'NEUTRAL', 'SKIPPED']);
+export function isPassingRollup(items) {
+    return items.length > 0 && items.every((i) => (isCheckRun(i)
+        ? i.status === 'COMPLETED' && PASSING_CONCLUSIONS.has(i.conclusion ?? '')
+        : i.state === 'SUCCESS'));
+}
+export const PASSING_ROLLUP_TTL_MS = 60 * 60 * 1000;
+export const FAILING_ROLLUP_TTL_MS = 5 * 60 * 1000;
+export function isFinishedRollup(items) {
+    return items.length > 0 && items.every((i) => (isCheckRun(i) ? i.status === 'COMPLETED' : i.state !== 'PENDING'));
+}
+function rollupTtlMs(items) {
+    return isPassingRollup(items) ? PASSING_ROLLUP_TTL_MS : FAILING_ROLLUP_TTL_MS;
+}
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const isFileList = (v) => Array.isArray(v) && v.every((f) => typeof f === 'string');
+const isCachedRollup = (v) => isRecord(v) && typeof v.readAt === 'number' && Array.isArray(v.items) &&
+    v.items.every((i) => isRecord(i) && typeof i.name === 'string');
+const isNpmRead = (v) => isRecord(v) && typeof v.readAt === 'number' && (v.version === null || typeof v.version === 'string') &&
+    (v.error === null || typeof v.error === 'string');
+const isMergedDetail = (v) => isRecord(v) && (v.mergedBy === null || typeof v.mergedBy === 'string') &&
+    typeof v.additions === 'number' && typeof v.deletions === 'number';
+export class KeyedCache {
+    file;
+    sep;
+    entries = {};
+    dirty = false;
+    constructor(dir, name, sep, isValid) {
+        this.file = path.join(dir, name);
+        this.sep = sep;
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(this.file, 'utf-8'));
+        }
+        catch {
+            return;
+        }
+        if (!isRecord(parsed))
+            return;
+        for (const [key, value] of Object.entries(parsed)) {
+            if (isValid(value))
+                this.entries[key] = value;
+            else
+                this.dirty = true;
+        }
+    }
+    get(slug, id) {
+        return this.entries[`${slug}${this.sep}${id}`];
+    }
+    set(slug, id, value) {
+        this.entries[`${slug}${this.sep}${id}`] = value;
+        this.dirty = true;
+    }
+    prune(slug, listed) {
+        for (const key of Object.keys(this.entries)) {
+            const at = key.lastIndexOf(this.sep);
+            if (key.slice(0, at) === slug && !listed.has(key.slice(at + 1))) {
+                delete this.entries[key];
+                this.dirty = true;
+            }
+        }
+    }
+    save() {
+        if (!this.dirty)
+            return;
+        fs.mkdirSync(path.dirname(this.file), { recursive: true });
+        atomicWriteFileSync(this.file, JSON.stringify(this.entries));
+    }
+}
+class CiErrors {
+    message = null;
+    record(err) {
+        const msg = ghFailure(err);
+        if (this.message === null || (isRateLimited(msg) && !isRateLimited(this.message)))
+            this.message = msg;
+    }
+}
+function isRateLimited(message) {
+    return isRateLimitError(message) || /API rate limit exceeded/i.test(message);
+}
+function readCi(ci, sha) {
+    if (!sha)
+        return Promise.resolve(NO_CI);
+    let read = ci.reads.get(sha);
+    if (!read) {
+        read = readCiUncached(ci, sha);
+        ci.reads.set(sha, read);
+    }
+    return read;
+}
+async function readCiUncached(ci, sha) {
+    const hit = ci.rollups.get(ci.slug, sha);
+    const age = hit ? ci.nowMs - hit.readAt : -1;
+    if (hit && age >= 0 && age < rollupTtlMs(hit.items))
+        return ciFromRollupItems(hit.items);
+    try {
+        const items = await rollupForSha(ci.slug, sha, ci.gh);
+        if (isFinishedRollup(items))
+            ci.rollups.set(ci.slug, sha, { items, readAt: ci.nowMs });
+        return ciFromRollupItems(items);
+    }
+    catch (err) {
+        ci.errors.record(err);
+        return NO_CI;
+    }
+}
+const CLOSED_JQ = '.[] | {number, title, url: .html_url, login: (.user.login // ""), avatarUrl: (.user.avatar_url // ""), ' +
+    'headRefName: (.head.ref // ""), headSha: (.head.sha // ""), baseRefName: (.base.ref // ""), ' +
+    'mergedAt: .merged_at, mergeCommitSha: .merge_commit_sha, updatedAt: .updated_at}';
+export async function listRecentlyMerged(repo, sinceMs, gh = ghExec) {
+    const rows = [];
+    let truncated = false;
+    for (let page = 1; page <= MERGED_PAGE_CAP; page++) {
+        const pageRows = parseNdjson(await gh([
+            'api', `repos/${repo}/pulls?state=closed&sort=updated&direction=desc&per_page=100&page=${page}`,
+            '--cache', '60s', '--jq', CLOSED_JQ,
+        ]));
+        rows.push(...pageRows);
+        const oldest = pageRows.at(-1)?.updatedAt;
+        if (pageRows.length < 100 || typeof oldest !== 'string' || Date.parse(oldest) < sinceMs)
+            break;
+        truncated = page === MERGED_PAGE_CAP;
+    }
+    const merged = rows
+        .filter((r) => typeof r.mergedAt === 'string' && Date.parse(r.mergedAt) >= sinceMs)
+        .sort((a, b) => Date.parse(String(b.mergedAt)) - Date.parse(String(a.mergedAt)))
+        .map((r) => ({
+        headSha: String(r.headSha ?? ''),
+        pr: {
+            number: Number(r.number),
+            title: String(r.title ?? ''),
+            url: String(r.url ?? ''),
+            author: { login: String(r.login ?? ''), avatarUrl: String(r.avatarUrl ?? '') },
+            headRefName: String(r.headRefName ?? ''),
+            baseRefName: String(r.baseRefName ?? ''),
+            mergedAt: String(r.mergedAt),
+            mergedBy: null,
+            mergeCommitSha: typeof r.mergeCommitSha === 'string' && r.mergeCommitSha ? r.mergeCommitSha : null,
+            ciState: null,
+            failingChecks: [],
+            additions: 0,
+            deletions: 0,
+            scope: null,
+        },
+    }));
+    return { merged, truncated };
+}
+async function readMergedDetail(slug, number, gh, details, errors) {
+    const hit = details.get(slug, number);
+    if (hit)
+        return hit;
+    try {
+        const row = JSON.parse((await gh([
+            'api', `repos/${slug}/pulls/${number}`, '--jq', '{mergedBy: .merged_by.login, additions, deletions}',
+        ])).trim());
+        const detail = { mergedBy: row.mergedBy || null, additions: Number(row.additions ?? 0), deletions: Number(row.deletions ?? 0) };
+        details.set(slug, number, detail);
+        return detail;
+    }
+    catch (err) {
+        errors.record(err);
+        return null;
+    }
+}
+async function readDefaultBranch(ci) {
+    try {
+        const name = (await ci.gh(['api', `repos/${ci.slug}`, '--cache', '1h', '--jq', '.default_branch'])).trim();
+        if (!name)
+            throw new Error(`${ci.slug} reports no default branch`);
+        const sha = (await ci.gh(['api', `repos/${ci.slug}/branches/${name}`, '--jq', '.commit.sha'])).trim();
+        if (!sha)
+            throw new Error(`${ci.slug}@${name} has no head commit`);
+        return { name, sha, ...await readCi(ci, sha) };
+    }
+    catch (err) {
+        ci.errors.record(err);
+        return null;
+    }
+}
 export async function resolveTargetSlugs(def, repo, gh) {
     const raw = projectRepoSlugs([def]);
-    // Canonicalize CONCURRENTLY — each repo read can take up to gh's 30s
-    // timeout, so a sequential walk of N repos would stack N×30s and blow past a
-    // native caller's bounded deadline. Repo count per project is small.
     const canonPairs = await Promise.all(raw.map(async (slug) => [slug, await canonicalizeRepo(slug, gh)]));
     const canon = new Map(canonPairs);
     const canonical = [...new Set(canon.values())];
@@ -149,11 +308,6 @@ export async function resolveTargetSlugs(def, repo, gh) {
     }
     return [requested];
 }
-/**
- * Classify one PR of a shared repository by the files it changes. `own` are
- * this project's prefixes, `others` every other sharing project's. Returns
- * null when the PR belongs only to another project.
- */
 export function scopeForFiles(files, own, others) {
     const under = (prefixes) => files.some((f) => prefixes.some((p) => f.startsWith(p)));
     if (under(own))
@@ -162,55 +316,20 @@ export function scopeForFiles(files, own, others) {
         return null;
     return 'repo-wide';
 }
-/**
- * The files a PR changes, keyed by its head SHA. The list for a given head is
- * immutable, so a cached entry never goes stale; a push mints a new key. Entries
- * for heads that are no longer open in that repo are pruned on write.
- */
-class PrFilesCache {
-    file = path.join(getCacheDir(), 'project-pr-files.json');
-    entries = {};
-    dirty = false;
-    constructor() {
-        // A missing or unreadable cache only costs re-reads; it never fails a list.
-        try {
-            const parsed = JSON.parse(fs.readFileSync(this.file, 'utf-8'));
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
-                this.entries = parsed;
-        }
-        catch {
-            this.entries = {};
-        }
+class PrFilesCache extends KeyedCache {
+    constructor(dir) {
+        super(dir, 'project-pr-files.json', '@', isFileList);
     }
     async files(slug, pr, gh) {
-        const key = `${slug}@${pr.headSha}`;
-        const hit = this.entries[key];
+        const hit = this.get(slug, pr.headSha);
         if (hit)
             return hit;
-        // A rename counts on both sides: moving a file out of a project's path touches that project.
         const out = await gh(['api', `repos/${slug}/pulls/${pr.number}/files?per_page=100`, '--paginate', '--jq', '.[] | .filename, (.previous_filename // empty)']);
         const files = out.split('\n').map((l) => l.trim()).filter(Boolean);
-        this.entries[key] = files;
-        this.dirty = true;
+        this.set(slug, pr.headSha, files);
         return files;
     }
-    prune(slug, openHeads) {
-        for (const key of Object.keys(this.entries)) {
-            const at = key.lastIndexOf('@');
-            if (key.slice(0, at) === slug && !openHeads.has(key.slice(at + 1))) {
-                delete this.entries[key];
-                this.dirty = true;
-            }
-        }
-    }
-    save() {
-        if (!this.dirty)
-            return;
-        fs.mkdirSync(path.dirname(this.file), { recursive: true });
-        atomicWriteFileSync(this.file, JSON.stringify(this.entries));
-    }
 }
-/** Run `fn` over `items` with at most `limit` in flight, preserving order. */
 async function mapBounded(items, limit, fn) {
     const results = new Array(items.length);
     let next = 0;
@@ -223,19 +342,9 @@ async function mapBounded(items, limit, fn) {
     await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
     return results;
 }
-/** The authenticated login, from a REST read gh caches for a day. */
 export async function fetchViewer(gh = ghExec) {
-    try {
-        return (await gh(['api', 'user', '--cache', '24h', '--jq', '.login'])).trim() || null;
-    }
-    catch {
-        return null;
-    }
+    return (await fetchViewerProfile(gh))?.login ?? null;
 }
-/**
- * The repository paths `def` claims, keyed by canonical slug. Canonicalization
- * is cached, so this costs no network after the first run of the day.
- */
 async function canonicalClaims(def, gh) {
     const out = new Map();
     for (const { slug, prefix } of repoPathClaims(def)) {
@@ -244,7 +353,6 @@ async function canonicalClaims(def, gh) {
     }
     return out;
 }
-/** For each canonical slug, the other projects attached to it and the paths they claim. */
 async function repoPeers(def, peers, gh) {
     const bySlug = new Map();
     await Promise.all(peers.filter((p) => p.name !== def.name).map(async (peer) => {
@@ -263,92 +371,195 @@ async function repoPeers(def, peers, gh) {
         entry.names.sort();
     return bySlug;
 }
-/**
- * Build the full envelope. `number` (which the command requires alongside
- * `repo`) fetches and enriches exactly that one PR; otherwise every target
- * repo's open PRs are listed with checks/reviewDecision left null.
- *
- * `peers` are every project definition. A repository attached to more than one
- * project is scoped: when this project claims part of it ({@link repoPathClaims}),
- * its list keeps only PRs that touch those paths (`scope: project`) or touch no
- * sharing project's paths (`scope: repo-wide`).
- */
-export async function buildProjectPrs(def, opts = {}, gh = ghExec, peers = []) {
+export async function buildProjectPrs(def, opts = {}, gh = ghExec, peers = [], ctx = {}) {
     const project = { name: def.name, linearProjectId: def.linear?.projectId ?? null };
     const slugs = await resolveTargetSlugs(def, opts.repo, gh);
     if (slugs.length === 0)
         return { project, viewer: null, repositories: [], partial: false };
     const viewerRead = fetchViewer(gh);
     const [shared, ownClaims] = await Promise.all([repoPeers(def, peers, gh), canonicalClaims(def, gh)]);
-    const filesCache = new PrFilesCache();
-    // Fetch repos in PARALLEL so a native caller's overall deadline scales with the
-    // slowest repo, not the sum — a serial multi-repo walk of 30s gh calls can blow
-    // past a bounded caller timeout and lose the whole result. Repo count is small
-    // (a project's attached repos), so this is a bounded fan-out, not unbounded.
+    const cacheDir = ctx.cacheDir ?? getCacheDir();
+    const filesCache = new PrFilesCache(cacheDir);
+    const rollups = new KeyedCache(cacheDir, 'project-pr-ci.json', '@', isCachedRollup);
+    const details = new KeyedCache(cacheDir, 'project-pr-merged.json', '#', isMergedDetail);
+    const npmVersions = new KeyedCache(cacheDir, 'project-npm-versions.json', '#', isNpmRead);
+    const nowMs = ctx.nowMs ?? Date.now();
+    const npm = {
+        view: ctx.npmView ?? defaultNpmView,
+        nowMs,
+        cache: { get: (name) => npmVersions.get('npm', name), set: (name, v) => npmVersions.set('npm', name, v) },
+    };
+    const sinceMs = nowMs - MERGED_WINDOW_DAYS * 24 * 60 * 60 * 1000;
     const repositories = await Promise.all(slugs.map(async (slug) => {
         const peer = shared.get(slug);
         const sharedWith = peer?.names ?? [];
         try {
-            let pullRequests;
+            const mergeRead = readRepoMergeAbility(slug, gh).then((merge) => ({ merge, error: null }), (err) => ({ merge: null, error: err }));
             if (opts.number !== undefined) {
                 const pr = await fetchOnePr(slug, opts.number, gh);
-                pullRequests = [await enrichPr(slug, pr, gh)];
+                const enriched = await enrichPr(slug, pr, gh);
+                const { merge, error: mergeError } = await mergeRead;
+                return {
+                    slug, sharedWith, pullRequests: [enriched], merge,
+                    recentlyMerged: [], defaultBranch: null, ciError: mergeError === null ? null : ghFailure(mergeError), truncated: false, release: null, releaseError: null, error: null,
+                };
+            }
+            const errors = new CiErrors();
+            const ci = { slug, gh, rollups, errors, nowMs, reads: new Map() };
+            const tagRead = readLatestTag(slug, gh, npm)
+                .then((tag) => ({ tag, error: null }), (err) => ({ tag: null, error: ghFailure(err) }));
+            const [listed, mergedRead, defaultBranch] = await Promise.all([
+                listOpenPrs(slug, gh),
+                listRecentlyMerged(slug, sinceMs, gh).catch((err) => {
+                    errors.record(err);
+                    return null;
+                }),
+                readDefaultBranch(ci),
+            ]);
+            const mergedListed = mergedRead?.merged ?? null;
+            let pullRequests = listed;
+            let merged = mergedListed ?? [];
+            const own = ownClaims.get(slug);
+            if (peer && own) {
+                if (mergedListed)
+                    filesCache.prune(slug, new Set([...listed.map((pr) => pr.headSha), ...merged.map((m) => m.headSha)]));
+                const scopeOf = async (pr) => scopeForFiles(await filesCache.files(slug, pr, gh), own, peer.prefixes);
+                const [openScopes, mergedScopes] = await Promise.all([
+                    mapBounded(pullRequests, 8, scopeOf),
+                    mapBounded(merged, 8, (m) => scopeOf({ number: m.pr.number, headSha: m.headSha })),
+                ]);
+                pullRequests = pullRequests
+                    .map((pr, i) => ({ ...pr, scope: openScopes[i] }))
+                    .filter((pr) => pr.scope !== null);
+                merged = merged
+                    .map((m, i) => ({ ...m, pr: { ...m.pr, scope: mergedScopes[i] } }))
+                    .filter((m) => m.pr.scope !== null);
             }
-            else {
-                pullRequests = await listOpenPrs(slug, gh);
-                const own = ownClaims.get(slug);
-                if (peer && own) {
-                    filesCache.prune(slug, new Set(pullRequests.map((pr) => pr.headSha)));
-                    const scopes = await mapBounded(pullRequests, 8, async (pr) => scopeForFiles(await filesCache.files(slug, pr, gh), own, peer.prefixes));
-                    pullRequests = pullRequests
-                        .map((pr, i) => ({ ...pr, scope: scopes[i] }))
-                        .filter((pr) => pr.scope !== null);
+            const { tag, error: releaseError } = await tagRead;
+            const release = tag
+                ? withMergesSince(tag, mergedListed ? merged.map((m) => m.pr) : null, { sinceMs, truncated: mergedRead?.truncated ?? false, base: defaultBranch?.name ?? null })
+                : null;
+            merged = merged.slice(0, MERGED_LIMIT);
+            const [openCi, recentlyMerged] = await Promise.all([
+                mapBounded(pullRequests, 8, (pr) => readCi(ci, pr.headSha)),
+                mapBounded(merged, 8, async (m) => {
+                    const [detail, mergeCi] = await Promise.all([
+                        readMergedDetail(slug, m.pr.number, gh, details, errors),
+                        readCi(ci, m.pr.mergeCommitSha),
+                    ]);
+                    return { ...m.pr, ...(detail ?? {}), ...mergeCi };
+                }),
+            ]);
+            pullRequests = pullRequests.map((pr, i) => ({ ...pr, ...openCi[i] }));
+            const { merge, error: mergeError } = await mergeRead;
+            if (mergeError !== null)
+                errors.record(mergeError);
+            if (mergedListed) {
+                details.prune(slug, new Set(mergedListed.map((m) => String(m.pr.number))));
+                if (defaultBranch) {
+                    rollups.prune(slug, new Set([
+                        ...listed.map((pr) => pr.headSha),
+                        ...mergedListed.flatMap((m) => (m.pr.mergeCommitSha ? [m.pr.mergeCommitSha] : [])),
+                        defaultBranch.sha,
+                    ]));
                 }
             }
-            return { slug, sharedWith, pullRequests, error: null };
+            return {
+                slug, sharedWith, pullRequests, merge, recentlyMerged, defaultBranch,
+                ciError: errors.message, truncated: mergedRead?.truncated ?? false, release, releaseError, error: null,
+            };
         }
         catch (err) {
-            // A fetch failure is reported, never relabeled as zero open PRs.
-            return { slug, sharedWith, pullRequests: [], error: err instanceof Error ? err.message : String(err) };
+            return {
+                slug, sharedWith, pullRequests: [], merge: null, recentlyMerged: [], defaultBranch: null, ciError: null, truncated: false,
+                release: null, releaseError: null, error: err instanceof Error ? err.message : String(err),
+            };
         }
     }));
     filesCache.save();
+    rollups.save();
+    details.save();
+    npmVersions.save();
     const partial = repositories.some((r) => r.error !== null);
     return { project, viewer: await viewerRead, repositories, partial };
 }
-/** How a PR is merged; the default is the first of these the repository allows. */
 export const MERGE_METHODS = ['rebase', 'squash', 'merge'];
-/** The first of {@link MERGE_METHODS} the repository allows. */
-export async function defaultMergeMethod(repo, gh = ghExec) {
-    const allowed = JSON.parse((await gh([
+async function readRepoMergeSettings(repo, gh) {
+    const row = JSON.parse((await gh([
         'api', `repos/${repo}`, '--cache', '1h',
-        '--jq', '{rebase: .allow_rebase_merge, squash: .allow_squash_merge, merge: .allow_merge_commit}',
+        '--jq', '{rebase: .allow_rebase_merge, squash: .allow_squash_merge, merge: .allow_merge_commit, ' +
+            'admin: (.permissions.admin // false), autoMerge: (.allow_auto_merge // false), defaultBranch: (.default_branch // "")}',
     ])).trim());
-    const method = MERGE_METHODS.find((m) => allowed[m]);
+    return {
+        methods: MERGE_METHODS.filter((m) => row[m]),
+        viewerIsAdmin: row.admin === true,
+        autoMergeAllowed: row.autoMerge === true,
+        defaultBranch: row.defaultBranch ?? '',
+    };
+}
+export async function defaultMergeMethod(repo, gh = ghExec) {
+    const method = (await readRepoMergeSettings(repo, gh)).methods[0];
     if (!method)
         throw new Error(`${repo} allows no merge method this token can see.`);
     return method;
 }
-/**
- * gh prints GitHub's refusal on stderr (`gh: Required status check … (HTTP 405)`),
- * sometimes followed by a hint line (a 401 adds `try authenticating with: gh auth
- * login`). Keep the line carrying the HTTP status, else the first line.
- */
-function ghFailure(err) {
+export async function readRepoMergeAbility(repo, gh = ghExec) {
+    const settings = await readRepoMergeSettings(repo, gh);
+    let adminBypass = false;
+    if (settings.viewerIsAdmin) {
+        if (!settings.defaultBranch)
+            throw new Error(`${repo} reports no default branch`);
+        try {
+            const enforced = (await gh([
+                'api', `repos/${repo}/branches/${settings.defaultBranch}/protection`, '--cache', '1h', '--jq', '.enforce_admins.enabled',
+            ])).trim();
+            adminBypass = enforced !== 'true';
+        }
+        catch (err) {
+            if (!/\(HTTP 404\)/.test(ghFailure(err)))
+                throw err;
+            adminBypass = true;
+        }
+    }
+    return {
+        viewerIsAdmin: settings.viewerIsAdmin,
+        adminBypass,
+        autoMergeAllowed: settings.autoMergeAllowed,
+        methods: settings.methods,
+    };
+}
+export function ghFailure(err) {
     const stderr = err?.stderr;
     const text = typeof stderr === 'string' && stderr.trim() ? stderr : err instanceof Error ? err.message : String(err);
     const lines = text.trim().split('\n').map((l) => l.trim()).filter(Boolean);
     const line = lines.find((l) => /\(HTTP \d{3}\)/.test(l)) ?? lines[0] ?? text;
     return line.replace(/^gh:\s*/, '');
 }
-/**
- * Merge one PR over REST (`PUT repos/{repo}/pulls/{n}/merge`), pinned to `sha`:
- * GitHub refuses with 409 when the head moved since the caller looked, so a push
- * that landed after the menu rendered is never merged unseen. Branch protection,
- * required checks and reviews are GitHub's to enforce; their refusal comes back
- * as `merged: false` with GitHub's own message.
- */
-export async function mergeProjectPr(repo, number, sha, method, gh = ghExec) {
+export const BLOCKED_WITHOUT_ADMIN = 'Blocked by branch protection; pass --admin to merge as an admin';
+const MERGEABLE_STATES = new Set(['clean', 'unstable', 'has_hooks']);
+export function mergeRefusalWithoutAdmin(state) {
+    if (MERGEABLE_STATES.has(state))
+        return null;
+    switch (state) {
+        case 'blocked': return BLOCKED_WITHOUT_ADMIN;
+        case 'dirty': return 'Has merge conflicts';
+        case 'behind': return 'The branch is behind its base; update it, or pass --admin to merge as an admin';
+        case 'draft': return 'Draft: mark it ready for review first';
+        default: return 'GitHub is still computing mergeability; try again in a moment';
+    }
+}
+export function readableMergeRefusal(message) {
+    const checks = /Required status checks? (.+?) (?:is|are) expected/i.exec(message);
+    if (checks && /\(HTTP 405\)/.test(message)) {
+        const names = checks[1].replace(/"/g, '');
+        const plural = names.includes(',') ? 'checks' : 'check';
+        return `Required ${plural} ${names} ${plural === 'check' ? "hasn't" : "haven't"} passed (HTTP 405)`;
+    }
+    if (/\(HTTP 409\)/.test(message))
+        return 'The head moved since you looked; reload the PR and try again (HTTP 409)';
+    return message;
+}
+export async function mergeProjectPr(repo, number, sha, method, opts = {}, gh = ghExec) {
     let chosen;
     try {
         chosen = method ?? await defaultMergeMethod(repo, gh);
@@ -356,6 +567,18 @@ export async function mergeProjectPr(repo, number, sha, method, gh = ghExec) {
     catch (err) {
         return { repo, number, method: method ?? MERGE_METHODS[0], merged: false, sha: null, message: ghFailure(err) };
     }
+    if (!opts.admin) {
+        let state;
+        try {
+            state = (await gh(['api', `repos/${repo}/pulls/${number}`, '--jq', '.mergeable_state // ""'])).trim();
+        }
+        catch (err) {
+            return { repo, number, method: chosen, merged: false, sha: null, message: ghFailure(err) };
+        }
+        const refusal = mergeRefusalWithoutAdmin(state);
+        if (refusal !== null)
+            return { repo, number, method: chosen, merged: false, sha: null, message: refusal };
+    }
     let out;
     try {
         out = await gh([
@@ -364,8 +587,145 @@ export async function mergeProjectPr(repo, number, sha, method, gh = ghExec) {
         ]);
     }
     catch (err) {
-        return { repo, number, method: chosen, merged: false, sha: null, message: ghFailure(err) };
+        return { repo, number, method: chosen, merged: false, sha: null, message: readableMergeRefusal(ghFailure(err)) };
     }
-    // GitHub answers this endpoint 200 only once the PR is merged; anything else made gh exit non-zero.
     return { repo, number, method: chosen, merged: true, sha: out.trim() || null, message: 'Merged' };
 }
+function assertHeadIs(repo, number, live, seen) {
+    if (!live.toLowerCase().startsWith(seen.toLowerCase())) {
+        throw new Error(`${repo}#${number} moved to ${live.slice(0, 7)} since you looked at ${seen.slice(0, 7)}; reload it and try again.`);
+    }
+    return live;
+}
+export async function setProjectPrAutoMerge(repo, number, opts, gh = ghExec) {
+    const base = { repo, number };
+    let pr;
+    try {
+        pr = JSON.parse((await gh([
+            'api', `repos/${repo}/pulls/${number}`, '--jq',
+            '{sha: .head.sha, nodeId: .node_id, state: .state, merged: (.merged // false), autoMethod: (.auto_merge.merge_method // null)}',
+        ])).trim());
+    }
+    catch (err) {
+        return { ...base, enabled: false, method: null, message: ghFailure(err) };
+    }
+    const current = { enabled: pr.autoMethod !== null, method: pr.autoMethod };
+    if (pr.state !== 'open')
+        return { ...base, ...current, message: pr.merged ? 'Already merged' : 'The pull request is closed' };
+    if (!opts.enable) {
+        if (!current.enabled)
+            return { ...base, enabled: false, method: null, message: 'Auto-merge was not on' };
+        try {
+            await gh([
+                'api', 'graphql',
+                '-f', 'query=mutation($id: ID!) { disablePullRequestAutoMerge(input: {pullRequestId: $id}) { pullRequest { autoMergeRequest { mergeMethod } } } }',
+                '-f', `id=${pr.nodeId}`,
+                '--jq', '.data.disablePullRequestAutoMerge.pullRequest.autoMergeRequest',
+            ]);
+        }
+        catch (err) {
+            return { ...base, ...current, message: ghFailure(err) };
+        }
+        return { ...base, enabled: false, method: null, message: 'Auto-merge turned off' };
+    }
+    let head;
+    let chosen;
+    try {
+        if (!opts.sha)
+            throw new Error('Auto-merge is pinned to the head you reviewed; pass its SHA.');
+        head = assertHeadIs(repo, number, pr.sha, opts.sha);
+        chosen = opts.method ?? await defaultMergeMethod(repo, gh);
+    }
+    catch (err) {
+        return { ...base, ...current, message: ghFailure(err) };
+    }
+    try {
+        await gh([
+            'api', 'graphql',
+            '-f', 'query=mutation($id: ID!, $method: PullRequestMergeMethod!, $head: GitObjectID!) { enablePullRequestAutoMerge(input: {pullRequestId: $id, mergeMethod: $method, expectedHeadOid: $head}) { pullRequest { autoMergeRequest { mergeMethod } } } }',
+            '-f', `id=${pr.nodeId}`,
+            '-f', `method=${chosen.toUpperCase()}`,
+            '-f', `head=${head}`,
+            '--jq', '.data.enablePullRequestAutoMerge.pullRequest.autoMergeRequest.mergeMethod',
+        ]);
+    }
+    catch (err) {
+        return { ...base, ...current, message: ghFailure(err) };
+    }
+    return { ...base, enabled: true, method: chosen, message: `Auto-merge on (${chosen}); it merges once the required checks pass` };
+}
+export async function markProjectPrReady(repo, number, sha, gh = ghExec) {
+    let head;
+    try {
+        head = JSON.parse((await gh([
+            'api', `repos/${repo}/pulls/${number}`, '--jq',
+            '{sha: .head.sha, draft: (.draft // false), nodeId: .node_id, state: .state, merged: (.merged // false)}',
+        ])).trim());
+        if (sha)
+            assertHeadIs(repo, number, head.sha, sha);
+    }
+    catch (err) {
+        return { repo, number, ready: false, sha: null, message: ghFailure(err) };
+    }
+    if (head.state !== 'open') {
+        return { repo, number, ready: false, sha: head.sha, message: head.merged ? 'Already merged' : 'The pull request is closed' };
+    }
+    if (!head.draft)
+        return { repo, number, ready: true, sha: head.sha, message: 'Already ready for review' };
+    try {
+        await gh([
+            'api', 'graphql',
+            '-f', 'query=mutation($id: ID!) { markPullRequestReadyForReview(input: {pullRequestId: $id}) { pullRequest { isDraft } } }',
+            '-f', `id=${head.nodeId}`,
+            '--jq', '.data.markPullRequestReadyForReview.pullRequest.isDraft',
+        ]);
+    }
+    catch (err) {
+        return { repo, number, ready: false, sha: head.sha, message: ghFailure(err) };
+    }
+    return { repo, number, ready: true, sha: head.sha, message: 'Marked ready for review' };
+}
+export const OWN_PR_APPROVAL = "GitHub doesn't let you approve your own pull request";
+export async function approveProjectPr(repo, number, sha, body, gh = ghExec, viewerLogin = async () => (await cachedViewer())?.login ?? null) {
+    const base = { repo, number, event: 'APPROVE' };
+    let commitId;
+    try {
+        const [live, viewer] = await Promise.all([
+            gh(['api', `repos/${repo}/pulls/${number}`, '--jq', '{sha: .head.sha, author: (.user.login // "")}'])
+                .then((out) => JSON.parse(out.trim())),
+            viewerLogin(),
+        ]);
+        if (viewer && live.author && viewer.toLowerCase() === live.author.toLowerCase()) {
+            return { ...base, submitted: false, sha: live.sha, id: null, url: null, message: OWN_PR_APPROVAL };
+        }
+        if (!live.sha)
+            throw new Error(`no head SHA for ${repo}#${number}`);
+        commitId = assertHeadIs(repo, number, live.sha, sha);
+    }
+    catch (err) {
+        return { ...base, submitted: false, sha: null, id: null, url: null, message: ghFailure(err) };
+    }
+    const args = ['api', '-X', 'POST', `repos/${repo}/pulls/${number}/reviews`, '-f', 'event=APPROVE', '-f', `commit_id=${commitId}`];
+    if (body)
+        args.push('-f', `body=${body}`);
+    let posted;
+    try {
+        posted = JSON.parse((await gh([...args, '--jq', '{id, url: .html_url}'])).trim());
+    }
+    catch (err) {
+        return { ...base, submitted: false, sha: commitId, id: null, url: null, message: ghFailure(err) };
+    }
+    return { ...base, submitted: true, sha: commitId, id: posted.id ?? null, url: posted.url || null, message: 'Approved' };
+}
+export async function commentOnProjectPr(repo, number, body, gh = ghExec) {
+    let posted;
+    try {
+        posted = JSON.parse((await gh([
+            'api', '-X', 'POST', `repos/${repo}/issues/${number}/comments`, '-f', `body=${body}`, '--jq', '{id, url: .html_url}',
+        ])).trim());
+    }
+    catch (err) {
+        return { repo, number, commented: false, id: null, url: null, message: ghFailure(err) };
+    }
+    return { repo, number, commented: true, id: posted.id ?? null, url: posted.url || null, message: 'Commented' };
+}