@getpaseo/server 0.1.83 → 0.1.84

package/dist/server/server/worktree-session.js

@@ -1,10 +1,10 @@
 import { basename } from "node:path";
 import { runAsyncWorktreeBootstrap, applyWorktreeSetupProgressEvent, buildWorktreeSetupDetail, createWorktreeSetupProgressAccumulator, getWorktreeSetupProgressResults, } from "./worktree-bootstrap.js";
 import { expandTilde } from "../utils/path.js";
-import { getWorktreeSetupCommands, isPaseoOwnedWorktreeCwd, resolveWorktreeRuntimeEnv, runWorktreeSetupCommands, slugify, validateBranchSlug, WorktreeSetupError, } from "../utils/worktree.js";
+import { getWorktreeSetupCommands, resolveWorktreeRuntimeEnv, runWorktreeSetupCommands, slugify, validateBranchSlug, WorktreeSetupError, } from "../utils/worktree.js";
 import { toCheckoutError } from "./checkout-git-utils.js";
-import { archivePaseoWorktree, } from "./paseo-worktree-archive-service.js";
 import { toWorktreeWireError } from "./worktree-errors.js";
+import { archivePaseoWorktreeCommand, createPaseoWorktreeCommand, listPaseoWorktreesCommand, } from "./worktree/commands.js";
 const SAFE_GIT_REF_PATTERN = /^[A-Za-z0-9._/-]+$/;
 function normalizeFirstAgentContext(request) {
     if (request.firstAgentContext) {
@@ -165,7 +165,7 @@ export async function handlePaseoWorktreeListRequest(dependencies, msg) {
         return;
     }
     try {
-        const worktrees = await dependencies.workspaceGitService.listWorktrees(cwd);
+        const worktrees = await listPaseoWorktreesCommand({ workspaceGitService: dependencies.workspaceGitService }, { cwd });
         dependencies.emit({
             type: "paseo_worktree_list_response",
             payload: {
@@ -193,56 +193,33 @@ export async function handlePaseoWorktreeListRequest(dependencies, msg) {
 }
 export async function handlePaseoWorktreeArchiveRequest(dependencies, msg) {
     const { requestId } = msg;
-    let targetPath = msg.worktreePath;
-    let repoRoot = msg.repoRoot ?? null;
     try {
-        if (!targetPath) {
-            if (!repoRoot || !msg.branchName) {
-                throw new Error("worktreePath or repoRoot+branchName is required");
-            }
-            const worktrees = await dependencies.workspaceGitService.listWorktrees(repoRoot);
-            const match = worktrees.find((entry) => entry.branchName === msg.branchName);
-            if (!match) {
-                throw new Error(`Paseo worktree not found for branch ${msg.branchName}`);
-            }
-            targetPath = match.path;
-        }
-        if (!targetPath) {
-            throw new Error("worktreePath could not be resolved");
-        }
-        const ownership = await isPaseoOwnedWorktreeCwd(targetPath, {
-            paseoHome: dependencies.paseoHome,
+        const result = await archivePaseoWorktreeCommand(dependencies, {
+            requestId,
+            worktreePath: msg.worktreePath,
+            repoRoot: msg.repoRoot,
+            branchName: msg.branchName,
         });
-        if (!ownership.allowed) {
+        if (!result.ok) {
             dependencies.emit({
                 type: "paseo_worktree_archive_response",
                 payload: {
                     success: false,
-                    removedAgents: [],
+                    removedAgents: result.removedAgents,
                     error: {
-                        code: "NOT_ALLOWED",
-                        message: "Worktree is not a Paseo-owned worktree",
+                        code: result.code,
+                        message: result.message,
                     },
                     requestId,
                 },
             });
             return;
         }
-        // repoRoot is best-effort: if git has forgotten about the worktree we
-        // still proceed using the path-derived worktreesRoot, since the ownership
-        // check already proved the path lives under $PASEO_HOME/worktrees.
-        repoRoot = ownership.repoRoot ?? repoRoot ?? null;
-        const removedAgents = await archivePaseoWorktree(dependencies, {
-            targetPath,
-            repoRoot,
-            worktreesRoot: ownership.worktreeRoot,
-            requestId,
-        });
         dependencies.emit({
             type: "paseo_worktree_archive_response",
             payload: {
                 success: true,
-                removedAgents,
+                removedAgents: result.removedAgents,
                 error: null,
                 requestId,
             },
@@ -262,7 +239,10 @@ export async function handlePaseoWorktreeArchiveRequest(dependencies, msg) {
 }
 export async function handleCreatePaseoWorktreeRequest(dependencies, request) {
     try {
-        const createdWorktree = await dependencies.createPaseoWorktreeWorkflow({
+        const commandResult = await createPaseoWorktreeCommand({
+            paseoHome: dependencies.paseoHome,
+            createPaseoWorktreeWorkflow: dependencies.createPaseoWorktreeWorkflow,
+        }, {
             cwd: request.cwd,
             projectId: request.projectId,
             worktreeSlug: request.worktreeSlug,
@@ -270,9 +250,22 @@ export async function handleCreatePaseoWorktreeRequest(dependencies, request) {
             refName: request.refName,
             action: request.action,
             githubPrNumber: request.githubPrNumber,
-            runSetup: false,
-            paseoHome: dependencies.paseoHome,
         });
+        if (!commandResult.ok) {
+            dependencies.sessionLogger.error({ err: commandResult.cause, cwd: request.cwd, worktreeSlug: request.worktreeSlug }, "Failed to create worktree");
+            dependencies.emit({
+                type: "create_paseo_worktree_response",
+                payload: {
+                    workspace: null,
+                    error: commandResult.error.message,
+                    errorCode: commandResult.error.code,
+                    setupTerminalId: null,
+                    requestId: request.requestId,
+                },
+            });
+            return;
+        }
+        const createdWorktree = commandResult.createdWorktree;
         const descriptor = await dependencies.describeWorkspaceRecord(createdWorktree);
         dependencies.emit({
             type: "create_paseo_worktree_response",

package/dist/server/services/github-service.d.ts

@@ -1,4 +1,4 @@
-import type { GitHubSearchKind } from "../shared/messages.js";
+import type { GitHubSearchKind } from "@getpaseo/protocol/messages";
 export declare const GITHUB_POLL_FAST_INTERVAL_MS = 20000;
 export declare const GITHUB_POLL_SLOW_INTERVAL_MS = 120000;
 export declare const GITHUB_POLL_ERROR_BACKOFF_CAP_MS = 300000;

package/dist/server/terminal/terminal-restore.d.ts

@@ -1,4 +1,4 @@
-import type { SubscribeTerminalRequest } from "../server/messages.js";
+import type { SubscribeTerminalRequest } from "@getpaseo/protocol/messages";
 import type { TerminalStateSnapshot, TerminalStateSnapshotOptions } from "./terminal.js";
 export declare const MAX_TERMINAL_OUTPUT_FRAME_BYTES: number;
 export type TerminalRestoreOptions = NonNullable<SubscribeTerminalRequest["restore"]>;

package/dist/server/terminal/terminal-restore.js

@@ -1,5 +1,5 @@
-import { TerminalStreamOpcode, encodeTerminalSnapshotPayload, encodeTerminalStreamFrame, } from "../shared/binary-frames/index.js";
-import { renderTerminalSnapshotToAnsi } from "../shared/terminal-snapshot.js";
+import { TerminalStreamOpcode, encodeTerminalSnapshotPayload, encodeTerminalStreamFrame, } from "@getpaseo/protocol/binary-frames/index";
+import { renderTerminalSnapshotToAnsi } from "@getpaseo/protocol/terminal-snapshot";
 export const MAX_TERMINAL_OUTPUT_FRAME_BYTES = 256 * 1024;
 const DEFAULT_VISIBLE_RESTORE_SCROLLBACK_LINES = 200;
 const MAX_VISIBLE_RESTORE_SCROLLBACK_LINES = 500;

package/dist/server/terminal/terminal-session-controller.d.ts

@@ -1,6 +1,6 @@
 import type pino from "pino";
 import type { SessionInboundMessage, SessionOutboundMessage } from "../server/messages.js";
-import { type TerminalStreamFrame } from "../shared/binary-frames/index.js";
+import { type TerminalStreamFrame } from "@getpaseo/protocol/binary-frames/index";
 import type { TerminalManager } from "./terminal-manager.js";
 export interface TerminalSessionControllerOptions {
     terminalManager: TerminalManager | null;

package/dist/server/terminal/terminal-session-controller.js

@@ -1,5 +1,5 @@
 import { killTerminalsUnderPath as killWorktreeTerminalsUnderPath } from "../server/paseo-worktree-archive-service.js";
-import { TerminalStreamOpcode, decodeTerminalResizePayload, encodeTerminalStreamFrame, } from "../shared/binary-frames/index.js";
+import { TerminalStreamOpcode, decodeTerminalResizePayload, encodeTerminalStreamFrame, } from "@getpaseo/protocol/binary-frames/index";
 import { TerminalOutputCoalescer } from "./terminal-output-coalescer.js";
 import { MAX_TERMINAL_OUTPUT_FRAME_BYTES, encodeLegacyTerminalSnapshotFrame, encodeTerminalRestoreFrame, resolveRestoreAfterOutputOverflow, resolveTerminalRestoreSnapshotOptions, resolveTerminalSubscriptionSnapshotMode, } from "./terminal-restore.js";
 const MAX_TERMINAL_STREAM_SLOTS = 256;

package/dist/server/terminal/terminal-worker-protocol.d.ts

@@ -1,5 +1,5 @@
 import type { TerminalExitInfo, ServerMessage, ClientMessage, TerminalStateSnapshot, TerminalStateSnapshotOptions } from "./terminal.js";
-import type { TerminalState } from "../shared/messages.js";
+import type { TerminalState } from "@getpaseo/protocol/messages";
 import type { CaptureTerminalLinesResult } from "./terminal-capture.js";
 export interface WorkerTerminalInfo {
     id: string;

package/dist/server/terminal/terminal.d.ts

@@ -1,4 +1,4 @@
-import type { TerminalState } from "../shared/messages.js";
+import type { TerminalState } from "@getpaseo/protocol/messages";
 export interface TerminalExitInfo {
     exitCode: number | null;
     signal: number | null;

package/dist/server/terminal/terminal.js

@@ -8,7 +8,7 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { createExternalProcessEnv } from "../server/paseo-env.js";
 import { writePrivateFileAtomicSync } from "../server/private-files.js";
-import { TerminalInputModeTracker } from "../shared/terminal-input-mode.js";
+import { TerminalInputModeTracker } from "@getpaseo/protocol/terminal-input-mode";
 const { Terminal } = xterm;
 const require = createRequire(import.meta.url);
 let nodePtySpawnHelperChecked = false;

package/dist/server/terminal/worker-terminal-manager.js

@@ -1,7 +1,7 @@
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
-import { TerminalInputModeTracker } from "../shared/terminal-input-mode.js";
+import { TerminalInputModeTracker } from "@getpaseo/protocol/terminal-input-mode";
 const REQUEST_TIMEOUT_MS = 10000;
 function resolveWorkerUrl() {
     const currentUrl = import.meta.url;

package/dist/server/utils/build-metadata-prompt.js

@@ -1,5 +1,5 @@
 import { readPaseoConfigJson } from "./paseo-config-file.js";
-import { PaseoConfigSchema } from "./paseo-config-schema.js";
+import { PaseoConfigSchema } from "@getpaseo/protocol/paseo-config-schema";
 import { wrapWithUserInstructions } from "./wrap-user-instructions.js";
 export async function buildMetadataPrompt(options) {
     const instructions = await readProjectMetadataInstructions(options);

package/dist/server/utils/checkout-git.d.ts

@@ -5,6 +5,10 @@ interface CheckoutReadCacheOptions {
     force?: boolean;
     reason?: string;
 }
+interface PullRequestStatusLookupTarget {
+    headRef: string;
+    headRepositoryOwner?: string;
+}
 export declare function __resetPullRequestStatusCacheForTests(): void;
 export declare function __setPullRequestStatusCacheTtlForTests(ttlMs: number): void;
 export declare function __resetCheckoutShortstatCacheForTests(): void;
@@ -127,7 +131,27 @@ export interface MergeFromBaseOptions {
 export interface CheckoutContext {
     paseoHome?: string;
     logger?: Pick<Logger, "trace">;
+    facts?: CheckoutSnapshotFacts | null;
 }
+export type CheckoutSnapshotFacts = {
+    isGit: false;
+} | {
+    isGit: true;
+    worktreeRoot: string;
+    currentBranch: string | null;
+    remoteUrl: string | null;
+    absoluteGitDir: string | null;
+    gitCommonDir: string | null;
+    paseoWorktree: PaseoWorktreeForCwd;
+    storedBaseRef: string | null;
+    resolvedBaseRef: string | null;
+    mainRepoRoot: string | null;
+    comparisonBaseRef: string | null;
+    branchRemoteName: string | null;
+    branchMergeRef: string | null;
+    trackedOriginBranch: string | null;
+    pullRequestLookupTarget: PullRequestStatusLookupTarget | null;
+};
 export declare function getCurrentBranch(cwd: string): Promise<string | null>;
 export declare function getMainRepoRoot(cwd: string): Promise<string>;
 export interface GitWorktreeEntry {
@@ -145,10 +169,17 @@ export declare function renameCurrentBranch(cwd: string, newName: string): Promi
     previousBranch: string | null;
     currentBranch: string | null;
 }>;
+type PaseoWorktreeForCwd = {
+    isPaseoOwnedWorktree: false;
+} | {
+    isPaseoOwnedWorktree: true;
+    worktreeRoot: string;
+};
 export declare function getOriginRemoteUrl(cwd: string): Promise<string | null>;
 export declare function hasOriginRemote(cwd: string): Promise<boolean>;
 export declare function resolveAbsoluteGitDir(cwd: string): Promise<string | null>;
 export declare function resolveRepositoryDefaultBranch(repoRoot: string): Promise<string | null>;
+export declare function getCheckoutSnapshotFacts(cwd: string, context?: CheckoutContext): Promise<CheckoutSnapshotFacts>;
 export declare function getCheckoutStatus(cwd: string, context?: CheckoutContext): Promise<CheckoutStatusResult>;
 export interface CheckoutShortstat {
     additions: number;
@@ -208,6 +239,6 @@ export declare function createPullRequest(cwd: string, options: CreatePullReques
     url: string;
     number: number;
 }>;
-export declare function getPullRequestStatus(cwd: string, github?: GitHubService, options?: CheckoutReadCacheOptions): Promise<PullRequestStatusResult>;
+export declare function getPullRequestStatus(cwd: string, github?: GitHubService, options?: CheckoutReadCacheOptions, context?: CheckoutContext): Promise<PullRequestStatusResult>;
 export {};
 //# sourceMappingURL=checkout-git.d.ts.map

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

@@ -523,7 +523,9 @@ export async function getMainRepoRoot(cwd) {
         cwd,
         envOverlay: READ_ONLY_GIT_ENV,
     });
-    const commonDir = resolveGitRevParsePath(cwd, commonDirOut);
+    return getMainRepoRootFromCommonDir(cwd, resolveGitRevParsePath(cwd, commonDirOut));
+}
+async function getMainRepoRootFromCommonDir(cwd, commonDir) {
     if (!commonDir) {
         throw new Error("Not in a git repository");
     }
@@ -617,7 +619,7 @@ export async function renameCurrentBranch(cwd, newName) {
     const currentBranch = await getCurrentBranch(cwd);
     return { previousBranch, currentBranch };
 }
-async function getPaseoWorktreeForCwd(cwd, context) {
+async function getPaseoWorktreeForCwd(cwd, context, knownWorktreeRoot) {
     // Fast-path reject: non-worktree paths do not need expensive ownership checks.
     if (!/[\\/]worktrees[\\/]/.test(cwd)) {
         return { isPaseoOwnedWorktree: false };
@@ -628,13 +630,16 @@ async function getPaseoWorktreeForCwd(cwd, context) {
     }
     return {
         isPaseoOwnedWorktree: true,
-        worktreeRoot: (await getWorktreeRoot(cwd)) ?? cwd,
+        worktreeRoot: knownWorktreeRoot ?? (await getWorktreeRoot(cwd)) ?? cwd,
     };
 }
 function readPaseoWorktreeBaseRef(worktreeRoot) {
     return readPaseoWorktreeMetadata(worktreeRoot)?.baseRefName ?? null;
 }
 async function getStoredBaseRefForCwd(cwd, context) {
+    if (context?.facts?.isGit) {
+        return context.facts.storedBaseRef;
+    }
     const paseoWorktree = await getPaseoWorktreeForCwd(cwd, context);
     if (!paseoWorktree.isPaseoOwnedWorktree) {
         return null;
@@ -642,10 +647,19 @@ async function getStoredBaseRefForCwd(cwd, context) {
     return readPaseoWorktreeBaseRef(paseoWorktree.worktreeRoot);
 }
 async function getResolvedBaseRefForCwd(cwd, context) {
+    if (context?.facts?.isGit) {
+        return context.facts.resolvedBaseRef;
+    }
     const { resolvedBaseRef } = await resolveBaseRefForCwd(cwd, context);
     return resolvedBaseRef;
 }
 async function resolveBaseRefForCwd(cwd, context) {
+    if (context?.facts?.isGit) {
+        return {
+            storedBaseRef: context.facts.storedBaseRef,
+            resolvedBaseRef: context.facts.resolvedBaseRef,
+        };
+    }
     const storedBaseRef = await getStoredBaseRefForCwd(cwd, context);
     return {
         storedBaseRef,
@@ -699,7 +713,10 @@ function parseBranchMergeHeadRef(mergeRef) {
     const headRef = mergeRef.slice(prefix.length).trim();
     return headRef.length > 0 ? headRef : null;
 }
-async function resolvePullRequestStatusLookupTarget(cwd, currentBranch) {
+async function resolvePullRequestStatusLookupTarget(cwd, currentBranch, context) {
+    if (context?.facts?.isGit && context.facts.pullRequestLookupTarget) {
+        return context.facts.pullRequestLookupTarget;
+    }
     const remoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.remote`);
     if (!remoteName?.startsWith("paseo-pr-")) {
         return { headRef: currentBranch };
@@ -730,6 +747,18 @@ export async function resolveAbsoluteGitDir(cwd) {
         return null;
     }
 }
+async function resolveGitCommonDir(cwd) {
+    try {
+        const { stdout } = await runGitCommand(["rev-parse", "--git-common-dir"], {
+            cwd,
+            envOverlay: READ_ONLY_GIT_ENV,
+        });
+        return resolveGitRevParsePath(cwd, stdout);
+    }
+    catch {
+        return null;
+    }
+}
 async function abortGitPullConflictState(cwd) {
     const gitDir = await resolveAbsoluteGitDir(cwd);
     if (!gitDir) {
@@ -876,7 +905,12 @@ async function getAheadBehind(cwd, baseRef, currentBranch, context) {
     if (!normalizedBaseRef || !currentBranch || normalizedBaseRef === currentBranch) {
         return null;
     }
-    const comparisonBaseRef = await resolveBestComparisonBaseRef(cwd, baseRef, context);
+    const comparisonBaseRef = context?.facts?.isGit && context.facts.resolvedBaseRef === baseRef
+        ? context.facts.comparisonBaseRef
+        : await resolveBestComparisonBaseRef(cwd, baseRef, context);
+    if (!comparisonBaseRef) {
+        return null;
+    }
     const { stdout } = await runGitCommand(["rev-list", "--left-right", "--count", `${comparisonBaseRef}...${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
     const [behindRaw, aheadRaw] = stdout.trim().split(/\s+/);
     const behind = Number.parseInt(behindRaw ?? "0", 10);
@@ -916,6 +950,9 @@ async function getAheadOfOrigin(cwd, currentBranch, baseRef, context) {
     }
 }
 async function getTrackedOriginBranch(cwd, currentBranch, context) {
+    if (context?.facts?.isGit && context.facts.currentBranch === currentBranch) {
+        return context.facts.trackedOriginBranch;
+    }
     const remoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.remote`, context);
     if (remoteName !== "origin") {
         return null;
@@ -942,15 +979,19 @@ async function inspectCheckoutContext(cwd, context) {
         if (!root) {
             return null;
         }
-        const [currentBranch, remoteUrl, paseoWorktree] = await Promise.all([
+        const [currentBranch, remoteUrl, absoluteGitDir, gitCommonDir, paseoWorktree] = await Promise.all([
             getCurrentBranch(cwd),
             getOriginRemoteUrl(cwd),
-            getPaseoWorktreeForCwd(cwd, context),
+            resolveAbsoluteGitDir(cwd),
+            resolveGitCommonDir(cwd),
+            getPaseoWorktreeForCwd(cwd, context, root),
         ]);
         return {
             worktreeRoot: root,
             currentBranch,
             remoteUrl,
+            absoluteGitDir,
+            gitCommonDir,
             paseoWorktree,
         };
     }
@@ -961,6 +1002,81 @@ async function inspectCheckoutContext(cwd, context) {
         throw error;
     }
 }
+function buildPullRequestLookupTargetFromBranchConfig(input) {
+    if (!input.branchRemoteName?.startsWith("paseo-pr-")) {
+        return { headRef: input.currentBranch };
+    }
+    const trackedHeadRef = parseBranchMergeHeadRef(input.branchMergeRef);
+    if (!trackedHeadRef) {
+        return { headRef: input.currentBranch };
+    }
+    const remoteRepo = input.branchRemoteUrl
+        ? parseGitHubRepoFromRemote(input.branchRemoteUrl)
+        : null;
+    const headRepositoryOwner = remoteRepo?.split("/")[0];
+    return {
+        headRef: trackedHeadRef,
+        ...(headRepositoryOwner ? { headRepositoryOwner } : {}),
+    };
+}
+export async function getCheckoutSnapshotFacts(cwd, context) {
+    if (context?.facts) {
+        return context.facts;
+    }
+    const inspected = await inspectCheckoutContext(cwd, context);
+    if (!inspected) {
+        return { isGit: false };
+    }
+    const storedBaseRef = inspected.paseoWorktree.isPaseoOwnedWorktree
+        ? readPaseoWorktreeBaseRef(inspected.paseoWorktree.worktreeRoot)
+        : null;
+    const resolvedBaseRef = storedBaseRef ?? (await resolveBaseRef(cwd));
+    const mainRepoRoot = await getMainRepoRootFromCommonDir(cwd, inspected.gitCommonDir).catch(() => null);
+    let comparisonBaseRef = null;
+    if (resolvedBaseRef &&
+        inspected.currentBranch &&
+        normalizeLocalBranchRefName(resolvedBaseRef) !== inspected.currentBranch) {
+        comparisonBaseRef = await resolveBestComparisonBaseRef(cwd, resolvedBaseRef, context).catch(() => null);
+    }
+    let branchRemoteName = null;
+    let branchMergeRef = null;
+    let branchRemoteUrl = null;
+    if (inspected.remoteUrl && inspected.currentBranch) {
+        branchRemoteName = await getGitConfigValue(cwd, `branch.${inspected.currentBranch}.remote`, context);
+        if (branchRemoteName) {
+            branchMergeRef = await getGitConfigValue(cwd, `branch.${inspected.currentBranch}.merge`, context);
+            if (branchRemoteName.startsWith("paseo-pr-")) {
+                branchRemoteUrl = await getGitConfigValue(cwd, `remote.${branchRemoteName}.url`, context);
+            }
+        }
+    }
+    const trackedOriginBranch = branchRemoteName === "origin" ? parseBranchMergeHeadRef(branchMergeRef) : null;
+    const pullRequestLookupTarget = inspected.currentBranch
+        ? buildPullRequestLookupTargetFromBranchConfig({
+            currentBranch: inspected.currentBranch,
+            branchRemoteName,
+            branchMergeRef,
+            branchRemoteUrl,
+        })
+        : null;
+    return {
+        isGit: true,
+        worktreeRoot: inspected.worktreeRoot,
+        currentBranch: inspected.currentBranch,
+        remoteUrl: inspected.remoteUrl,
+        absoluteGitDir: inspected.absoluteGitDir,
+        gitCommonDir: inspected.gitCommonDir,
+        paseoWorktree: inspected.paseoWorktree,
+        storedBaseRef,
+        resolvedBaseRef,
+        mainRepoRoot,
+        comparisonBaseRef,
+        branchRemoteName,
+        branchMergeRef,
+        trackedOriginBranch,
+        pullRequestLookupTarget,
+    };
+}
 const PER_FILE_DIFF_MAX_BYTES = 1024 * 1024; // 1MB
 const TOTAL_DIFF_MAX_BYTES = 2 * 1024 * 1024; // 2MB
 const UNTRACKED_BINARY_SNIFF_BYTES = 16 * 1024;
@@ -1049,27 +1165,28 @@ async function getUntrackedDiffText(cwd, change, ignoreWhitespace = false) {
     };
 }
 export async function getCheckoutStatus(cwd, context) {
-    const inspected = await inspectCheckoutContext(cwd, context);
-    if (!inspected) {
+    const facts = await getCheckoutSnapshotFacts(cwd, context);
+    if (!facts.isGit) {
         return { isGit: false };
     }
-    const worktreeRoot = inspected.worktreeRoot;
-    const currentBranch = inspected.currentBranch;
-    const remoteUrl = inspected.remoteUrl;
-    const paseoWorktree = inspected.paseoWorktree;
+    const worktreeRoot = facts.worktreeRoot;
+    const currentBranch = facts.currentBranch;
+    const remoteUrl = facts.remoteUrl;
+    const paseoWorktree = facts.paseoWorktree;
     const isDirty = await isWorkingTreeDirty(cwd, context);
     const hasRemote = remoteUrl !== null;
-    const { resolvedBaseRef: baseRef } = await resolveBaseRefForCwd(cwd, context);
-    const mainRepoRoot = await getMainRepoRoot(cwd).catch(() => null);
+    const baseRef = facts.resolvedBaseRef;
+    const mainRepoRoot = facts.mainRepoRoot;
+    const factsContext = { ...context, facts };
     const [aheadBehind, aheadOfOrigin, behindOfOrigin] = await Promise.all([
         baseRef && currentBranch
-            ? getAheadBehind(cwd, baseRef, currentBranch, context)
+            ? getAheadBehind(cwd, baseRef, currentBranch, factsContext)
             : Promise.resolve(null),
         hasRemote && currentBranch
-            ? getAheadOfOrigin(cwd, currentBranch, baseRef, context)
+            ? getAheadOfOrigin(cwd, currentBranch, baseRef, factsContext)
             : Promise.resolve(null),
         hasRemote && currentBranch
-            ? getBehindOfOrigin(cwd, currentBranch, context)
+            ? getBehindOfOrigin(cwd, currentBranch, factsContext)
             : Promise.resolve(null),
     ]);
     if (paseoWorktree.isPaseoOwnedWorktree && baseRef) {
@@ -1161,31 +1278,29 @@ async function countUntrackedAdditions(cwd) {
     }
 }
 async function getCheckoutShortstatUncached(cwd, context) {
-    try {
-        await requireGitRepo(cwd);
-    }
-    catch {
+    if (context?.facts?.isGit === false) {
         return null;
     }
-    const localBaseRef = await getResolvedBaseRefForCwd(cwd, context);
-    const currentBranch = await getCurrentBranch(cwd);
-    let comparisonRef;
-    if (currentBranch && localBaseRef && currentBranch !== localBaseRef) {
+    if (!context?.facts?.isGit) {
         try {
-            comparisonRef = await resolveBestComparisonBaseRef(cwd, localBaseRef);
+            await requireGitRepo(cwd);
         }
         catch {
             return null;
         }
     }
-    else if (currentBranch) {
-        const hasOrigin = await doesGitRefExist(cwd, `refs/remotes/origin/${currentBranch}`);
-        if (!hasOrigin) {
-            return null;
-        }
-        comparisonRef = `origin/${currentBranch}`;
-    }
-    else {
+    const facts = context?.facts;
+    const localBaseRef = facts?.isGit
+        ? facts.resolvedBaseRef
+        : await getResolvedBaseRefForCwd(cwd, context);
+    const currentBranch = facts?.isGit ? facts.currentBranch : await getCurrentBranch(cwd);
+    const comparisonRef = await resolveShortstatComparisonRef({
+        cwd,
+        currentBranch,
+        localBaseRef,
+        facts,
+    });
+    if (!comparisonRef) {
         return null;
     }
     try {
@@ -1217,6 +1332,24 @@ async function getCheckoutShortstatUncached(cwd, context) {
         return null;
     }
 }
+async function resolveShortstatComparisonRef(input) {
+    const { cwd, currentBranch, localBaseRef, facts } = input;
+    if (!currentBranch) {
+        return null;
+    }
+    if (localBaseRef && currentBranch !== localBaseRef) {
+        try {
+            return facts?.isGit && facts.resolvedBaseRef === localBaseRef && facts.comparisonBaseRef
+                ? facts.comparisonBaseRef
+                : await resolveBestComparisonBaseRef(cwd, localBaseRef);
+        }
+        catch {
+            return null;
+        }
+    }
+    const hasOrigin = await doesGitRefExist(cwd, `refs/remotes/origin/${currentBranch}`);
+    return hasOrigin ? `origin/${currentBranch}` : null;
+}
 function getOrLoadCheckoutShortstat(cwd, context, options) {
     const cacheKey = getShortstatCacheKey(cwd);
     if (!options?.force) {
@@ -1806,7 +1939,7 @@ export async function createPullRequest(cwd, options, github = createGitHubServi
     github.invalidate({ cwd });
     return result;
 }
-export async function getPullRequestStatus(cwd, github = createGitHubService(), options) {
+export async function getPullRequestStatus(cwd, github = createGitHubService(), options, context) {
     const cacheKey = getPullRequestStatusCacheKey(cwd);
     if (!options?.force) {
         const cached = pullRequestStatusCache.get(cacheKey);
@@ -1818,7 +1951,7 @@ export async function getPullRequestStatus(cwd, github = createGitHubService(),
             return existing;
         }
     }
-    const lookup = getPullRequestStatusUncached(cwd, github, options)
+    const lookup = getPullRequestStatusUncached(cwd, github, options, context)
         .then((status) => {
         pullRequestStatusCache.set(cacheKey, status);
         rememberPullRequestStatus(cacheKey, status);
@@ -1839,9 +1972,17 @@ export async function getPullRequestStatus(cwd, github = createGitHubService(),
     pullRequestStatusInFlight.set(cacheKey, lookup);
     return lookup;
 }
-async function getPullRequestStatusUncached(cwd, github, options) {
-    await requireGitRepo(cwd);
-    const head = await getCurrentBranch(cwd);
+async function getPullRequestStatusUncached(cwd, github, options, context) {
+    if (context?.facts?.isGit === false) {
+        return {
+            status: null,
+            githubFeaturesEnabled: false,
+        };
+    }
+    if (!context?.facts?.isGit) {
+        await requireGitRepo(cwd);
+    }
+    const head = context?.facts?.isGit ? context.facts.currentBranch : await getCurrentBranch(cwd);
     if (!head) {
         return {
             status: null,
@@ -1849,7 +1990,7 @@ async function getPullRequestStatusUncached(cwd, github, options) {
         };
     }
     try {
-        const lookupTarget = await resolvePullRequestStatusLookupTarget(cwd, head);
+        const lookupTarget = await resolvePullRequestStatusLookupTarget(cwd, head, context);
         let status;
         if (options?.force) {
             const reason = options.reason;

package/dist/server/utils/github-remote.d.ts

@@ -1,6 +1,6 @@
-import { type GitHubRemoteIdentity as ResolvedGitHubRemoteIdentity } from "../shared/git-remote.js";
+import { type GitHubRemoteIdentity as ResolvedGitHubRemoteIdentity } from "@getpaseo/protocol/git-remote";
 export type SshHostnameResolver = (host: string) => Promise<string | null>;
-export { parseGitHubRemoteUrl, type GitHubRemoteIdentity } from "../shared/git-remote.js";
+export { parseGitHubRemoteUrl, type GitHubRemoteIdentity } from "@getpaseo/protocol/git-remote";
 export declare function resolveGitHubRemote(input: {
     remoteUrl: string;
     resolveSshHostname?: SshHostnameResolver;