@getpaseo/server 0.1.61 → 0.1.63

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

@@ -3,13 +3,13 @@ import { existsSync, realpathSync } from "fs";
 import { open as openFile, readFile, stat as statFile } from "fs/promises";
 import { TTLCache } from "@isaacs/ttlcache";
 import { parseAndHighlightDiff } from "../server/utils/diff-highlighter.js";
-import { GitHubAuthenticationError, GitHubCliMissingError, createGitHubService, resolveGitHubRepo, } from "../services/github-service.js";
+import { parseGitHubRepoFromRemote } from "../server/workspace-git-metadata.js";
+import { GitHubAuthenticationError, GitHubCliMissingError, GitHubCommandError, createGitHubService, resolveGitHubRepo, } from "../services/github-service.js";
 import { parseGitRevParsePath, resolveGitRevParsePath } from "./git-rev-parse-path.js";
 import { runGitCommand } from "./run-git-command.js";
 import { isPaseoOwnedWorktreeCwd } from "./worktree.js";
-import { requirePaseoWorktreeBaseRefName } from "./worktree-metadata.js";
+import { readPaseoWorktreeMetadata } from "./worktree-metadata.js";
 const READ_ONLY_GIT_ENV = {
-    ...process.env,
     GIT_OPTIONAL_LOCKS: "0",
 };
 const DEFAULT_PULL_REQUEST_STATUS_CACHE_TTL_MS = 30000;
@@ -19,6 +19,7 @@ const SHORTSTAT_CACHE_MAX = 1000;
 let pullRequestStatusCacheTtlMs = DEFAULT_PULL_REQUEST_STATUS_CACHE_TTL_MS;
 let pullRequestStatusCache = createPullRequestStatusCache(pullRequestStatusCacheTtlMs);
 const pullRequestStatusInFlight = new Map();
+const lastSuccessfulPullRequestStatus = new Map();
 let shortstatCacheTtlMs = DEFAULT_SHORTSTAT_CACHE_TTL_MS;
 let shortstatCache = createShortstatCache(shortstatCacheTtlMs);
 const shortstatInFlight = new Map();
@@ -39,6 +40,16 @@ function createShortstatCache(ttlMs) {
 function getPullRequestStatusCacheKey(cwd) {
     return resolve(cwd);
 }
+function rememberPullRequestStatus(cacheKey, status) {
+    lastSuccessfulPullRequestStatus.set(cacheKey, status);
+    if (lastSuccessfulPullRequestStatus.size <= PULL_REQUEST_STATUS_CACHE_MAX) {
+        return;
+    }
+    const oldest = lastSuccessfulPullRequestStatus.keys().next();
+    if (!oldest.done) {
+        lastSuccessfulPullRequestStatus.delete(oldest.value);
+    }
+}
 function getShortstatCacheKey(cwd) {
     return resolve(cwd);
 }
@@ -48,6 +59,7 @@ export function __resetPullRequestStatusCacheForTests() {
     pullRequestStatusCacheTtlMs = DEFAULT_PULL_REQUEST_STATUS_CACHE_TTL_MS;
     pullRequestStatusCache = createPullRequestStatusCache(pullRequestStatusCacheTtlMs);
     pullRequestStatusInFlight.clear();
+    lastSuccessfulPullRequestStatus.clear();
 }
 export function __setPullRequestStatusCacheTtlForTests(ttlMs) {
     pullRequestStatusCache.clear();
@@ -55,6 +67,7 @@ export function __setPullRequestStatusCacheTtlForTests(ttlMs) {
     pullRequestStatusCacheTtlMs = ttlMs;
     pullRequestStatusCache = createPullRequestStatusCache(ttlMs);
     pullRequestStatusInFlight.clear();
+    lastSuccessfulPullRequestStatus.clear();
 }
 export function __resetCheckoutShortstatCacheForTests() {
     shortstatCache.clear();
@@ -99,7 +112,7 @@ async function listGitRefs(cwd, refPrefix) {
         "--sort=-committerdate",
         "--format=%(refname)%09%(committerdate:unix)",
         refPrefix,
-    ], { cwd, env: READ_ONLY_GIT_ENV });
+    ], { cwd, envOverlay: READ_ONLY_GIT_ENV });
     return stdout
         .split("\n")
         .map((line) => {
@@ -199,7 +212,7 @@ export async function resolveBranchCheckout(cwd, name) {
     const localRef = `refs/heads/${normalized}`;
     const localResult = await runGitCommand(["rev-parse", "--verify", "--quiet", localRef], {
         cwd,
-        env: READ_ONLY_GIT_ENV,
+        envOverlay: READ_ONLY_GIT_ENV,
         acceptExitCodes: [0, 1],
     });
     const hasLocal = localResult.exitCode === 0;
@@ -210,7 +223,7 @@ export async function resolveBranchCheckout(cwd, name) {
     const remoteRefPath = `refs/remotes/${remoteRef}`;
     const remoteResult = await runGitCommand(["rev-parse", "--verify", "--quiet", remoteRefPath], {
         cwd,
-        env: READ_ONLY_GIT_ENV,
+        envOverlay: READ_ONLY_GIT_ENV,
         acceptExitCodes: [0, 1],
     });
     const hasRemote = remoteResult.exitCode === 0;
@@ -245,7 +258,7 @@ async function listCheckoutFileChanges(cwd, refs, ignoreWhitespace = false) {
     const { stdout: nameStatusOut } = await runGitCommand(buildGitDiffArgs({
         ignoreWhitespace,
         extra: ["--name-status", ...getCheckoutDiffRefArgs(refs)],
-    }), { cwd, env: READ_ONLY_GIT_ENV });
+    }), { cwd, envOverlay: READ_ONLY_GIT_ENV });
     for (const line of nameStatusOut
         .split("\n")
         .map((l) => l.trim())
@@ -283,7 +296,7 @@ async function listCheckoutFileChanges(cwd, refs, ignoreWhitespace = false) {
     if (refs.includeUntracked) {
         const { stdout: untrackedOut } = await runGitCommand(["ls-files", "--others", "--exclude-standard"], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         for (const file of untrackedOut
             .split("\n")
@@ -316,7 +329,7 @@ async function readGitFileContentAtRef(cwd, ref, path) {
     try {
         const { stdout } = await runGitCommand(["show", `${ref}:${path}`], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         return stdout;
     }
@@ -328,7 +341,7 @@ async function tryResolveMergeBase(cwd, baseRef) {
     try {
         const { stdout } = await runGitCommand(["merge-base", baseRef, "HEAD"], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         const sha = stdout.trim();
         return sha.length > 0 ? sha : null;
@@ -360,7 +373,7 @@ async function getTrackedNumstatByPath(cwd, refs, ignoreWhitespace = false) {
         extra: ["--numstat", ...getCheckoutDiffRefArgs(refs)],
     }), {
         cwd,
-        env: READ_ONLY_GIT_ENV,
+        envOverlay: READ_ONLY_GIT_ENV,
         maxOutputBytes: TRACKED_DIFF_NUMSTAT_MAX_BYTES,
         acceptExitCodes: [0],
     });
@@ -435,9 +448,9 @@ function isGitError(error) {
 }
 async function requireGitRepo(cwd) {
     try {
-        await runGitCommand(["rev-parse", "--git-dir"], { cwd, env: READ_ONLY_GIT_ENV });
+        await runGitCommand(["rev-parse", "--git-dir"], { cwd, envOverlay: READ_ONLY_GIT_ENV });
     }
-    catch (error) {
+    catch {
         throw new NotGitRepoError(cwd);
     }
 }
@@ -445,7 +458,7 @@ export async function getCurrentBranch(cwd) {
     try {
         const { stdout } = await runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         const branch = stdout.trim();
         if (branch === "HEAD") {
@@ -458,11 +471,12 @@ export async function getCurrentBranch(cwd) {
     }
 }
 async function getRebaseHeadBranch(cwd) {
-    for (const path of ["rebase-merge/head-name", "rebase-apply/head-name"]) {
+    const paths = ["rebase-merge/head-name", "rebase-apply/head-name"];
+    const results = await Promise.all(paths.map(async (path) => {
         try {
             const { stdout } = await runGitCommand(["rev-parse", "--git-path", path], {
                 cwd,
-                env: READ_ONLY_GIT_ENV,
+                envOverlay: READ_ONLY_GIT_ENV,
             });
             const headName = (await readFile(resolve(cwd, stdout.trim()), "utf8")).trim();
             if (headName.startsWith("refs/heads/")) {
@@ -471,16 +485,16 @@ async function getRebaseHeadBranch(cwd) {
             return headName || null;
         }
         catch {
-            // Try the other rebase backend.
+            return null;
         }
-    }
-    return null;
+    }));
+    return results.find((result) => result !== null) ?? null;
 }
 async function getWorktreeRoot(cwd) {
     try {
         const { stdout } = await runGitCommand(["rev-parse", "--show-toplevel"], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         return parseGitRevParsePath(stdout);
     }
@@ -491,7 +505,7 @@ async function getWorktreeRoot(cwd) {
 export async function getMainRepoRoot(cwd) {
     const { stdout: commonDirOut } = await runGitCommand(["rev-parse", "--git-common-dir"], {
         cwd,
-        env: READ_ONLY_GIT_ENV,
+        envOverlay: READ_ONLY_GIT_ENV,
     });
     const commonDir = resolveGitRevParsePath(cwd, commonDirOut);
     if (!commonDir) {
@@ -503,7 +517,7 @@ export async function getMainRepoRoot(cwd) {
     }
     const { stdout: worktreeOut } = await runGitCommand(["worktree", "list", "--porcelain"], {
         cwd,
-        env: READ_ONLY_GIT_ENV,
+        envOverlay: READ_ONLY_GIT_ENV,
     });
     const worktrees = parseWorktreeList(worktreeOut);
     const nonBareNonPaseo = worktrees.filter((wt) => !wt.isBare && !isPaseoWorktreePath(wt.path));
@@ -561,7 +575,7 @@ async function getWorktreePathForBranch(cwd, branchName) {
     try {
         const { stdout } = await runGitCommand(["worktree", "list", "--porcelain"], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         const entries = parseWorktreeList(stdout);
         const ref = branchName.startsWith("refs/heads/") ? branchName : `refs/heads/${branchName}`;
@@ -584,25 +598,45 @@ export async function renameCurrentBranch(cwd, newName) {
     const currentBranch = await getCurrentBranch(cwd);
     return { previousBranch, currentBranch };
 }
-async function getConfiguredBaseRefForCwd(cwd, context) {
+async function getPaseoWorktreeForCwd(cwd, context) {
     // Fast-path reject: non-worktree paths do not need expensive ownership checks.
     if (!/[\\/]worktrees[\\/]/.test(cwd)) {
-        return { baseRef: null, isPaseoOwnedWorktree: false };
+        return { isPaseoOwnedWorktree: false };
     }
     const ownership = await isPaseoOwnedWorktreeCwd(cwd, { paseoHome: context?.paseoHome });
     if (!ownership.allowed) {
-        return { baseRef: null, isPaseoOwnedWorktree: false };
+        return { isPaseoOwnedWorktree: false };
     }
-    const worktreeRoot = (await getWorktreeRoot(cwd)) ?? cwd;
     return {
-        baseRef: requirePaseoWorktreeBaseRefName(worktreeRoot),
         isPaseoOwnedWorktree: true,
+        worktreeRoot: (await getWorktreeRoot(cwd)) ?? cwd,
+    };
+}
+function readPaseoWorktreeBaseRef(worktreeRoot) {
+    return readPaseoWorktreeMetadata(worktreeRoot)?.baseRefName ?? null;
+}
+async function getStoredBaseRefForCwd(cwd, context) {
+    const paseoWorktree = await getPaseoWorktreeForCwd(cwd, context);
+    if (!paseoWorktree.isPaseoOwnedWorktree) {
+        return null;
+    }
+    return readPaseoWorktreeBaseRef(paseoWorktree.worktreeRoot);
+}
+async function getResolvedBaseRefForCwd(cwd, context) {
+    const { resolvedBaseRef } = await resolveBaseRefForCwd(cwd, context);
+    return resolvedBaseRef;
+}
+async function resolveBaseRefForCwd(cwd, context) {
+    const storedBaseRef = await getStoredBaseRefForCwd(cwd, context);
+    return {
+        storedBaseRef,
+        resolvedBaseRef: storedBaseRef ?? (await resolveBaseRef(cwd)),
     };
 }
 async function isWorkingTreeDirty(cwd) {
     const { stdout } = await runGitCommand(["status", "--porcelain"], {
         cwd,
-        env: READ_ONLY_GIT_ENV,
+        envOverlay: READ_ONLY_GIT_ENV,
     });
     return stdout.trim().length > 0;
 }
@@ -610,7 +644,7 @@ export async function getOriginRemoteUrl(cwd) {
     try {
         const { stdout } = await runGitCommand(["config", "--get", "remote.origin.url"], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         const url = stdout.trim();
         return url.length > 0 ? url : null;
@@ -623,11 +657,50 @@ export async function hasOriginRemote(cwd) {
     const url = await getOriginRemoteUrl(cwd);
     return url !== null;
 }
+async function getGitConfigValue(cwd, key) {
+    try {
+        const { stdout } = await runGitCommand(["config", "--get", key], {
+            cwd,
+            envOverlay: READ_ONLY_GIT_ENV,
+        });
+        const value = stdout.trim();
+        return value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseBranchMergeHeadRef(mergeRef) {
+    const prefix = "refs/heads/";
+    if (!mergeRef?.startsWith(prefix)) {
+        return null;
+    }
+    const headRef = mergeRef.slice(prefix.length).trim();
+    return headRef.length > 0 ? headRef : null;
+}
+async function resolvePullRequestStatusLookupTarget(cwd, currentBranch) {
+    const remoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.remote`);
+    if (!remoteName?.startsWith("paseo-pr-")) {
+        return { headRef: currentBranch };
+    }
+    const mergeRef = await getGitConfigValue(cwd, `branch.${currentBranch}.merge`);
+    const trackedHeadRef = parseBranchMergeHeadRef(mergeRef);
+    if (!trackedHeadRef) {
+        return { headRef: currentBranch };
+    }
+    const remoteUrl = await getGitConfigValue(cwd, `remote.${remoteName}.url`);
+    const remoteRepo = remoteUrl ? parseGitHubRepoFromRemote(remoteUrl) : null;
+    const headRepositoryOwner = remoteRepo?.split("/")[0];
+    return {
+        headRef: trackedHeadRef,
+        ...(headRepositoryOwner ? { headRepositoryOwner } : {}),
+    };
+}
 export async function resolveAbsoluteGitDir(cwd) {
     try {
         const { stdout } = await runGitCommand(["rev-parse", "--absolute-git-dir"], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         const gitDir = stdout.trim();
         return gitDir.length > 0 ? gitDir : null;
@@ -665,7 +738,7 @@ export async function resolveRepositoryDefaultBranch(repoRoot) {
     try {
         const { stdout } = await runGitCommand(["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"], {
             cwd: repoRoot,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         const ref = stdout.trim();
         if (ref) {
@@ -678,7 +751,7 @@ export async function resolveRepositoryDefaultBranch(repoRoot) {
             try {
                 await runGitCommand(["show-ref", "--verify", "--quiet", `refs/heads/${localName}`], {
                     cwd: repoRoot,
-                    env: READ_ONLY_GIT_ENV,
+                    envOverlay: READ_ONLY_GIT_ENV,
                 });
                 return localName;
             }
@@ -692,16 +765,16 @@ export async function resolveRepositoryDefaultBranch(repoRoot) {
     }
     const { stdout } = await runGitCommand(["branch", "--format=%(refname:short)"], {
         cwd: repoRoot,
-        env: READ_ONLY_GIT_ENV,
+        envOverlay: READ_ONLY_GIT_ENV,
     });
-    const branches = stdout
+    const branches = new Set(stdout
         .split("\n")
         .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-    if (branches.includes("main")) {
+        .filter((line) => line.length > 0));
+    if (branches.has("main")) {
         return "main";
     }
-    if (branches.includes("master")) {
+    if (branches.has("master")) {
         return "master";
     }
     return null;
@@ -728,7 +801,7 @@ function normalizeComparisonBaseRefName(input) {
 async function doesGitRefExist(cwd, fullRef) {
     const result = await runGitCommand(["show-ref", "--verify", "--quiet", fullRef], {
         cwd,
-        env: READ_ONLY_GIT_ENV,
+        envOverlay: READ_ONLY_GIT_ENV,
         acceptExitCodes: [0, 1],
     });
     return result.exitCode === 0;
@@ -764,7 +837,7 @@ async function resolveMostAheadBaseRef(cwd, normalizedBaseRef) {
     if (!hasLocal && !hasOrigin) {
         throw new Error(`Base branch not found locally or on origin: ${normalizedBaseRef}`);
     }
-    const { stdout } = await runGitCommand(["rev-list", "--left-right", "--count", `${normalizedBaseRef}...origin/${normalizedBaseRef}`], { cwd, env: READ_ONLY_GIT_ENV });
+    const { stdout } = await runGitCommand(["rev-list", "--left-right", "--count", `${normalizedBaseRef}...origin/${normalizedBaseRef}`], { cwd, envOverlay: READ_ONLY_GIT_ENV });
     const [localOnlyRaw, originOnlyRaw] = stdout.trim().split(/\s+/);
     const localOnly = Number.parseInt(localOnlyRaw ?? "0", 10);
     const originOnly = Number.parseInt(originOnlyRaw ?? "0", 10);
@@ -782,7 +855,7 @@ async function getAheadBehind(cwd, baseRef, currentBranch) {
         return null;
     }
     const comparisonBaseRef = await resolveBestComparisonBaseRef(cwd, baseRef);
-    const { stdout } = await runGitCommand(["rev-list", "--left-right", "--count", `${comparisonBaseRef}...${currentBranch}`], { cwd, env: READ_ONLY_GIT_ENV });
+    const { stdout } = await runGitCommand(["rev-list", "--left-right", "--count", `${comparisonBaseRef}...${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV });
     const [behindRaw, aheadRaw] = stdout.trim().split(/\s+/);
     const behind = Number.parseInt(behindRaw ?? "0", 10);
     const ahead = Number.parseInt(aheadRaw ?? "0", 10);
@@ -796,7 +869,7 @@ async function getAheadOfOrigin(cwd, currentBranch) {
         return null;
     }
     try {
-        const { stdout } = await runGitCommand(["rev-list", "--count", `origin/${currentBranch}..${currentBranch}`], { cwd, env: READ_ONLY_GIT_ENV });
+        const { stdout } = await runGitCommand(["rev-list", "--count", `origin/${currentBranch}..${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV });
         const count = Number.parseInt(stdout.trim(), 10);
         return Number.isNaN(count) ? null : count;
     }
@@ -804,7 +877,7 @@ async function getAheadOfOrigin(cwd, currentBranch) {
         try {
             const { stdout } = await runGitCommand(["rev-list", "--count", currentBranch], {
                 cwd,
-                env: READ_ONLY_GIT_ENV,
+                envOverlay: READ_ONLY_GIT_ENV,
             });
             const count = Number.parseInt(stdout.trim(), 10);
             return Number.isNaN(count) ? null : count;
@@ -819,7 +892,7 @@ async function getBehindOfOrigin(cwd, currentBranch) {
         return null;
     }
     try {
-        const { stdout } = await runGitCommand(["rev-list", "--count", `${currentBranch}..origin/${currentBranch}`], { cwd, env: READ_ONLY_GIT_ENV });
+        const { stdout } = await runGitCommand(["rev-list", "--count", `${currentBranch}..origin/${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV });
         const count = Number.parseInt(stdout.trim(), 10);
         return Number.isNaN(count) ? null : count;
     }
@@ -833,16 +906,16 @@ async function inspectCheckoutContext(cwd, context) {
         if (!root) {
             return null;
         }
-        const [currentBranch, remoteUrl, configured] = await Promise.all([
+        const [currentBranch, remoteUrl, paseoWorktree] = await Promise.all([
             getCurrentBranch(cwd),
             getOriginRemoteUrl(cwd),
-            getConfiguredBaseRefForCwd(cwd, context),
+            getPaseoWorktreeForCwd(cwd, context),
         ]);
         return {
             worktreeRoot: root,
             currentBranch,
             remoteUrl,
-            configured,
+            paseoWorktree,
         };
     }
     catch (error) {
@@ -929,7 +1002,7 @@ async function getUntrackedDiffText(cwd, change, ignoreWhitespace = false) {
         extra: ["--no-index", "/dev/null", "--", change.path],
     }), {
         cwd,
-        env: READ_ONLY_GIT_ENV,
+        envOverlay: READ_ONLY_GIT_ENV,
         maxOutputBytes: PER_FILE_DIFF_MAX_BYTES,
         acceptExitCodes: [0, 1],
     });
@@ -947,24 +1020,24 @@ export async function getCheckoutStatus(cwd, context) {
     const worktreeRoot = inspected.worktreeRoot;
     const currentBranch = inspected.currentBranch;
     const remoteUrl = inspected.remoteUrl;
-    const configured = inspected.configured;
+    const paseoWorktree = inspected.paseoWorktree;
     const isDirty = await isWorkingTreeDirty(cwd);
     const hasRemote = remoteUrl !== null;
-    const baseRef = configured.baseRef ?? (await resolveBaseRef(cwd));
+    const { resolvedBaseRef: baseRef } = await resolveBaseRefForCwd(cwd, context);
+    const mainRepoRoot = await getMainRepoRoot(cwd).catch(() => null);
     const [aheadBehind, aheadOfOrigin, behindOfOrigin] = await Promise.all([
         baseRef && currentBranch ? getAheadBehind(cwd, baseRef, currentBranch) : Promise.resolve(null),
         hasRemote && currentBranch ? getAheadOfOrigin(cwd, currentBranch) : Promise.resolve(null),
         hasRemote && currentBranch ? getBehindOfOrigin(cwd, currentBranch) : Promise.resolve(null),
     ]);
-    if (configured.isPaseoOwnedWorktree) {
-        const mainRepoRoot = await getMainRepoRoot(cwd);
+    if (paseoWorktree.isPaseoOwnedWorktree && baseRef) {
         return {
             isGit: true,
             repoRoot: worktreeRoot,
-            mainRepoRoot,
+            mainRepoRoot: mainRepoRoot ?? worktreeRoot,
             currentBranch,
             isDirty,
-            baseRef: configured.baseRef,
+            baseRef,
             aheadBehind,
             aheadOfOrigin,
             behindOfOrigin,
@@ -976,6 +1049,7 @@ export async function getCheckoutStatus(cwd, context) {
     return {
         isGit: true,
         repoRoot: worktreeRoot,
+        mainRepoRoot: mainRepoRoot && resolve(mainRepoRoot) !== resolve(worktreeRoot) ? mainRepoRoot : null,
         currentBranch,
         isDirty,
         baseRef,
@@ -1014,8 +1088,7 @@ async function getCheckoutShortstatUncached(cwd, context) {
     catch {
         return null;
     }
-    const configured = await getConfiguredBaseRefForCwd(cwd, context);
-    const localBaseRef = configured.baseRef ?? (await resolveBaseRef(cwd));
+    const localBaseRef = await getResolvedBaseRefForCwd(cwd, context);
     const currentBranch = await getCurrentBranch(cwd);
     let comparisonRef;
     if (currentBranch && localBaseRef && currentBranch !== localBaseRef) {
@@ -1039,7 +1112,7 @@ async function getCheckoutShortstatUncached(cwd, context) {
     try {
         const { stdout: mergeBaseOut } = await runGitCommand(["merge-base", "HEAD", comparisonRef], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         const mergeBase = mergeBaseOut.trim();
         if (!mergeBase) {
@@ -1047,7 +1120,7 @@ async function getCheckoutShortstatUncached(cwd, context) {
         }
         const { stdout } = await runGitCommand(["diff", "--shortstat", mergeBase], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         return parseCheckoutShortstat(stdout);
     }
@@ -1092,32 +1165,143 @@ export function warmCheckoutShortstatInBackground(cwd, context, onComplete) {
     void getOrLoadCheckoutShortstat(cwd, context)
         .then(() => {
         onComplete?.();
+        return;
     })
         .catch(() => {
         // Non-critical: keep listing path resilient even if git commands fail.
     });
 }
-export async function getCheckoutDiff(cwd, compare, context) {
-    await requireGitRepo(cwd);
-    let refsForDiff;
-    if (compare.mode === "uncommitted") {
-        refsForDiff = { baseRef: "HEAD", includeUntracked: true };
+async function appendStructuredTrackedDiffs(input) {
+    const { cwd, trackedChanges, trackedChangeByPath, trackedNumstatByPath, trackedPlaceholderByPath, trackedDiffText, trackedDiffTruncated, refsForDiff, ignoreWhitespace, structured, appendTrackedPlaceholderComment, } = input;
+    const parsedTrackedFiles = trackedDiffText.length > 0
+        ? await parseAndHighlightDiff(trackedDiffText, cwd, {
+            getOldFileContent: async (file) => {
+                const change = trackedChangeByPath.get(file.path);
+                if (!change || change.isNew) {
+                    return null;
+                }
+                const refPath = change.oldPath ?? change.path;
+                return readGitFileContentAtRef(cwd, refsForDiff.baseRef, refPath);
+            },
+            getNewFileContent: async (file) => {
+                if (!refsForDiff.targetRef) {
+                    return null;
+                }
+                return readGitFileContentAtRef(cwd, refsForDiff.targetRef, file.path);
+            },
+        })
+        : [];
+    const parsedTrackedByPath = new Map(parsedTrackedFiles.map((file) => [file.path, file]));
+    for (const change of trackedChanges) {
+        const placeholder = trackedPlaceholderByPath.get(change.path);
+        if (placeholder) {
+            structured.push(buildPlaceholderParsedDiffFile(change, {
+                status: placeholder.status,
+                stat: placeholder.stat,
+            }));
+            appendTrackedPlaceholderComment(change, placeholder.status);
+            continue;
+        }
+        const stat = trackedNumstatByPath.get(change.path) ?? null;
+        const parsedFile = parsedTrackedByPath.get(change.path);
+        if (parsedFile) {
+            structured.push({
+                ...parsedFile,
+                path: change.path,
+                isNew: change.isNew,
+                isDeleted: change.isDeleted,
+                status: "ok",
+            });
+            continue;
+        }
+        // `git diff -w --name-status` can still report a modified path even when the
+        // whitespace-filtered patch and numstat are both empty. Skip emitting a
+        // structured placeholder in that case so whitespace-only edits truly disappear.
+        if (ignoreWhitespace &&
+            !trackedDiffTruncated &&
+            change.status.startsWith("M") &&
+            (!stat || (!stat.isBinary && stat.additions === 0 && stat.deletions === 0))) {
+            continue;
+        }
+        structured.push({
+            path: change.path,
+            isNew: change.isNew,
+            isDeleted: change.isDeleted,
+            additions: stat?.additions ?? 0,
+            deletions: stat?.deletions ?? 0,
+            hunks: [],
+            status: trackedDiffTruncated ? "too_large" : "ok",
+        });
     }
-    else {
-        const configured = await getConfiguredBaseRefForCwd(cwd, context);
-        const baseRef = configured.baseRef ?? compare.baseRef ?? (await resolveBaseRef(cwd));
-        if (!baseRef) {
-            return { diff: "" };
-        }
-        if (configured.isPaseoOwnedWorktree && compare.baseRef && compare.baseRef !== baseRef) {
-            throw new Error(`Base ref mismatch: expected ${baseRef}, got ${compare.baseRef}`);
-        }
-        const bestBaseRef = await resolveBestComparisonBaseRef(cwd, baseRef);
-        refsForDiff = {
-            baseRef: (await tryResolveMergeBase(cwd, bestBaseRef)) ?? bestBaseRef,
-            targetRef: "HEAD",
-            includeUntracked: false,
+}
+async function processUntrackedChange(input) {
+    const { cwd, change, ignoreWhitespace, includeStructured, structured, appendDiff } = input;
+    const { text, truncated, stat } = await getUntrackedDiffText(cwd, change, ignoreWhitespace);
+    if (!includeStructured) {
+        if (stat?.isBinary) {
+            appendDiff(`# ${change.path}: binary diff omitted\n`);
+        }
+        else if (truncated) {
+            appendDiff(`# ${change.path}: diff too large omitted\n`);
+        }
+        else {
+            appendDiff(text);
+        }
+        return;
+    }
+    if (stat?.isBinary) {
+        structured.push(buildPlaceholderParsedDiffFile(change, { status: "binary", stat }));
+        appendDiff(`# ${change.path}: binary diff omitted\n`);
+        return;
+    }
+    if (truncated) {
+        structured.push(buildPlaceholderParsedDiffFile(change, { status: "too_large", stat }));
+        appendDiff(`# ${change.path}: diff too large omitted\n`);
+        return;
+    }
+    appendDiff(text);
+    const parsed = await parseAndHighlightDiff(text, cwd);
+    const parsedFile = parsed[0] ??
+        {
+            path: change.path,
+            isNew: change.isNew,
+            isDeleted: change.isDeleted,
+            additions: stat?.additions ?? 0,
+            deletions: stat?.deletions ?? 0,
+            hunks: [],
         };
+    structured.push({
+        ...parsedFile,
+        path: change.path,
+        isNew: change.isNew,
+        isDeleted: change.isDeleted,
+        status: "ok",
+    });
+}
+async function resolveCheckoutDiffRefs(cwd, compare, context) {
+    if (compare.mode === "uncommitted") {
+        return { baseRef: "HEAD", includeUntracked: true };
+    }
+    const { storedBaseRef, resolvedBaseRef } = await resolveBaseRefForCwd(cwd, context);
+    const baseRef = compare.baseRef ?? resolvedBaseRef;
+    if (!baseRef) {
+        return null;
+    }
+    if (storedBaseRef && compare.baseRef && compare.baseRef !== storedBaseRef) {
+        throw new Error(`Base ref mismatch: expected ${baseRef}, got ${compare.baseRef}`);
+    }
+    const bestBaseRef = await resolveBestComparisonBaseRef(cwd, baseRef);
+    return {
+        baseRef: (await tryResolveMergeBase(cwd, bestBaseRef)) ?? bestBaseRef,
+        targetRef: "HEAD",
+        includeUntracked: false,
+    };
+}
+export async function getCheckoutDiff(cwd, compare, context) {
+    await requireGitRepo(cwd);
+    const refsForDiff = await resolveCheckoutDiffRefs(cwd, compare, context);
+    if (!refsForDiff) {
+        return { diff: "" };
     }
     const ignoreWhitespace = compare.ignoreWhitespace === true;
     const changes = await listCheckoutFileChanges(cwd, refsForDiff, ignoreWhitespace);
@@ -1174,7 +1358,7 @@ export async function getCheckoutDiff(cwd, compare, context) {
             extra: [...getCheckoutDiffRefArgs(refsForDiff), "--", ...trackedDiffPaths],
         }), {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
             maxOutputBytes: TOTAL_DIFF_MAX_BYTES,
         });
         trackedDiffText = trackedDiffResult.stdout;
@@ -1192,66 +1376,20 @@ export async function getCheckoutDiff(cwd, compare, context) {
         appendDiff(`# ${change.path}: diff too large omitted\n`);
     };
     if (compare.includeStructured) {
-        const parsedTrackedFiles = trackedDiffText.length > 0
-            ? await parseAndHighlightDiff(trackedDiffText, cwd, {
-                getOldFileContent: async (file) => {
-                    const change = trackedChangeByPath.get(file.path);
-                    if (!change || change.isNew) {
-                        return null;
-                    }
-                    const refPath = change.oldPath ?? change.path;
-                    return readGitFileContentAtRef(cwd, refsForDiff.baseRef, refPath);
-                },
-                getNewFileContent: async (file) => {
-                    if (!refsForDiff.targetRef) {
-                        return null;
-                    }
-                    return readGitFileContentAtRef(cwd, refsForDiff.targetRef, file.path);
-                },
-            })
-            : [];
-        const parsedTrackedByPath = new Map(parsedTrackedFiles.map((file) => [file.path, file]));
-        for (const change of trackedChanges) {
-            const placeholder = trackedPlaceholderByPath.get(change.path);
-            if (placeholder) {
-                structured.push(buildPlaceholderParsedDiffFile(change, {
-                    status: placeholder.status,
-                    stat: placeholder.stat,
-                }));
-                appendTrackedPlaceholderComment(change, placeholder.status);
-                continue;
-            }
-            const stat = trackedNumstatByPath.get(change.path) ?? null;
-            const parsedFile = parsedTrackedByPath.get(change.path);
-            if (parsedFile) {
-                structured.push({
-                    ...parsedFile,
-                    path: change.path,
-                    isNew: change.isNew,
-                    isDeleted: change.isDeleted,
-                    status: "ok",
-                });
-                continue;
-            }
-            // `git diff -w --name-status` can still report a modified path even when the
-            // whitespace-filtered patch and numstat are both empty. Skip emitting a
-            // structured placeholder in that case so whitespace-only edits truly disappear.
-            if (ignoreWhitespace &&
-                !trackedDiffTruncated &&
-                change.status.startsWith("M") &&
-                (!stat || (!stat.isBinary && stat.additions === 0 && stat.deletions === 0))) {
-                continue;
-            }
-            structured.push({
-                path: change.path,
-                isNew: change.isNew,
-                isDeleted: change.isDeleted,
-                additions: stat?.additions ?? 0,
-                deletions: stat?.deletions ?? 0,
-                hunks: [],
-                status: trackedDiffTruncated ? "too_large" : "ok",
-            });
-        }
+        await appendStructuredTrackedDiffs({
+            cwd,
+            trackedChanges,
+            trackedChangeByPath,
+            trackedNumstatByPath,
+            trackedPlaceholderByPath,
+            trackedDiffText,
+            trackedDiffTruncated,
+            refsForDiff,
+            ignoreWhitespace,
+            structured,
+            appendDiff,
+            appendTrackedPlaceholderComment,
+        });
     }
     else {
         for (const change of trackedChanges) {
@@ -1265,46 +1403,13 @@ export async function getCheckoutDiff(cwd, compare, context) {
         if (diffBytes >= TOTAL_DIFF_MAX_BYTES) {
             break;
         }
-        const { text, truncated, stat } = await getUntrackedDiffText(cwd, change, ignoreWhitespace);
-        if (!compare.includeStructured) {
-            if (stat?.isBinary) {
-                appendDiff(`# ${change.path}: binary diff omitted\n`);
-            }
-            else if (truncated) {
-                appendDiff(`# ${change.path}: diff too large omitted\n`);
-            }
-            else {
-                appendDiff(text);
-            }
-            continue;
-        }
-        if (stat?.isBinary) {
-            structured.push(buildPlaceholderParsedDiffFile(change, { status: "binary", stat }));
-            appendDiff(`# ${change.path}: binary diff omitted\n`);
-            continue;
-        }
-        if (truncated) {
-            structured.push(buildPlaceholderParsedDiffFile(change, { status: "too_large", stat }));
-            appendDiff(`# ${change.path}: diff too large omitted\n`);
-            continue;
-        }
-        appendDiff(text);
-        const parsed = await parseAndHighlightDiff(text, cwd);
-        const parsedFile = parsed[0] ??
-            {
-                path: change.path,
-                isNew: change.isNew,
-                isDeleted: change.isDeleted,
-                additions: stat?.additions ?? 0,
-                deletions: stat?.deletions ?? 0,
-                hunks: [],
-            };
-        structured.push({
-            ...parsedFile,
-            path: change.path,
-            isNew: change.isNew,
-            isDeleted: change.isDeleted,
-            status: "ok",
+        await processUntrackedChange({
+            cwd,
+            change,
+            ignoreWhitespace,
+            includeStructured: compare.includeStructured === true,
+            structured,
+            appendDiff,
         });
     }
     if (compare.includeStructured) {
@@ -1325,15 +1430,66 @@ export async function commitChanges(cwd, options) {
 export async function commitAll(cwd, message) {
     await commitChanges(cwd, { message, addAll: true });
 }
+async function detectAndThrowMergeToBaseConflict(input) {
+    const { operationCwd, error, baseRef, currentBranch } = input;
+    const errorDetails = error instanceof Error
+        ? `${error.message}\n${error.stderr ?? ""}\n${error.stdout ?? ""}`
+        : String(error);
+    try {
+        const [unmergedOutput, lsFilesOutput, statusOutput] = await Promise.all([
+            runGitCommand(["diff", "--name-only", "--diff-filter=U"], { cwd: operationCwd }),
+            runGitCommand(["ls-files", "-u"], { cwd: operationCwd }),
+            runGitCommand(["status", "--porcelain"], { cwd: operationCwd }),
+        ]);
+        const statusConflicts = statusOutput.stdout
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .filter((line) => /^(UU|AA|DD|AU|UA|UD|DU)\s/.test(line))
+            .map((line) => line.slice(3).trim());
+        const conflicts = [
+            ...unmergedOutput.stdout
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean),
+            ...lsFilesOutput.stdout
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .map((line) => line.split("\t").pop()),
+            ...statusConflicts,
+        ].filter(Boolean);
+        const conflictDetected = conflicts.length > 0 || /CONFLICT|Automatic merge failed/i.test(errorDetails);
+        if (conflictDetected) {
+            try {
+                await runGitCommand(["merge", "--abort"], { cwd: operationCwd, timeout: 120000 });
+            }
+            catch {
+                // ignore
+            }
+            throw new MergeConflictError({
+                baseRef,
+                currentBranch,
+                conflictFiles: conflicts.length > 0 ? conflicts : [],
+            });
+        }
+    }
+    catch (innerError) {
+        if (innerError instanceof MergeConflictError) {
+            throw innerError;
+        }
+        // ignore detection failures
+    }
+}
 export async function mergeToBase(cwd, options = {}, context) {
     await requireGitRepo(cwd);
     const currentBranch = await getCurrentBranch(cwd);
-    const configured = await getConfiguredBaseRefForCwd(cwd, context);
-    const baseRef = configured.baseRef ?? options.baseRef ?? (await resolveBaseRef(cwd));
+    const { storedBaseRef, resolvedBaseRef } = await resolveBaseRefForCwd(cwd, context);
+    const baseRef = options.baseRef ?? resolvedBaseRef;
     if (!baseRef) {
         throw new Error("Unable to determine base branch for merge");
     }
-    if (configured.isPaseoOwnedWorktree && options.baseRef && options.baseRef !== baseRef) {
+    if (storedBaseRef && options.baseRef && options.baseRef !== storedBaseRef) {
         throw new Error(`Base ref mismatch: expected ${baseRef}, got ${options.baseRef}`);
     }
     if (!currentBranch) {
@@ -1371,54 +1527,12 @@ export async function mergeToBase(cwd, options = {}, context) {
         }
     }
     catch (error) {
-        const errorDetails = error instanceof Error
-            ? `${error.message}\n${error.stderr ?? ""}\n${error.stdout ?? ""}`
-            : String(error);
-        try {
-            const [unmergedOutput, lsFilesOutput, statusOutput] = await Promise.all([
-                runGitCommand(["diff", "--name-only", "--diff-filter=U"], { cwd: operationCwd }),
-                runGitCommand(["ls-files", "-u"], { cwd: operationCwd }),
-                runGitCommand(["status", "--porcelain"], { cwd: operationCwd }),
-            ]);
-            const statusConflicts = statusOutput.stdout
-                .split("\n")
-                .map((line) => line.trim())
-                .filter(Boolean)
-                .filter((line) => /^(UU|AA|DD|AU|UA|UD|DU)\s/.test(line))
-                .map((line) => line.slice(3).trim());
-            const conflicts = [
-                ...unmergedOutput.stdout
-                    .split("\n")
-                    .map((line) => line.trim())
-                    .filter(Boolean),
-                ...lsFilesOutput.stdout
-                    .split("\n")
-                    .map((line) => line.trim())
-                    .filter(Boolean)
-                    .map((line) => line.split("\t").pop()),
-                ...statusConflicts,
-            ].filter(Boolean);
-            const conflictDetected = conflicts.length > 0 || /CONFLICT|Automatic merge failed/i.test(errorDetails);
-            if (conflictDetected) {
-                try {
-                    await runGitCommand(["merge", "--abort"], { cwd: operationCwd, timeout: 120000 });
-                }
-                catch {
-                    // ignore
-                }
-                throw new MergeConflictError({
-                    baseRef: normalizedBaseRef,
-                    currentBranch,
-                    conflictFiles: conflicts.length > 0 ? conflicts : [],
-                });
-            }
-        }
-        catch (innerError) {
-            if (innerError instanceof MergeConflictError) {
-                throw innerError;
-            }
-            // ignore detection failures
-        }
+        await detectAndThrowMergeToBaseConflict({
+            operationCwd,
+            error,
+            baseRef: normalizedBaseRef,
+            currentBranch,
+        });
         throw error;
     }
     finally {
@@ -1442,19 +1556,19 @@ export async function mergeFromBase(cwd, options = {}, context) {
     if (!currentBranch || currentBranch === "HEAD") {
         throw new Error("Unable to determine current branch for merge");
     }
-    const configured = await getConfiguredBaseRefForCwd(cwd, context);
-    const baseRef = configured.baseRef ?? options.baseRef ?? (await resolveBaseRef(cwd));
+    const { storedBaseRef, resolvedBaseRef } = await resolveBaseRefForCwd(cwd, context);
+    const baseRef = options.baseRef ?? resolvedBaseRef;
     if (!baseRef) {
         throw new Error("Unable to determine base branch for merge");
     }
-    if (configured.isPaseoOwnedWorktree && options.baseRef && options.baseRef !== baseRef) {
+    if (storedBaseRef && options.baseRef && options.baseRef !== storedBaseRef) {
         throw new Error(`Base ref mismatch: expected ${baseRef}, got ${options.baseRef}`);
     }
     const requireCleanTarget = options.requireCleanTarget ?? true;
     if (requireCleanTarget) {
         const { stdout } = await runGitCommand(["status", "--porcelain"], {
             cwd,
-            env: READ_ONLY_GIT_ENV,
+            envOverlay: READ_ONLY_GIT_ENV,
         });
         if (stdout.trim().length > 0) {
             throw new Error("Working directory has uncommitted changes.");
@@ -1469,55 +1583,64 @@ export async function mergeFromBase(cwd, options = {}, context) {
         await runGitCommand(["merge", bestBaseRef], { cwd, timeout: 120000 });
     }
     catch (error) {
-        const errorDetails = error instanceof Error
-            ? `${error.message}\n${error.stderr ?? ""}\n${error.stdout ?? ""}`
-            : String(error);
-        try {
-            const [unmergedOutput, lsFilesOutput, statusOutput] = await Promise.all([
-                runGitCommand(["diff", "--name-only", "--diff-filter=U"], { cwd }),
-                runGitCommand(["ls-files", "-u"], { cwd }),
-                runGitCommand(["status", "--porcelain"], { cwd }),
-            ]);
-            const statusConflicts = statusOutput.stdout
+        await detectAndThrowMergeFromBaseConflict({
+            cwd,
+            error,
+            baseRef: bestBaseRef,
+            currentBranch,
+        });
+        throw error;
+    }
+}
+async function detectAndThrowMergeFromBaseConflict(input) {
+    const { cwd, error, baseRef, currentBranch } = input;
+    const errorDetails = error instanceof Error
+        ? `${error.message}\n${error.stderr ?? ""}\n${error.stdout ?? ""}`
+        : String(error);
+    try {
+        const [unmergedOutput, lsFilesOutput, statusOutput] = await Promise.all([
+            runGitCommand(["diff", "--name-only", "--diff-filter=U"], { cwd }),
+            runGitCommand(["ls-files", "-u"], { cwd }),
+            runGitCommand(["status", "--porcelain"], { cwd }),
+        ]);
+        const statusConflicts = statusOutput.stdout
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .filter((line) => /^(UU|AA|DD|AU|UA|UD|DU)\s/.test(line))
+            .map((line) => line.slice(3).trim());
+        const conflicts = [
+            ...unmergedOutput.stdout
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean),
+            ...lsFilesOutput.stdout
                 .split("\n")
                 .map((line) => line.trim())
                 .filter(Boolean)
-                .filter((line) => /^(UU|AA|DD|AU|UA|UD|DU)\s/.test(line))
-                .map((line) => line.slice(3).trim());
-            const conflicts = [
-                ...unmergedOutput.stdout
-                    .split("\n")
-                    .map((line) => line.trim())
-                    .filter(Boolean),
-                ...lsFilesOutput.stdout
-                    .split("\n")
-                    .map((line) => line.trim())
-                    .filter(Boolean)
-                    .map((line) => line.split("\t").pop()),
-                ...statusConflicts,
-            ].filter(Boolean);
-            const conflictDetected = conflicts.length > 0 || /CONFLICT|Automatic merge failed/i.test(errorDetails);
-            if (conflictDetected) {
-                try {
-                    await runGitCommand(["merge", "--abort"], { cwd, timeout: 120000 });
-                }
-                catch {
-                    // ignore
-                }
-                throw new MergeFromBaseConflictError({
-                    baseRef: bestBaseRef,
-                    currentBranch,
-                    conflictFiles: conflicts.length > 0 ? conflicts : [],
-                });
+                .map((line) => line.split("\t").pop()),
+            ...statusConflicts,
+        ].filter(Boolean);
+        const conflictDetected = conflicts.length > 0 || /CONFLICT|Automatic merge failed/i.test(errorDetails);
+        if (conflictDetected) {
+            try {
+                await runGitCommand(["merge", "--abort"], { cwd, timeout: 120000 });
             }
-        }
-        catch (innerError) {
-            if (innerError instanceof MergeFromBaseConflictError) {
-                throw innerError;
+            catch {
+                // ignore
             }
-            // ignore detection failures
+            throw new MergeFromBaseConflictError({
+                baseRef,
+                currentBranch,
+                conflictFiles: conflicts.length > 0 ? conflicts : [],
+            });
         }
-        throw error;
+    }
+    catch (innerError) {
+        if (innerError instanceof MergeFromBaseConflictError) {
+            throw innerError;
+        }
+        // ignore detection failures
     }
 }
 export async function pullCurrentBranch(cwd, github) {
@@ -1552,15 +1675,15 @@ export async function pushCurrentBranch(cwd, github) {
     await runGitCommand(["push", "-u", "origin", currentBranch], { cwd, timeout: 120000 });
     github?.invalidate({ cwd });
 }
-export async function createPullRequest(cwd, options, github = createGitHubService(), workspaceGitService) {
+export async function createPullRequest(cwd, options, github = createGitHubService(), context) {
     await requireGitRepo(cwd);
-    const repo = await resolveGitHubRepo(cwd, { workspaceGitService });
+    const repo = await resolveGitHubRepo(cwd);
     if (!repo) {
         throw new Error("Unable to determine GitHub repo from git remote");
     }
     const head = options.head ?? (await getCurrentBranch(cwd));
-    const configured = await getConfiguredBaseRefForCwd(cwd);
-    const base = configured.baseRef ?? options.base ?? (await resolveBaseRef(cwd));
+    const { storedBaseRef, resolvedBaseRef } = await resolveBaseRefForCwd(cwd, context);
+    const base = options.base ?? resolvedBaseRef;
     if (!head) {
         throw new Error("Unable to determine head branch for PR");
     }
@@ -1568,7 +1691,7 @@ export async function createPullRequest(cwd, options, github = createGitHubServi
         throw new Error("Unable to determine base branch for PR");
     }
     const normalizedBase = normalizeLocalBranchRefName(base);
-    if (configured.isPaseoOwnedWorktree && options.base && options.base !== base) {
+    if (storedBaseRef && options.base && options.base !== storedBaseRef) {
         throw new Error(`Base ref mismatch: expected ${base}, got ${options.base}`);
     }
     await runGitCommand(["push", "-u", "origin", head], { cwd, timeout: 120000 });
@@ -1598,7 +1721,17 @@ export async function getPullRequestStatus(cwd, github = createGitHubService(),
     const lookup = getPullRequestStatusUncached(cwd, github, options)
         .then((status) => {
         pullRequestStatusCache.set(cacheKey, status);
+        rememberPullRequestStatus(cacheKey, status);
         return status;
+    })
+        .catch((error) => {
+        if (error instanceof GitHubCommandError) {
+            const stale = lastSuccessfulPullRequestStatus.get(cacheKey);
+            if (stale) {
+                return stale;
+            }
+        }
+        throw error;
     })
         .finally(() => {
         pullRequestStatusInFlight.delete(cacheKey);
@@ -1616,9 +1749,10 @@ async function getPullRequestStatusUncached(cwd, github, options) {
         };
     }
     try {
+        const lookupTarget = await resolvePullRequestStatusLookupTarget(cwd, head);
         const status = await github.getCurrentPullRequestStatus({
             cwd,
-            headRef: head,
+            ...lookupTarget,
             reason: options?.reason,
         });
         return {