knodin 0.5.0

package/dist/src/pr-triage.js

@@ -0,0 +1,638 @@
+/**
+ * PR triage — a thin local wrapper around the user's already-authenticated
+ * `gh` CLI. No stored credentials, no auth logic here: this only shells out to
+ * `gh` and joins its output onto the engine's existing `query("impact", ...)`
+ * and `map()` results.
+ *
+ * Shipped CLI-first under R7; R22 additionally exposes this same pipeline
+ * through the `knodin` MCP gateway's `prs` operation (the R7 "CLI-only, never
+ * wire into knodin-tools" ruling is superseded — the no-stored-creds property
+ * it protected is unchanged). The MCP path must never throw into the stdio
+ * transport, so it goes through `ghUnavailableReason()` (non-throwing) rather
+ * than `ensureGhAvailable()` (throwing, still used by the CLI's hard-fail).
+ */
+import child_process from "node:child_process";
+/** Resolve the `gh` binary to invoke. Tests override via `RECKON_GH_BIN` to
+ * point at a stub script fixture — no network in tests. */
+function ghBin() {
+    return process.env.RECKON_GH_BIN || "gh";
+}
+const STALE_DAYS = 30;
+const PR_LIST_FIELDS = "number,title,updatedAt,reviewDecision,statusCheckRollup,files,headRefName";
+const PR_AUDIT_FIELDS = `${PR_LIST_FIELDS},baseRefName,state,mergeCommit,url,isDraft`;
+const GH_MISSING_MSG = "knodin prs requires the GitHub CLI ('gh') on PATH — install it, then run 'gh auth login'.";
+const GH_UNAUTH_MSG = "knodin prs requires an authenticated 'gh' — run 'gh auth login' (gh auth status failed).";
+/** Match a bounded branch glob without compiling user input as a regular expression. */
+export function matchesBranchGlob(value, pattern) {
+    if (pattern.length > 256)
+        return false;
+    let valueIndex = 0;
+    let patternIndex = 0;
+    let starIndex = -1;
+    let starValueIndex = 0;
+    while (valueIndex < value.length) {
+        if (patternIndex < pattern.length &&
+            (pattern[patternIndex] === "?" || pattern[patternIndex] === value[valueIndex])) {
+            valueIndex++;
+            patternIndex++;
+        }
+        else if (patternIndex < pattern.length && pattern[patternIndex] === "*") {
+            starIndex = patternIndex++;
+            starValueIndex = valueIndex;
+        }
+        else if (starIndex >= 0) {
+            patternIndex = starIndex + 1;
+            valueIndex = ++starValueIndex;
+        }
+        else
+            return false;
+    }
+    while (patternIndex < pattern.length && pattern[patternIndex] === "*")
+        patternIndex++;
+    return patternIndex === pattern.length;
+}
+/**
+ * Non-throwing gh-availability probe: returns a one-line reason string when
+ * `gh` is missing from PATH or unauthenticated, or `null` when it's usable.
+ * The MCP path (R22) uses this so a `gh` problem surfaces as a structured
+ * `{ error }` result instead of an exception the stdio transport can't
+ * interpret. Shares its message text with {@link ensureGhAvailable}.
+ */
+export function ghUnavailableReason() {
+    const bin = ghBin();
+    const res = child_process.spawnSync(bin, ["auth", "status"], {
+        encoding: "utf-8",
+        env: process.env,
+    });
+    if (res.error)
+        return GH_MISSING_MSG;
+    if (res.status !== 0)
+        return GH_UNAUTH_MSG;
+    return null;
+}
+/**
+ * Hard-fails fast (one-line message, no stack trace expected from callers)
+ * when `gh` isn't on PATH or isn't authenticated. Required before the single
+ * `gh pr list` call per the R7 spec. Retained for the CLI's hard-fail path;
+ * the MCP path uses {@link ghUnavailableReason} instead.
+ */
+export function ensureGhAvailable() {
+    const reason = ghUnavailableReason();
+    if (reason)
+        throw new Error(reason);
+}
+/** Single `gh pr list` call for open PRs — NO per-PR `gh` calls (per spec). */
+export function fetchOpenPrs(repoPath, limit = 50) {
+    const bin = ghBin();
+    const res = child_process.spawnSync(bin, ["pr", "list", "--json", PR_LIST_FIELDS, "--limit", String(limit)], { cwd: repoPath, encoding: "utf-8", env: process.env });
+    if (res.error) {
+        throw new Error(GH_MISSING_MSG);
+    }
+    if (res.status !== 0) {
+        const stderr = (res.stderr ?? "").toString().trim();
+        throw new Error(`knodin prs: 'gh pr list' failed${stderr ? `: ${stderr}` : ""}`);
+    }
+    const stdout = (res.stdout ?? "").toString().trim();
+    if (!stdout)
+        return [];
+    return JSON.parse(stdout);
+}
+/** `gh pr view <n>` fields — same set as {@link PR_LIST_FIELDS} plus `state`,
+ * needed to filter out a closed/merged PR that `gh pr view` will happily
+ * return even though it isn't "open". */
+const PR_VIEW_FIELDS = `${PR_LIST_FIELDS},state`;
+/**
+ * Single-PR lookup that isn't bounded by `gh pr list`'s `--limit` page: a PR
+ * that exists and is open but falls outside a small `fetchOpenPrs` page (e.g.
+ * an older PR when there are more than `limit` open PRs) must still be found.
+ * Returns `null` — never throws — both when the PR number doesn't exist at
+ * all (`gh pr view`'s failure mode for a bad number) and when it exists but
+ * isn't currently OPEN (closed/merged), matching "not found among open PRs".
+ */
+export function fetchOpenPr(repoPath, prNumber) {
+    const bin = ghBin();
+    const res = child_process.spawnSync(bin, ["pr", "view", String(prNumber), "--json", PR_VIEW_FIELDS], { cwd: repoPath, encoding: "utf-8", env: process.env });
+    if (res.error || res.status !== 0)
+        return null;
+    const stdout = (res.stdout ?? "").toString().trim();
+    if (!stdout)
+        return null;
+    const pr = JSON.parse(stdout);
+    if (pr.state !== "OPEN")
+        return null;
+    return pr;
+}
+/** Collapses a PR's `statusCheckRollup` (CheckRun/StatusContext entries, mixed
+ * `conclusion`/`state`/`status` vocab across GitHub's two check APIs) into one
+ * of `pass | pending | fail | none`. */
+export function computeCiStatus(rollup) {
+    if (!rollup || rollup.length === 0)
+        return "none";
+    const FAIL_CONCLUSIONS = new Set([
+        "FAILURE",
+        "CANCELLED",
+        "TIMED_OUT",
+        "ERROR",
+        "ACTION_REQUIRED",
+        "STARTUP_FAILURE",
+    ]);
+    let pending = false;
+    for (const entry of rollup) {
+        const conclusion = (entry.conclusion ?? "").toUpperCase();
+        const state = (entry.state ?? "").toUpperCase();
+        const status = (entry.status ?? "").toUpperCase();
+        if (FAIL_CONCLUSIONS.has(conclusion) || state === "FAILURE" || state === "ERROR") {
+            return "fail";
+        }
+        if (state === "PENDING" || (status && status !== "COMPLETED")) {
+            pending = true;
+        }
+    }
+    return pending ? "pending" : "pass";
+}
+/**
+ * Classifies a PR per the R7 spec: BLOCKED (changes requested or CI fail)
+ * beats PENDING (CI running) beats STALE (>30d untouched) beats READY (CI
+ * pass and review approved/none-required).
+ */
+export function classifyPr(pr, ci, now = Date.now()) {
+    if (ci === "fail" || pr.reviewDecision === "CHANGES_REQUESTED")
+        return "BLOCKED";
+    if (ci === "pending")
+        return "PENDING";
+    const updatedMs = Date.parse(pr.updatedAt);
+    const ageDays = (now - updatedMs) / (1000 * 60 * 60 * 24);
+    if (Number.isFinite(ageDays) && ageDays > STALE_DAYS)
+        return "STALE";
+    return "READY";
+}
+/**
+ * Shared join for a PR's changed files → `query("impact", ...)` blast radius →
+ * `map()` community membership. Returns `null` when NONE of the PR's changed
+ * files are indexed (deps/workflow-only changes), which both public wrappers
+ * render as their respective "nothing indexed" shape. Names/counts are both
+ * derived from this one traversal so the two wrappers can never disagree.
+ */
+async function joinPrImpact(pr, engine, repoPath) {
+    const changedPaths = (pr.files ?? []).map((f) => f.path).filter(Boolean);
+    if (changedPaths.length === 0)
+        return null;
+    const indexedPaths = [];
+    for (const filePath of changedPaths) {
+        const summary = await engine.query("file_summary", filePath, repoPath);
+        if (summary.count > 0)
+            indexedPaths.push(filePath);
+    }
+    if (indexedPaths.length === 0)
+        return null;
+    const impactResult = await engine.query("impact", indexedPaths.join(","), repoPath, undefined, undefined, undefined, undefined, undefined, { mode: "file" });
+    const impactedFiles = new Set(indexedPaths);
+    for (const row of impactResult.results) {
+        if (row.file)
+            impactedFiles.add(row.file);
+    }
+    const mapResult = await engine.map(repoPath, "standard");
+    const communities = [];
+    for (const community of mapResult.communities) {
+        const files = community.files ?? [];
+        if (files.some((f) => impactedFiles.has(f)))
+            communities.push(community.name);
+    }
+    return { symbolCount: impactResult.count, files: [...impactedFiles], communities };
+}
+/**
+ * Joins a PR's changed files onto `query("impact", ...)` and `map()`
+ * community membership. Files not present in the index (deps, workflows, …)
+ * are dropped before the join; if NONE of a PR's files are indexed the whole
+ * impact is reported as `"–"`, matching graphify's dep-only-PR row.
+ */
+export async function computePrImpact(pr, engine, repoPath) {
+    const joined = await joinPrImpact(pr, engine, repoPath);
+    if (!joined)
+        return { symbols: "–", communities: "–" };
+    return { symbols: joined.symbolCount, communities: joined.communities.length };
+}
+/**
+ * Detailed single-PR impact (R22's `get_pr_impact` equivalent): the impacted
+ * file list and community **names**, not just counts. Returns empty lists when
+ * none of the PR's changed files are indexed.
+ */
+export async function computePrImpactDetail(pr, engine, repoPath) {
+    const joined = await joinPrImpact(pr, engine, repoPath);
+    if (!joined)
+        return { files: [], communities: [] };
+    return { files: joined.files, communities: joined.communities };
+}
+const STATUS_RANK = {
+    READY: 0,
+    PENDING: 1,
+    STALE: 2,
+    BLOCKED: 3,
+};
+/** Numeric sort key for an impact — `"–"` (unindexed/dep-only) sorts as the
+ * smallest, simplest possible change. */
+function impactSortKey(impact) {
+    return impact.symbols === "–" ? 0 : impact.symbols;
+}
+/**
+ * Runs the full R7 pipeline: hard-fail check, single `gh pr list` call,
+ * per-PR classification + impact join, then sorts READY-small-impact first,
+ * then PENDING, then STALE, then BLOCKED.
+ *
+ * `skipGhCheck` lets a caller that already probed gh availability itself
+ * (the MCP dispatcher, via {@link ghUnavailableReason}) skip this function's
+ * own {@link ensureGhAvailable} call — otherwise a single `knodin prs` MCP
+ * call spawns `gh auth status` twice. Defaults to `false` so the CLI's
+ * existing standalone hard-fail behavior is unchanged.
+ */
+export async function triagePrs(repoPath, engine, limit = 50, skipGhCheck = false) {
+    if (!skipGhCheck)
+        ensureGhAvailable();
+    const prs = fetchOpenPrs(repoPath, limit);
+    const triaged = [];
+    for (const pr of prs) {
+        const ci = computeCiStatus(pr.statusCheckRollup);
+        const status = classifyPr(pr, ci);
+        const impact = await computePrImpact(pr, engine, repoPath);
+        triaged.push({
+            number: pr.number,
+            title: pr.title,
+            status,
+            ci,
+            updatedAt: pr.updatedAt,
+            impact,
+        });
+    }
+    triaged.sort((a, b) => {
+        const rankDiff = STATUS_RANK[a.status] - STATUS_RANK[b.status];
+        if (rankDiff !== 0)
+            return rankDiff;
+        return impactSortKey(a.impact) - impactSortKey(b.impact);
+    });
+    return triaged;
+}
+/**
+ * Single-PR detail path (R22): looks up `prNumber` directly via `gh pr view`
+ * (see {@link fetchOpenPr}) — NOT via `fetchOpenPrs(...).find(...)`, since
+ * that's bounded by `--limit` (default 50) and would falsely report "not
+ * found" for a real, open PR that simply falls outside that page — and
+ * returns the detailed impact (file list + community names). Assumes gh
+ * availability was already checked by the caller (the MCP dispatcher probes
+ * {@link ghUnavailableReason} first). Returns a structured `{ error }` —
+ * never throws — when the PR isn't open (missing entirely, or closed/merged).
+ */
+export async function triagePrDetail(repoPath, engine, prNumber, 
+// Kept for call-site compatibility (the MCP dispatcher and CLI both still
+// pass a `limit`), but unused now that lookup goes through `fetchOpenPr`
+// (`gh pr view`) rather than a `--limit`-bounded `gh pr list` page.
+_limit = 50) {
+    const pr = fetchOpenPr(repoPath, prNumber);
+    if (!pr)
+        return { error: `knodin prs: PR #${prNumber} not found among open PRs` };
+    const ci = computeCiStatus(pr.statusCheckRollup);
+    const status = classifyPr(pr, ci);
+    const impact = await computePrImpactDetail(pr, engine, repoPath);
+    return { number: pr.number, title: pr.title, status, ci, updatedAt: pr.updatedAt, impact };
+}
+function ghText(repoPath, args) {
+    const result = child_process.spawnSync(ghBin(), args, {
+        cwd: repoPath,
+        encoding: "utf-8",
+        env: process.env,
+    });
+    if (result.error)
+        return {
+            value: null,
+            error: result.error instanceof Error ? result.error.message : String(result.error),
+        };
+    if (result.status !== 0)
+        return {
+            value: null,
+            error: (result.stderr ?? "").toString().trim() || `gh ${args.join(" ")} failed`,
+        };
+    return { value: (result.stdout ?? "").toString().trim(), error: null };
+}
+function revisionCommits(repoPath, base, head) {
+    if (!base && !head)
+        return { commits: null, error: null };
+    if (!base || !head)
+        return { commits: null, error: "both --base and --head are required for revision auditing" };
+    const result = child_process.spawnSync("git", ["rev-list", `${base}..${head}`], {
+        cwd: repoPath,
+        encoding: "utf-8",
+    });
+    if (result.status !== 0)
+        return {
+            commits: null,
+            error: (result.stderr ?? "").toString().trim() || `unable to resolve ${base}..${head}`,
+        };
+    return {
+        commits: new Set((result.stdout ?? "").toString().split(/\r?\n/).filter(Boolean)),
+        error: null,
+    };
+}
+function rulesetPatternMatches(pattern, branch, defaultBranch) {
+    if (pattern === "~ALL")
+        return true;
+    if (pattern === "~DEFAULT_BRANCH")
+        return defaultBranch === branch;
+    const ref = `refs/heads/${branch}`;
+    return (pattern === branch ||
+        pattern === ref ||
+        matchesBranchGlob(branch, pattern) ||
+        matchesBranchGlob(ref, pattern));
+}
+function rulesetAppliesToBranch(ruleset, branch, defaultBranch) {
+    if (ruleset.target !== "branch" || ruleset.enforcement !== "active")
+        return false;
+    const names = ruleset.conditions?.ref_name;
+    const excluded = (names?.exclude ?? []).some((pattern) => rulesetPatternMatches(pattern, branch, defaultBranch));
+    if (excluded)
+        return false;
+    const included = names?.include ?? [];
+    return (included.length === 0 ||
+        included.some((pattern) => rulesetPatternMatches(pattern, branch, defaultBranch)));
+}
+function rulesetRequiredChecks(repoPath, repository, branch, defaultBranch) {
+    const listed = ghText(repoPath, ["api", `repos/${repository}/rulesets?includes_parents=true`]);
+    if (listed.error)
+        return { checks: null, error: listed.error };
+    let summaries;
+    try {
+        summaries = JSON.parse(listed.value || "[]");
+        if (!Array.isArray(summaries))
+            throw new Error("expected an array");
+    }
+    catch (error) {
+        return {
+            checks: null,
+            error: `invalid ruleset list JSON (${error instanceof Error ? error.message : String(error)})`,
+        };
+    }
+    const checks = [];
+    for (const summary of summaries) {
+        if (summary.id === undefined)
+            continue;
+        const detail = ghText(repoPath, [
+            "api",
+            `repos/${repository}/rulesets/${summary.id}?includes_parents=true`,
+        ]);
+        if (detail.error)
+            return { checks: null, error: `ruleset ${summary.id}: ${detail.error}` };
+        let ruleset;
+        try {
+            ruleset = JSON.parse(detail.value || "{}");
+        }
+        catch (error) {
+            return {
+                checks: null,
+                error: `ruleset ${summary.id}: invalid JSON (${error instanceof Error ? error.message : String(error)})`,
+            };
+        }
+        if (!rulesetAppliesToBranch(ruleset, branch, defaultBranch))
+            continue;
+        for (const rule of ruleset.rules ?? []) {
+            if (rule.type === "required_status_checks") {
+                for (const check of rule.parameters?.required_status_checks ?? []) {
+                    checks.push({
+                        ...check,
+                        source: "ruleset",
+                        rulesetId: ruleset.id ?? summary.id,
+                        rulesetName: ruleset.name ?? summary.name ?? null,
+                        ruleType: rule.type,
+                    });
+                }
+            }
+            if (rule.type === "workflows") {
+                for (const workflow of rule.parameters?.workflows ?? []) {
+                    checks.push({
+                        ...workflow,
+                        context: workflow.path ?? null,
+                        source: "ruleset",
+                        rulesetId: ruleset.id ?? summary.id,
+                        rulesetName: ruleset.name ?? summary.name ?? null,
+                        ruleType: rule.type,
+                    });
+                }
+            }
+        }
+    }
+    return { checks, error: null };
+}
+function auditSupplement(repoPath, repository, pr, defaultBranch) {
+    const errors = [];
+    let requiredChecks = null;
+    const required = ghText(repoPath, [
+        "api",
+        `repos/${repository}/branches/${encodeURIComponent(pr.baseRefName ?? "")}/protection/required_status_checks`,
+    ]);
+    if (required.error?.includes("HTTP 404")) {
+        const fallback = rulesetRequiredChecks(repoPath, repository, pr.baseRefName ?? "", defaultBranch);
+        if (fallback.error)
+            errors.push(`PR #${pr.number} required checks: classic protection unavailable (${required.error}); rulesets: ${fallback.error}`);
+        else
+            requiredChecks = fallback.checks;
+    }
+    else if (required.error)
+        errors.push(`PR #${pr.number} required checks: ${required.error}`);
+    else {
+        try {
+            const parsed = JSON.parse(required.value || "{}");
+            requiredChecks = parsed.checks ?? parsed.contexts ?? [];
+        }
+        catch (error) {
+            errors.push(`PR #${pr.number} required checks: invalid JSON (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    const [owner, name] = repository.split("/", 2);
+    const threads = ghText(repoPath, [
+        "api",
+        "graphql",
+        "-f",
+        "query=query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){pullRequest(number:$number){reviewThreads(first:100){nodes{isResolved isOutdated}pageInfo{hasNextPage}}}}}",
+        "-F",
+        `owner=${owner}`,
+        "-F",
+        `name=${name}`,
+        "-F",
+        `number=${pr.number}`,
+    ]);
+    let unresolvedActionableThreads = null;
+    if (threads.error)
+        errors.push(`PR #${pr.number} review threads: ${threads.error}`);
+    else {
+        try {
+            const parsed = JSON.parse(threads.value || "{}");
+            const reviewThreads = parsed.data?.repository?.pullRequest?.reviewThreads;
+            if (reviewThreads?.pageInfo?.hasNextPage)
+                errors.push(`PR #${pr.number} review threads: incomplete response exceeds 100 threads`);
+            else
+                unresolvedActionableThreads = (reviewThreads?.nodes ?? []).filter((thread) => !thread.isResolved && !thread.isOutdated).length;
+        }
+        catch (error) {
+            errors.push(`PR #${pr.number} review threads: invalid JSON (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    const branch = ghText(repoPath, [
+        "api",
+        `repos/${repository}/git/ref/heads/${encodeURIComponent(pr.headRefName)}`,
+    ]);
+    const headBranchSurvives = branch.error
+        ? branch.error.includes("HTTP 404")
+            ? false
+            : null
+        : true;
+    if (branch.error && headBranchSurvives === null)
+        errors.push(`PR #${pr.number} head branch: ${branch.error}`);
+    return { requiredChecks, unresolvedActionableThreads, headBranchSurvives, errors };
+}
+/** Completion-oriented, schema-versioned PR evidence without mutating gh account state. */
+export async function auditPullRequests(repoPath, engine, options = {}) {
+    const errors = [];
+    const repositoryResult = ghText(repoPath, [
+        "repo",
+        "view",
+        "--json",
+        "nameWithOwner,url,defaultBranchRef",
+    ]);
+    if (repositoryResult.error)
+        errors.push(`repository: ${repositoryResult.error}`);
+    let repository = null;
+    let host = null;
+    let defaultBranch = null;
+    try {
+        const resolved = JSON.parse(repositoryResult.value || "{}");
+        repository = resolved.nameWithOwner ?? null;
+        host = resolved.url ? new URL(resolved.url).host : null;
+        defaultBranch = resolved.defaultBranchRef?.name ?? null;
+    }
+    catch (error) {
+        errors.push(`repository: invalid JSON (${error instanceof Error ? error.message : String(error)})`);
+    }
+    const loginResult = ghText(repoPath, [
+        "api",
+        ...(host ? ["--hostname", host] : []),
+        "user",
+        "--jq",
+        ".login",
+    ]);
+    if (loginResult.error)
+        errors.push(`authentication: ${loginResult.error}`);
+    const authenticatedAs = loginResult.value;
+    if (options.expectedLogin && authenticatedAs && options.expectedLogin !== authenticatedAs) {
+        errors.push(`authenticated login mismatch: expected ${options.expectedLogin}, resolved ${authenticatedAs}`);
+    }
+    if (!repository || !authenticatedAs || errors.some((error) => error.includes("login mismatch"))) {
+        return {
+            schemaVersion: 1,
+            status: "unavailable",
+            repository,
+            host,
+            authenticatedAs,
+            resultCount: null,
+            pullRequests: [],
+            errors,
+        };
+    }
+    const state = options.state ?? "open";
+    if (!["open", "merged", "closed", "all"].includes(state))
+        errors.push(`pull requests: unsupported state ${state}`);
+    if (options.range && !/^\d+\.\.\d+$/.test(options.range))
+        errors.push(`pull requests: invalid range ${options.range}; expected N..N`);
+    const revisions = revisionCommits(repoPath, options.base, options.head);
+    if (revisions.error)
+        errors.push(`revision range: ${revisions.error}`);
+    if (errors.length > 0) {
+        return {
+            schemaVersion: 1,
+            status: "unavailable",
+            repository,
+            host,
+            authenticatedAs,
+            resultCount: null,
+            pullRequests: [],
+            errors,
+        };
+    }
+    const list = ghText(repoPath, [
+        "pr",
+        "list",
+        "--state",
+        state,
+        "--limit",
+        String(options.limit ?? 50),
+        "--json",
+        PR_AUDIT_FIELDS,
+    ]);
+    if (list.error) {
+        errors.push(`pull requests: ${list.error}`);
+        return {
+            schemaVersion: 1,
+            status: "unavailable",
+            repository,
+            host,
+            authenticatedAs,
+            resultCount: null,
+            pullRequests: [],
+            errors,
+        };
+    }
+    let raw;
+    try {
+        raw = list.value ? JSON.parse(list.value) : [];
+    }
+    catch (error) {
+        errors.push(`pull requests: invalid JSON (${error instanceof Error ? error.message : String(error)})`);
+        raw = [];
+    }
+    const branchGlob = options.branches ?? null;
+    const range = options.range?.match(/^(\d+)\.\.(\d+)$/);
+    const minimum = range ? Number(range[1]) : null;
+    const maximum = range ? Number(range[2]) : null;
+    const selected = raw.filter((pr) => (!branchGlob || matchesBranchGlob(pr.headRefName, branchGlob)) &&
+        (minimum === null || maximum === null || (pr.number >= minimum && pr.number <= maximum)) &&
+        (revisions.commits === null ||
+            (pr.mergeCommit?.oid !== undefined && revisions.commits.has(pr.mergeCommit.oid))));
+    const pullRequests = [];
+    for (const pr of selected) {
+        const ci = computeCiStatus(pr.statusCheckRollup);
+        const supplement = auditSupplement(repoPath, repository, pr, defaultBranch);
+        errors.push(...supplement.errors);
+        pullRequests.push({
+            number: pr.number,
+            title: pr.title,
+            state: pr.state ?? state.toUpperCase(),
+            head: pr.headRefName,
+            base: pr.baseRefName ?? null,
+            mergeCommit: pr.mergeCommit?.oid ?? null,
+            url: pr.url ?? null,
+            isDraft: pr.isDraft ?? false,
+            reviewDecision: pr.reviewDecision,
+            approval: pr.reviewDecision === "APPROVED",
+            ci,
+            triageStatus: classifyPr(pr, ci),
+            observedChecks: pr.statusCheckRollup ?? [],
+            requiredChecks: supplement.requiredChecks,
+            unresolvedActionableThreads: supplement.unresolvedActionableThreads,
+            headBranchSurvives: supplement.headBranchSurvives,
+            impact: await computePrImpact(pr, engine, repoPath),
+        });
+    }
+    return {
+        schemaVersion: 1,
+        status: errors.length > 0 ? "partial" : "ok",
+        repository,
+        host,
+        authenticatedAs,
+        state,
+        resultCount: pullRequests.length,
+        pullRequests,
+        errors,
+        revisionRange: options.base && options.head
+            ? { base: options.base, head: options.head, commitCount: revisions.commits?.size ?? null }
+            : null,
+        limitations: [
+            "review-thread evidence is intentionally incomplete when a PR exceeds 100 threads",
+        ],
+    };
+}