@junctionpanel/server 0.1.69 → 0.1.70

package/dist/server/utils/checkout-git.js

@@ -4,6 +4,7 @@ import { resolve, dirname, basename } from "path";
 import { realpathSync } from "fs";
 import { open as openFile, stat as statFile } from "fs/promises";
 import { parseAndHighlightDiff } from "../server/utils/diff-highlighter.js";
+import { expandTilde } from "./path.js";
 import { isJunctionOwnedWorktreeCwd } from "./worktree.js";
 import { requireJunctionWorktreeBaseRefName } from "./worktree-metadata.js";
 const execAsync = promisify(exec);
@@ -71,6 +72,7 @@ async function spawnLimitedText(params) {
             }
             resolvePromise({
                 text: Buffer.concat(stdoutChunks).toString("utf8"),
+                stderrText: stderrPreview.trim(),
                 truncated,
                 exitCode: code,
                 signal,
@@ -411,6 +413,19 @@ async function getCurrentBranch(cwd) {
         return null;
     }
 }
+async function getCurrentHeadSha(cwd) {
+    try {
+        const { stdout } = await execAsync("git rev-parse --verify HEAD", {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+        });
+        const headSha = stdout.trim();
+        return headSha.length > 0 ? headSha : null;
+    }
+    catch {
+        return null;
+    }
+}
 async function getWorktreeRoot(cwd) {
     try {
         const { stdout } = await execAsync("git rev-parse --path-format=absolute --show-toplevel", { cwd, env: READ_ONLY_GIT_ENV });
@@ -1474,6 +1489,23 @@ export async function pushCurrentBranch(cwd, options) {
 const GH_JSON_MAX_BYTES = 512 * 1024;
 const GH_FAILED_LOG_MAX_BYTES = 200 * 1024;
 const GH_FAILED_LOG_TOTAL_MAX_BYTES = 300 * 1024;
+const PULL_REQUEST_STATUS_ACTIVE_CACHE_MS = 15000;
+const PULL_REQUEST_STATUS_PASSIVE_CACHE_MS = 3 * 60000;
+const PULL_REQUEST_STATUS_READY_CACHE_MS = 45000;
+const PULL_REQUEST_STATUS_MERGED_CACHE_MS = 5 * 60000;
+const PULL_REQUEST_STATUS_EMPTY_CACHE_MS = 90000;
+const PULL_REQUEST_SEARCH_CACHE_MS = 15000;
+const PULL_REQUEST_LOOKUP_CACHE_MAX_ENTRIES = 256;
+const PULL_REQUEST_SEARCH_CACHE_MAX_ENTRIES = 128;
+const pullRequestLookupCache = new Map();
+const pullRequestLookupCacheGenerationByCwd = new Map();
+const pullRequestSearchCache = new Map();
+export class PullRequestRateLimitError extends Error {
+    constructor(message = "GitHub rate limit reached while loading pull request data") {
+        super(message);
+        this.name = "PullRequestRateLimitError";
+    }
+}
 async function ensureGhAvailable(cwd) {
     try {
         await execAsync("gh --version", { cwd });
@@ -1501,6 +1533,61 @@ function isGhAuthError(error) {
         text.includes("bad credentials") ||
         text.includes("http 401"));
 }
+function isGhRateLimitError(error) {
+    const text = getCommandErrorText(error);
+    return (text.includes("rate limit") ||
+        text.includes("secondary rate limit") ||
+        text.includes("retry-after") ||
+        text.includes("x-ratelimit") ||
+        text.includes("abuse detection"));
+}
+function indicatesNoRequiredChecks(text) {
+    const normalized = text.toLowerCase();
+    return (normalized.includes("no checks reported") ||
+        normalized.includes("no required checks reported"));
+}
+function normalizePullRequestDetailLevel(detailLevel) {
+    return detailLevel ?? "detail";
+}
+function hasSufficientPullRequestDetail(cached, requested) {
+    if (cached === "detail") {
+        return true;
+    }
+    return requested === "summary";
+}
+function normalizePullRequestCacheScope(input) {
+    return {
+        cwd: expandTilde(input.cwd.trim()),
+        remoteName: input.remoteName?.trim() || null,
+    };
+}
+function getPullRequestLookupCacheGeneration(cwd) {
+    const normalizedScope = normalizePullRequestCacheScope({ cwd });
+    return pullRequestLookupCacheGenerationByCwd.get(normalizedScope.cwd) ?? 0;
+}
+function bumpPullRequestLookupCacheGeneration(cwd) {
+    const normalizedScope = normalizePullRequestCacheScope({ cwd });
+    const nextGeneration = getPullRequestLookupCacheGeneration(normalizedScope.cwd) + 1;
+    pullRequestLookupCacheGenerationByCwd.set(normalizedScope.cwd, nextGeneration);
+    return nextGeneration;
+}
+function resolvePullRequestLookupMaxAgeMs(input) {
+    if (!input.status) {
+        return PULL_REQUEST_STATUS_EMPTY_CACHE_MS;
+    }
+    if (input.status.isMerged) {
+        return PULL_REQUEST_STATUS_MERGED_CACHE_MS;
+    }
+    if (input.detailLevel === "summary") {
+        return PULL_REQUEST_STATUS_PASSIVE_CACHE_MS;
+    }
+    if (input.status.requiredChecksPassed === true &&
+        input.status.canMerge === true &&
+        input.status.hasConflicts === false) {
+        return PULL_REQUEST_STATUS_READY_CACHE_MS;
+    }
+    return PULL_REQUEST_STATUS_ACTIVE_CACHE_MS;
+}
 function parseGitHubRepoFromRemoteUrl(url) {
     let cleaned = url.trim();
     if (!cleaned) {
@@ -1553,6 +1640,23 @@ async function hasAuthenticatedGitHubCliSession(cwd) {
         throw error;
     }
 }
+async function ghApiJson(input) {
+    const result = await spawnLimitedText({
+        cmd: "gh",
+        args: ["api", ...input.args],
+        cwd: input.cwd,
+        maxBytes: GH_JSON_MAX_BYTES,
+        acceptExitCodes: input.acceptExitCodes,
+    });
+    if (result.truncated) {
+        throw new Error(`GitHub API response exceeded the ${GH_JSON_MAX_BYTES} byte limit.`);
+    }
+    const text = result.text.trim();
+    if (!text) {
+        throw new Error(`GitHub API returned an empty response for: gh api ${input.args.join(" ")}`);
+    }
+    return JSON.parse(text);
+}
 async function listPullRequestsForHead(options) {
     const { stdout } = await execFileAsync("gh", [
         "api",
@@ -1567,6 +1671,125 @@ async function listPullRequestsForHead(options) {
     const parsed = JSON.parse(stdout.trim());
     return Array.isArray(parsed) ? parsed : [];
 }
+function buildPullRequestLookupCacheKey(input) {
+    const normalizedScope = normalizePullRequestCacheScope({
+        cwd: input.cwd,
+        remoteName: input.remoteName,
+    });
+    return JSON.stringify([
+        normalizedScope.cwd,
+        normalizedScope.remoteName ?? "",
+        input.repoIdentity?.trim() ?? "",
+        input.branch.trim(),
+    ]);
+}
+function getCompatiblePullRequestLookup(input) {
+    prunePullRequestLookupCache();
+    const cached = pullRequestLookupCache.get(input.cacheKey);
+    if (!cached) {
+        return null;
+    }
+    if (cached.localHeadSha !== input.localHeadSha) {
+        pullRequestLookupCache.delete(input.cacheKey);
+        return null;
+    }
+    if (!hasSufficientPullRequestDetail(cached.lookup.detailLevel, input.detailLevel)) {
+        return null;
+    }
+    return cached.lookup;
+}
+function getCachedPullRequestLookup(input) {
+    const cached = getCompatiblePullRequestLookup(input);
+    if (!cached) {
+        return null;
+    }
+    if (Date.now() - cached.fetchedAt > input.maxAgeMs) {
+        pullRequestLookupCache.delete(input.cacheKey);
+        return null;
+    }
+    return cached;
+}
+function setCachedPullRequestLookup(cacheKey, localHeadSha, lookup, options) {
+    if (getPullRequestLookupCacheGeneration(options.cwd) !== options.generation) {
+        return lookup;
+    }
+    prunePullRequestLookupCache();
+    pullRequestLookupCache.set(cacheKey, {
+        lookup,
+        localHeadSha,
+    });
+    prunePullRequestLookupCache();
+    return lookup;
+}
+function getPullRequestLookupEntryMaxAgeMs(entry) {
+    return resolvePullRequestLookupMaxAgeMs({
+        detailLevel: entry.lookup.detailLevel,
+        status: entry.lookup.status,
+    });
+}
+function prunePullRequestLookupCache(now = Date.now()) {
+    for (const [key, entry] of pullRequestLookupCache.entries()) {
+        if (now - entry.lookup.fetchedAt > getPullRequestLookupEntryMaxAgeMs(entry)) {
+            pullRequestLookupCache.delete(key);
+        }
+    }
+    while (pullRequestLookupCache.size > PULL_REQUEST_LOOKUP_CACHE_MAX_ENTRIES) {
+        const oldestKey = pullRequestLookupCache.keys().next().value;
+        if (typeof oldestKey !== "string") {
+            break;
+        }
+        pullRequestLookupCache.delete(oldestKey);
+    }
+}
+function prunePullRequestSearchCache(now = Date.now()) {
+    for (const [key, entry] of pullRequestSearchCache.entries()) {
+        if (now - entry.fetchedAt > PULL_REQUEST_SEARCH_CACHE_MS) {
+            pullRequestSearchCache.delete(key);
+        }
+    }
+    while (pullRequestSearchCache.size > PULL_REQUEST_SEARCH_CACHE_MAX_ENTRIES) {
+        const oldestKey = pullRequestSearchCache.keys().next().value;
+        if (typeof oldestKey !== "string") {
+            break;
+        }
+        pullRequestSearchCache.delete(oldestKey);
+    }
+}
+/**
+ * Clear cached pull request lookup and search entries for a workspace.
+ *
+ * When `options.remoteName` is omitted, entries across every remote for the
+ * normalized workspace path are cleared.
+ */
+export function invalidatePullRequestCache(cwd, options) {
+    prunePullRequestLookupCache();
+    prunePullRequestSearchCache();
+    const normalizedScope = normalizePullRequestCacheScope({
+        cwd,
+        remoteName: options?.remoteName,
+    });
+    bumpPullRequestLookupCacheGeneration(normalizedScope.cwd);
+    for (const key of pullRequestLookupCache.keys()) {
+        const [entryCwd, entryRemoteName] = JSON.parse(key);
+        if (entryCwd !== normalizedScope.cwd) {
+            continue;
+        }
+        if (normalizedScope.remoteName !== null && entryRemoteName !== normalizedScope.remoteName) {
+            continue;
+        }
+        pullRequestLookupCache.delete(key);
+    }
+    for (const key of pullRequestSearchCache.keys()) {
+        const [entryCwd, entryRemoteName] = JSON.parse(key);
+        if (entryCwd !== normalizedScope.cwd) {
+            continue;
+        }
+        if (normalizedScope.remoteName !== null && entryRemoteName !== normalizedScope.remoteName) {
+            continue;
+        }
+        pullRequestSearchCache.delete(key);
+    }
+}
 function matchesPullRequestHeadRef(current, expectedHead) {
     if (!current || typeof current !== "object") {
         return false;
@@ -1667,6 +1890,7 @@ function parsePullRequestChecks(input) {
                 : null,
             state,
             bucket,
+            required: true,
         };
     })
         .filter((entry) => entry !== null);
@@ -1690,64 +1914,114 @@ async function getRequiredPullRequestChecks(cwd, prNumber) {
         });
     }
     catch (error) {
-        if (getCommandErrorText(error).includes("no checks reported")) {
+        if (indicatesNoRequiredChecks(getCommandErrorText(error))) {
             return [];
         }
         throw error;
     }
     const text = result.text.trim();
     if (!text) {
-        return [];
+        if (result.exitCode === 0 || indicatesNoRequiredChecks(result.stderrText)) {
+            return [];
+        }
+        throw new Error(result.stderrText || `gh pr checks returned no JSON output for PR #${prNumber}.`);
     }
     return parsePullRequestChecks(JSON.parse(text));
 }
-function parseStatusCheckRollup(input) {
-    if (!Array.isArray(input)) {
-        return [];
-    }
-    return input
-        .map((entry) => {
+function parseRestCheckRuns(input) {
+    const runs = Array.isArray(input)
+        ? input.flatMap((page) => page && typeof page === "object" && Array.isArray(page.check_runs)
+            ? page.check_runs
+            : [])
+        : input && typeof input === "object" && Array.isArray(input.check_runs)
+            ? input.check_runs
+            : [];
+    const parsedRuns = [];
+    for (const entry of runs) {
         if (!entry || typeof entry !== "object") {
-            return null;
+            continue;
         }
-        const statusValue = typeof entry.status === "string" && entry.status.trim().length > 0
-            ? entry.status.trim()
-            : typeof entry.state === "string" && entry.state.trim().length > 0
-                ? entry.state.trim()
-                : "";
-        const conclusionValue = typeof entry.conclusion === "string" && entry.conclusion.trim().length > 0
-            ? entry.conclusion.trim()
+        const run = entry;
+        const statusValue = typeof run.status === "string" && run.status.trim().length > 0
+            ? run.status.trim()
+            : "";
+        const conclusionValue = typeof run.conclusion === "string" && run.conclusion.trim().length > 0
+            ? run.conclusion.trim()
             : "";
-        const bucket = normalizeCheckBucket(undefined, conclusionValue || statusValue) ??
-            (statusValue.toLowerCase() === "completed" && conclusionValue
-                ? normalizeCheckBucket(undefined, conclusionValue)
-                : null);
-        const name = typeof entry.name === "string" && entry.name.trim().length > 0
-            ? entry.name.trim()
-            : typeof entry.context === "string" && entry.context.trim().length > 0
-                ? entry.context.trim()
-                : "";
+        const state = conclusionValue || statusValue;
+        const bucket = normalizeCheckBucket(undefined, state);
+        const name = typeof run.name === "string" ? run.name.trim() : "";
         if (!bucket || !name) {
-            return null;
+            continue;
         }
-        return {
+        parsedRuns.push({
             name,
-            workflow: typeof entry.workflowName === "string" && entry.workflowName.trim().length > 0
-                ? entry.workflowName.trim()
-                : null,
-            link: typeof entry.detailsUrl === "string" && entry.detailsUrl.trim().length > 0
-                ? entry.detailsUrl.trim()
-                : typeof entry.targetUrl === "string" && entry.targetUrl.trim().length > 0
-                    ? entry.targetUrl.trim()
+            workflow: null,
+            link: typeof run.details_url === "string" && run.details_url.trim().length > 0
+                ? run.details_url.trim()
+                : typeof run.html_url === "string" && run.html_url.trim().length > 0
+                    ? run.html_url.trim()
                     : null,
-            description: typeof entry.description === "string" && entry.description.trim().length > 0
-                ? entry.description.trim()
+            description: null,
+            state,
+            bucket,
+            required: false,
+        });
+    }
+    return parsedRuns;
+}
+function parseRestCombinedStatuses(input) {
+    const pages = Array.isArray(input) ? input : [input];
+    const statuses = pages.flatMap((page) => {
+        if (!page || typeof page !== "object") {
+            return [];
+        }
+        return Array.isArray(page.statuses)
+            ? page.statuses
+            : [];
+    });
+    const parsedStatuses = [];
+    for (const entry of statuses) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const statusEntry = entry;
+        const state = typeof statusEntry.state === "string" ? statusEntry.state.trim() : "";
+        const bucket = normalizeCheckBucket(undefined, state);
+        const name = typeof statusEntry.context === "string" ? statusEntry.context.trim() : "";
+        if (!bucket || !name) {
+            continue;
+        }
+        parsedStatuses.push({
+            name,
+            workflow: null,
+            link: typeof statusEntry.target_url === "string" &&
+                statusEntry.target_url.trim().length > 0
+                ? statusEntry.target_url.trim()
+                : null,
+            description: typeof statusEntry.description === "string" &&
+                statusEntry.description.trim().length > 0
+                ? statusEntry.description.trim()
                 : null,
-            state: conclusionValue || statusValue,
+            state,
             bucket,
-        };
-    })
-        .filter((entry) => entry !== null);
+            required: false,
+        });
+    }
+    return parsedStatuses;
+}
+async function getPullRequestChecksViaRest(cwd, repo, ref) {
+    const [checkRuns, combinedStatuses] = await Promise.all([
+        ghApiJson({
+            cwd,
+            args: ["--paginate", "--slurp", `repos/${repo}/commits/${ref}/check-runs?per_page=100`],
+        }),
+        ghApiJson({
+            cwd,
+            args: ["--paginate", "--slurp", `repos/${repo}/commits/${ref}/status?per_page=100`],
+        }),
+    ]);
+    return mergeCheckStatuses(parseRestCombinedStatuses(combinedStatuses), parseRestCheckRuns(checkRuns));
 }
 function mergeCheckStatuses(requiredChecks, rollupChecks) {
     const merged = new Map();
@@ -1770,39 +2044,39 @@ function deriveChecksState(checks) {
     }
     return "passing";
 }
-async function getPullRequestMergeability(cwd, prNumber) {
-    const result = await spawnLimitedText({
-        cmd: "gh",
-        args: [
-            "pr",
-            "view",
-            String(prNumber),
-            "--json",
-            "mergeable,mergeStateStatus,statusCheckRollup",
-        ],
+async function getPullRequestMergeabilityViaRest(cwd, repo, prNumber) {
+    const parsed = await ghApiJson({
         cwd,
-        maxBytes: GH_JSON_MAX_BYTES,
+        args: [`repos/${repo}/pulls/${prNumber}`],
     });
-    const text = result.text.trim();
-    if (!text) {
-        return { hasConflicts: false, rollupChecks: [] };
-    }
-    const parsed = JSON.parse(text);
-    const mergeable = typeof parsed.mergeable === "string" ? parsed.mergeable.trim().toUpperCase() : "";
-    const mergeStateStatus = typeof parsed.mergeStateStatus === "string"
-        ? parsed.mergeStateStatus.trim().toUpperCase()
+    const mergeable = typeof parsed.mergeable === "boolean" ? parsed.mergeable : null;
+    const mergeableState = typeof parsed.mergeable_state === "string"
+        ? parsed.mergeable_state.trim().toUpperCase()
         : "";
     return {
-        hasConflicts: mergeable === "CONFLICTING" || mergeStateStatus === "DIRTY",
-        rollupChecks: parseStatusCheckRollup(parsed.statusCheckRollup),
+        hasConflicts: mergeable === false || mergeableState === "DIRTY",
+        mergeableKnown: mergeable !== null || (mergeableState.length > 0 && mergeableState !== "UNKNOWN"),
     };
 }
-function toPullRequestStatus(baseStatus, checks, mergeability) {
-    const checksState = baseStatus.isMerged ? "passing" : deriveChecksState(checks);
+function toPullRequestStatus(baseStatus, checks, mergeability, options) {
+    const requiredChecks = checks.filter((check) => check.required);
+    const requiredChecksKnown = options?.requiredChecksKnown ?? true;
+    const checksState = baseStatus.isMerged
+        ? "passing"
+        : !requiredChecksKnown
+            ? deriveChecksState(checks)
+            : requiredChecks.length === 0
+                ? "passing"
+                : deriveChecksState(requiredChecks);
     const requiredChecksPassed = baseStatus.isMerged
         ? true
-        : checks.every((check) => check.bucket === "pass" || check.bucket === "skipping");
+        : !requiredChecksKnown
+            ? false
+            : requiredChecks.length === 0
+                ? true
+                : requiredChecks.every((check) => check.bucket === "pass" || check.bucket === "skipping");
     const hasConflicts = baseStatus.isMerged ? false : (mergeability?.hasConflicts ?? false);
+    const mergeableKnown = baseStatus.isMerged ? true : (mergeability?.mergeableKnown ?? true);
     return {
         number: baseStatus.number,
         url: baseStatus.url,
@@ -1811,9 +2085,14 @@ function toPullRequestStatus(baseStatus, checks, mergeability) {
         baseRefName: baseStatus.baseRefName,
         headRefName: baseStatus.headRefName,
         isMerged: baseStatus.isMerged,
+        detailLevel: "detail",
         checksState,
         requiredChecksPassed,
-        canMerge: !baseStatus.isMerged && !baseStatus.draft && requiredChecksPassed && !hasConflicts,
+        canMerge: !baseStatus.isMerged &&
+            !baseStatus.draft &&
+            requiredChecksPassed &&
+            !hasConflicts &&
+            mergeableKnown,
         hasConflicts,
     };
 }
@@ -1940,17 +2219,68 @@ function appendBoundedText(parts, next, currentBytes) {
     parts.push(`${truncated}\n\n[combined log output truncated]`);
     return GH_FAILED_LOG_TOTAL_MAX_BYTES;
 }
+function toSummaryOnlyPullRequestStatus(baseStatus) {
+    return {
+        number: baseStatus.number,
+        url: baseStatus.url,
+        title: baseStatus.title,
+        state: baseStatus.state,
+        baseRefName: baseStatus.baseRefName,
+        headRefName: baseStatus.headRefName,
+        isMerged: baseStatus.isMerged,
+        detailLevel: "summary",
+        checksState: null,
+        requiredChecksPassed: null,
+        canMerge: null,
+        hasConflicts: null,
+    };
+}
 async function loadCurrentPullRequest(cwd, options) {
     await requireGitRepo(cwd);
+    const detailLevel = normalizePullRequestDetailLevel(options?.detailLevel);
     const head = await getCurrentBranch(cwd);
+    const localHeadSha = await getCurrentHeadSha(cwd);
     if (!head) {
         return {
             status: null,
             githubFeaturesEnabled: false,
             checks: [],
             headSha: null,
+            repo: null,
+            detailLevel,
+            fetchedAt: Date.now(),
         };
     }
+    const remoteName = await resolveEffectiveRemoteName(cwd, options?.remoteName);
+    const remoteUrl = remoteName ? await getRemoteUrl(cwd, remoteName) : null;
+    const cacheKey = buildPullRequestLookupCacheKey({
+        cwd,
+        remoteName,
+        repoIdentity: remoteUrl,
+        branch: head,
+    });
+    const cacheGeneration = getPullRequestLookupCacheGeneration(cwd);
+    const compatibleCachedLookup = getCompatiblePullRequestLookup({
+        cacheKey,
+        detailLevel,
+        localHeadSha,
+    });
+    const maxAgeMs = options?.maxAgeMs ??
+        resolvePullRequestLookupMaxAgeMs({
+            detailLevel,
+            status: compatibleCachedLookup?.status ?? null,
+        });
+    const freshCachedLookup = options?.forceRefresh
+        ? null
+        : getCachedPullRequestLookup({
+            cacheKey,
+            detailLevel,
+            maxAgeMs,
+            localHeadSha,
+        });
+    if (freshCachedLookup) {
+        return freshCachedLookup;
+    }
     try {
         await ensureGhAvailable(cwd);
     }
@@ -1960,10 +2290,11 @@ async function loadCurrentPullRequest(cwd, options) {
             githubFeaturesEnabled: false,
             checks: [],
             headSha: null,
+            repo: null,
+            detailLevel,
+            fetchedAt: Date.now(),
         };
     }
-    const remoteName = await resolveEffectiveRemoteName(cwd, options?.remoteName);
-    const remoteUrl = remoteName ? await getRemoteUrl(cwd, remoteName) : null;
     if (!remoteUrl) {
         const hasAuthenticatedGhSession = await hasAuthenticatedGitHubCliSession(cwd);
         return {
@@ -1971,6 +2302,9 @@ async function loadCurrentPullRequest(cwd, options) {
             githubFeaturesEnabled: hasAuthenticatedGhSession,
             checks: [],
             headSha: null,
+            repo: null,
+            detailLevel,
+            fetchedAt: Date.now(),
         };
     }
     const repo = parseGitHubRepoFromRemoteUrl(remoteUrl);
@@ -1980,6 +2314,9 @@ async function loadCurrentPullRequest(cwd, options) {
             githubFeaturesEnabled: false,
             checks: [],
             headSha: null,
+            repo: null,
+            detailLevel,
+            fetchedAt: Date.now(),
         };
     }
     const owner = repo.split("/")[0];
@@ -2000,15 +2337,36 @@ async function loadCurrentPullRequest(cwd, options) {
                 githubFeaturesEnabled: false,
                 checks: [],
                 headSha: null,
+                repo,
+                detailLevel,
+                fetchedAt: Date.now(),
             };
         }
+        if (isGhRateLimitError(error)) {
+            if (compatibleCachedLookup) {
+                return compatibleCachedLookup;
+            }
+            throw new PullRequestRateLimitError();
+        }
         throw error;
     }
     const openPull = openPulls.find((entry) => matchesPullRequestHeadRef(entry, head)) ?? null;
     const openBaseStatus = buildPullRequestBaseStatus(openPull, head);
     if (openBaseStatus) {
-        let checks;
-        let mergeability = { hasConflicts: false, rollupChecks: [] };
+        if (detailLevel === "summary") {
+            return setCachedPullRequestLookup(cacheKey, localHeadSha, {
+                status: toSummaryOnlyPullRequestStatus(openBaseStatus),
+                githubFeaturesEnabled: true,
+                checks: [],
+                headSha: openBaseStatus.headSha,
+                repo,
+                detailLevel,
+                fetchedAt: Date.now(),
+            }, { cwd, generation: cacheGeneration });
+        }
+        let checks = [];
+        let requiredChecksKnown = true;
+        let mergeability = { hasConflicts: false, mergeableKnown: false };
         try {
             checks = await getRequiredPullRequestChecks(cwd, openBaseStatus.number);
         }
@@ -2019,12 +2377,22 @@ async function loadCurrentPullRequest(cwd, options) {
                     githubFeaturesEnabled: false,
                     checks: [],
                     headSha: null,
+                    repo,
+                    detailLevel,
+                    fetchedAt: Date.now(),
                 };
             }
-            throw error;
+            if (isGhRateLimitError(error)) {
+                if (compatibleCachedLookup) {
+                    return compatibleCachedLookup;
+                }
+                throw new PullRequestRateLimitError();
+            }
+            requiredChecksKnown = false;
+            checks = await getPullRequestChecksViaRest(cwd, repo, openBaseStatus.headSha ?? localHeadSha ?? openBaseStatus.headRefName);
         }
         try {
-            mergeability = await getPullRequestMergeability(cwd, openBaseStatus.number);
+            mergeability = await getPullRequestMergeabilityViaRest(cwd, repo, openBaseStatus.number);
         }
         catch (error) {
             if (isGhAuthError(error)) {
@@ -2033,15 +2401,29 @@ async function loadCurrentPullRequest(cwd, options) {
                     githubFeaturesEnabled: false,
                     checks: [],
                     headSha: null,
+                    repo,
+                    detailLevel,
+                    fetchedAt: Date.now(),
                 };
             }
+            if (isGhRateLimitError(error)) {
+                if (compatibleCachedLookup) {
+                    return compatibleCachedLookup;
+                }
+                throw new PullRequestRateLimitError();
+            }
         }
-        return {
-            status: toPullRequestStatus(openBaseStatus, mergeCheckStatuses(checks, mergeability.rollupChecks), mergeability),
+        return setCachedPullRequestLookup(cacheKey, localHeadSha, {
+            status: toPullRequestStatus(openBaseStatus, checks, mergeability, {
+                requiredChecksKnown,
+            }),
             githubFeaturesEnabled: true,
-            checks: mergeCheckStatuses(checks, mergeability.rollupChecks),
+            checks,
             headSha: openBaseStatus.headSha,
-        };
+            repo,
+            detailLevel,
+            fetchedAt: Date.now(),
+        }, { cwd, generation: cacheGeneration });
     }
     let closedPulls;
     try {
@@ -2060,8 +2442,17 @@ async function loadCurrentPullRequest(cwd, options) {
                 githubFeaturesEnabled: false,
                 checks: [],
                 headSha: null,
+                repo,
+                detailLevel,
+                fetchedAt: Date.now(),
             };
         }
+        if (isGhRateLimitError(error)) {
+            if (compatibleCachedLookup) {
+                return compatibleCachedLookup;
+            }
+            throw new PullRequestRateLimitError();
+        }
         throw error;
     }
     const mergedClosedPull = closedPulls.find((entry) => matchesPullRequestHeadRef(entry, head) &&
@@ -2071,19 +2462,33 @@ async function loadCurrentPullRequest(cwd, options) {
         entry.merged_at.trim().length > 0) ?? null;
     const mergedBaseStatus = buildPullRequestBaseStatus(mergedClosedPull, head);
     if (!mergedBaseStatus) {
-        return {
+        return setCachedPullRequestLookup(cacheKey, localHeadSha, {
             status: null,
             githubFeaturesEnabled: true,
             checks: [],
             headSha: null,
-        };
-    }
-    return {
-        status: toPullRequestStatus(mergedBaseStatus, []),
+            repo,
+            detailLevel,
+            fetchedAt: Date.now(),
+        }, { cwd, generation: cacheGeneration });
+    }
+    return setCachedPullRequestLookup(cacheKey, localHeadSha, {
+        status: detailLevel === "summary"
+            ? toSummaryOnlyPullRequestStatus(mergedBaseStatus)
+            : toPullRequestStatus(mergedBaseStatus, []),
         githubFeaturesEnabled: true,
         checks: [],
         headSha: mergedBaseStatus.headSha,
-    };
+        repo,
+        detailLevel,
+        fetchedAt: Date.now(),
+    }, { cwd, generation: cacheGeneration });
+}
+/**
+ * Read the current branch pull request snapshot using cache-aware summary/detail hydration.
+ */
+export async function getPullRequestSnapshot(cwd, options) {
+    return loadCurrentPullRequest(cwd, options);
 }
 export async function createPullRequest(cwd, options) {
     await requireGitRepo(cwd);
@@ -2121,15 +2526,27 @@ export async function createPullRequest(cwd, options) {
     if (!parsed?.url || !parsed?.number) {
         throw new Error("GitHub CLI did not return PR url/number");
     }
+    invalidatePullRequestCache(cwd, { remoteName });
     return { url: parsed.url, number: parsed.number };
 }
+/**
+ * Read a detailed pull request status for the current branch.
+ */
 export async function getPullRequestStatus(cwd, options) {
-    const lookup = await loadCurrentPullRequest(cwd, options);
+    const lookup = await loadCurrentPullRequest(cwd, {
+        remoteName: options?.remoteName,
+        detailLevel: "detail",
+        maxAgeMs: options?.maxAgeMs ?? PULL_REQUEST_STATUS_ACTIVE_CACHE_MS,
+        forceRefresh: options?.forceRefresh,
+    });
     return {
         status: lookup.status,
         githubFeaturesEnabled: lookup.githubFeaturesEnabled,
     };
 }
+/**
+ * Search pull requests for the current repository using a short-lived cache.
+ */
 export async function searchPullRequests(cwd, options = {}) {
     await requireGitRepo(cwd);
     try {
@@ -2149,6 +2566,22 @@ export async function searchPullRequests(cwd, options = {}) {
             githubFeaturesEnabled: false,
         };
     }
+    const normalizedScope = normalizePullRequestCacheScope({
+        cwd,
+        remoteName,
+    });
+    const searchCacheKey = JSON.stringify([
+        normalizedScope.cwd,
+        normalizedScope.remoteName ?? "",
+        repo,
+        options.query?.trim() ?? "",
+        options.limit ?? 25,
+    ]);
+    prunePullRequestSearchCache();
+    const cachedSearch = pullRequestSearchCache.get(searchCacheKey);
+    if (cachedSearch && Date.now() - cachedSearch.fetchedAt <= PULL_REQUEST_SEARCH_CACHE_MS) {
+        return cachedSearch.result;
+    }
     const args = [
         "pr",
         "list",
@@ -2203,10 +2636,17 @@ export async function searchPullRequests(cwd, options = {}) {
                     }];
             })
             : [];
-        return {
+        const result = {
             pullRequests,
             githubFeaturesEnabled: true,
         };
+        prunePullRequestSearchCache();
+        pullRequestSearchCache.set(searchCacheKey, {
+            result,
+            fetchedAt: Date.now(),
+        });
+        prunePullRequestSearchCache();
+        return result;
     }
     catch {
         return {
@@ -2215,8 +2655,16 @@ export async function searchPullRequests(cwd, options = {}) {
         };
     }
 }
+/**
+ * Return failed-check logs for the current branch pull request when available.
+ */
 export async function getPullRequestFailureLogs(cwd, options) {
-    const lookup = await loadCurrentPullRequest(cwd, options);
+    const lookup = await loadCurrentPullRequest(cwd, {
+        remoteName: options?.remoteName,
+        detailLevel: "detail",
+        maxAgeMs: options?.maxAgeMs ?? PULL_REQUEST_STATUS_ACTIVE_CACHE_MS,
+        forceRefresh: options?.forceRefresh,
+    });
     if (!lookup.githubFeaturesEnabled) {
         return {
             logs: null,
@@ -2224,6 +2672,8 @@ export async function getPullRequestFailureLogs(cwd, options) {
         };
     }
     const failedChecks = lookup.checks.filter((check) => check.bucket === "fail" || check.bucket === "cancel");
+    const failedRequiredChecks = failedChecks.filter((check) => check.required);
+    const summarizedChecks = failedRequiredChecks.length > 0 ? failedRequiredChecks : failedChecks;
     if (!lookup.status || lookup.status.isMerged || failedChecks.length === 0) {
         return {
             logs: null,
@@ -2242,8 +2692,8 @@ export async function getPullRequestFailureLogs(cwd, options) {
         `PR #${lookup.status.number}: ${lookup.status.title}`,
         `Branch: ${lookup.status.headRefName} -> ${lookup.status.baseRefName}`,
         "",
-        "Failed required checks:",
-        ...failedChecks.map((check) => {
+        failedRequiredChecks.length > 0 ? "Failed required checks:" : "Failing checks:",
+        ...summarizedChecks.map((check) => {
             const workflowSuffix = check.workflow ? ` [${check.workflow}]` : "";
             const descriptionSuffix = check.description ? ` - ${check.description}` : "";
             return `- ${check.name}${workflowSuffix}${descriptionSuffix}`;
@@ -2288,20 +2738,50 @@ export async function getPullRequestFailureLogs(cwd, options) {
         githubFeaturesEnabled: true,
     };
 }
+function isMergeQueueFallbackError(error) {
+    const text = getCommandErrorText(error);
+    return (text.includes("merge queue") ||
+        text.includes("enqueue") ||
+        text.includes("auto-merge") ||
+        text.includes("changes must be made through the merge queue"));
+}
+/**
+ * Merge the current branch pull request using a REST-first strategy with queue-aware fallback.
+ */
 export async function mergePullRequest(cwd, options = {}) {
     const method = options.method ?? "squash";
     if (method !== "squash") {
         throw new Error("Only squash merge is supported");
     }
-    const statusResult = await getPullRequestStatus(cwd, { remoteName: options.remoteName });
-    if (!statusResult.githubFeaturesEnabled) {
+    const remoteName = await resolveEffectiveRemoteName(cwd, options.remoteName);
+    const lookup = await loadCurrentPullRequest(cwd, {
+        remoteName,
+        detailLevel: "summary",
+        maxAgeMs: options.maxAgeMs ?? PULL_REQUEST_STATUS_ACTIVE_CACHE_MS,
+        forceRefresh: true,
+    });
+    if (!lookup.githubFeaturesEnabled) {
         throw new Error("GitHub CLI (gh) is not available or not authenticated");
     }
-    if (!statusResult.status || statusResult.status.isMerged) {
+    if (!lookup.status || lookup.status.isMerged || !lookup.repo) {
         throw new Error("No open pull request found for current branch");
     }
-    await execFileAsync("gh", ["pr", "merge", String(statusResult.status.number), "--squash"], {
-        cwd,
-    });
+    try {
+        await execFileAsync("gh", [
+            "api",
+            "-X",
+            "PUT",
+            `repos/${lookup.repo}/pulls/${lookup.status.number}/merge`,
+            "-f",
+            `merge_method=${method}`,
+        ], { cwd });
+    }
+    catch (error) {
+        if (!isMergeQueueFallbackError(error)) {
+            throw error;
+        }
+        await execFileAsync("gh", ["pr", "merge", String(lookup.status.number), "--squash"], { cwd });
+    }
+    invalidatePullRequestCache(cwd, { remoteName });
 }
 //# sourceMappingURL=checkout-git.js.map