@getpaseo/server 0.1.88 → 0.1.90

package/dist/server/server/worktree/commands.js

@@ -17,6 +17,7 @@ export async function createPaseoWorktreeCommand(dependencies, input) {
             ...input,
             runSetup: false,
             paseoHome: input.paseoHome ?? dependencies.paseoHome,
+            worktreesRoot: input.worktreesRoot ?? dependencies.worktreesRoot,
         });
         return { ok: true, createdWorktree };
     }
@@ -32,6 +33,7 @@ export async function archivePaseoWorktreeCommand(dependencies, input) {
     const resolvedTarget = await resolveArchiveTarget(dependencies, input);
     const ownership = await isPaseoOwnedWorktreeCwd(resolvedTarget.targetPath, {
         paseoHome: dependencies.paseoHome,
+        worktreesRoot: dependencies.worktreesRoot,
     });
     if (!ownership.allowed) {
         return {
@@ -46,6 +48,7 @@ export async function archivePaseoWorktreeCommand(dependencies, input) {
         targetPath: resolvedTarget.targetPath,
         repoRoot,
         worktreesRoot: ownership.worktreeRoot,
+        worktreesBaseRoot: dependencies.worktreesRoot,
         requestId: input.requestId,
     });
     return {
@@ -78,7 +81,7 @@ async function resolveArchiveTarget(dependencies, input) {
     throw new Error("worktreePath, worktreeSlug, or repoRoot+branchName is required");
 }
 async function resolveWorktreeSlugPath(dependencies, repoRoot, worktreeSlug) {
-    const worktreesRoot = await getPaseoWorktreesRoot(repoRoot, dependencies.paseoHome);
+    const worktreesRoot = await getPaseoWorktreesRoot(repoRoot, dependencies.paseoHome, dependencies.worktreesRoot);
     return join(worktreesRoot, worktreeSlug);
 }
 //# sourceMappingURL=commands.js.map

package/dist/server/server/worktree-bootstrap.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from "pino";
 import type { TerminalManager } from "../terminal/terminal-manager.js";
 import { runWorktreeSetupCommands, type WorktreeConfig, type WorktreeSetupCommandResult } from "../utils/worktree.js";
-import { type ScriptRouteStore } from "./script-proxy.js";
+import { type ServiceProxySubsystem } from "./service-proxy.js";
 import type { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
 import type { AgentTimelineItem, ToolCallDetail } from "./agent/agent-sdk-types.js";
 export interface WorktreeBootstrapTerminalResult {
@@ -58,7 +58,8 @@ interface SpawnWorkspaceScriptOptions {
     scriptName: string;
     daemonPort?: number | null;
     daemonListenHost?: string | null;
-    routeStore: ScriptRouteStore;
+    serviceProxyPublicBaseUrl?: string | null;
+    serviceProxy: ServiceProxySubsystem;
     runtimeStore: WorkspaceScriptRuntimeStore;
     terminalManager: TerminalManager;
     logger?: Logger;
@@ -67,7 +68,7 @@ interface SpawnWorkspaceScriptOptions {
 export declare function spawnWorkspaceScript(options: SpawnWorkspaceScriptOptions): Promise<WorktreeScriptResult>;
 export declare function teardownWorktreeScripts(options: {
     hostnames: string[];
-    routeStore: ScriptRouteStore;
+    serviceProxy: Pick<ServiceProxySubsystem, "removeServiceRoutesByHostnames">;
     logger: Logger;
 }): void;
 export {};

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

@@ -1,7 +1,6 @@
 import { v4 as uuidv4 } from "uuid";
-import { buildScriptHostname } from "../utils/script-hostname.js";
 import { getScriptConfigs, getWorktreeTerminalSpecs, isServiceScript, paseoConfigParseError, processCarriageReturns, readPaseoConfig, resolveWorktreeRuntimeEnv, runWorktreeSetupCommands, WorktreeSetupError, } from "../utils/worktree.js";
-import { findFreePort } from "./script-proxy.js";
+import { findFreePort } from "./service-proxy.js";
 import { assertNoServiceEnvNameCollisions, buildWorkspaceServiceEnv, } from "./workspace-service-env.js";
 import { ensureWorkspaceServicePortPlan, requirePlannedWorkspaceServicePort, refreshWorkspaceServicePort, } from "./workspace-service-port-registry.js";
 const MAX_WORKTREE_SETUP_COMMAND_OUTPUT_BYTES = 64 * 1024;
@@ -501,8 +500,7 @@ export async function runAsyncWorktreeBootstrap(options) {
     await runWorktreeTerminalBootstrap(options, runtimeEnv);
 }
 async function setupServiceScriptRoute(params) {
-    const { scriptConfigs, config, scriptName, projectSlug, branchName, workspaceId, daemonPort, daemonListenHost, existingRuntimeEntry, routeStore, } = params;
-    const hostname = buildScriptHostname({ projectSlug, branchName, scriptName });
+    const { scriptConfigs, config, scriptName, projectSlug, branchName, workspaceId, daemonPort, daemonListenHost, serviceProxyPublicBaseUrl, existingRuntimeEntry, serviceProxy, } = params;
     const serviceDeclarations = [];
     for (const [configuredScriptName, scriptConfig] of scriptConfigs) {
         if (isServiceScript(scriptConfig)) {
@@ -538,16 +536,18 @@ async function setupServiceScriptRoute(params) {
         branchName,
         daemonPort,
         daemonListenHost,
+        serviceProxyPublicBaseUrl,
         peers,
     });
-    routeStore.registerRoute({
-        hostname,
+    const registeredRoute = serviceProxy.registerWorkspaceService({
         port,
         workspaceId,
         projectSlug,
+        branchName,
         scriptName,
+        publicBaseUrl: serviceProxyPublicBaseUrl ?? null,
     });
-    return { hostname, port, env };
+    return { hostname: registeredRoute.hostname, port, env };
 }
 async function acquireWorkspaceScriptTerminal(params) {
     const { serviceScript, existingRuntimeEntry, terminalManager, repoRoot, scriptName, env } = params;
@@ -565,7 +565,7 @@ async function acquireWorkspaceScriptTerminal(params) {
     return { terminal, reusableTerminal };
 }
 export async function spawnWorkspaceScript(options) {
-    const { repoRoot, workspaceId, projectSlug, branchName, scriptName, daemonPort, daemonListenHost, routeStore, runtimeStore, terminalManager, logger, onLifecycleChanged, } = options;
+    const { repoRoot, workspaceId, projectSlug, branchName, scriptName, daemonPort, daemonListenHost, serviceProxyPublicBaseUrl, serviceProxy, runtimeStore, terminalManager, logger, onLifecycleChanged, } = options;
     const configResult = readPaseoConfig(repoRoot);
     if (!configResult.ok) {
         throw paseoConfigParseError(configResult);
@@ -598,8 +598,9 @@ export async function spawnWorkspaceScript(options) {
                 workspaceId,
                 daemonPort,
                 daemonListenHost,
+                serviceProxyPublicBaseUrl,
                 existingRuntimeEntry,
-                routeStore,
+                serviceProxy,
             });
             hostname = serviceSetup.hostname;
             port = serviceSetup.port;
@@ -631,7 +632,7 @@ export async function spawnWorkspaceScript(options) {
             disposeLifecycleListeners?.();
             disposeLifecycleListeners = null;
             if (input.removeRoute && hostname) {
-                routeStore.removeRouteForWorkspaceScript({ workspaceId, scriptName });
+                serviceProxy.removeWorkspaceService({ workspaceId, scriptName });
             }
             runtimeStore.set({
                 workspaceId,
@@ -689,7 +690,7 @@ export async function spawnWorkspaceScript(options) {
     catch (error) {
         disposeLifecycleListeners?.();
         if (routeRegistered && hostname) {
-            routeStore.removeRoute(hostname);
+            serviceProxy.removeServiceRoutesByHostnames([hostname]);
         }
         if (runtimeRegistered) {
             runtimeStore.remove({ workspaceId, scriptName });
@@ -707,9 +708,9 @@ export async function spawnWorkspaceScript(options) {
     }
 }
 export function teardownWorktreeScripts(options) {
-    const { hostnames, routeStore, logger } = options;
+    const { hostnames, serviceProxy, logger } = options;
+    serviceProxy.removeServiceRoutesByHostnames(hostnames);
     for (const hostname of hostnames) {
-        routeStore.removeRoute(hostname);
         logger.info({ hostname }, "Removed script proxy route");
     }
 }

package/dist/server/server/worktree-core.d.ts

@@ -11,6 +11,7 @@ export interface CreateWorktreeCoreInput {
     githubPrNumber?: number;
     firstAgentContext?: FirstAgentContext;
     paseoHome?: string;
+    worktreesRoot?: string;
     runSetup?: boolean;
 }
 export interface CreateWorktreeCoreDeps {

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

@@ -54,6 +54,7 @@ export async function createWorktreeCore(input, deps) {
         slug: normalizedSlug,
         repoRoot,
         paseoHome: input.paseoHome,
+        worktreesRoot: input.worktreesRoot,
     });
     if (existingWorktree) {
         return { worktree: existingWorktree, intent, repoRoot, created: false };
@@ -65,6 +66,7 @@ export async function createWorktreeCore(input, deps) {
             source: intent,
             runSetup: input.runSetup ?? true,
             paseoHome: input.paseoHome,
+            worktreesRoot: input.worktreesRoot,
         }),
         intent,
         repoRoot,

package/dist/server/server/worktree-session.d.ts

@@ -5,7 +5,7 @@ import type { PersistedWorkspaceRecord } from "./workspace-registry.js";
 import type { WorkspaceGitService } from "./workspace-git-service.js";
 import { runAsyncWorktreeBootstrap } from "./worktree-bootstrap.js";
 import type { TerminalManager } from "../terminal/terminal-manager.js";
-import type { ScriptRouteStore } from "./script-proxy.js";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
 import type { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
 import type { GitHubService } from "../services/github-service.js";
 import type { CheckoutExistingBranchResult } from "../utils/checkout-git.js";
@@ -31,6 +31,7 @@ type AgentWorktreeSetupTimelineWriter = (input: {
 }) => Promise<boolean>;
 interface BuildAgentSessionConfigDependencies {
     paseoHome?: string;
+    worktreesRoot?: string;
     sessionLogger: Logger;
     workspaceGitService?: WorkspaceGitService;
     createPaseoWorktree: (input: CreatePaseoWorktreeInput, options?: {
@@ -47,6 +48,7 @@ interface BuildAgentSessionConfigDependencies {
 }
 interface CreatePaseoWorktreeInBackgroundDependencies {
     paseoHome?: string;
+    worktreesRoot?: string;
     emitWorkspaceUpdateForCwd: (cwd: string, options?: {
         dedupeGitState?: boolean;
     }) => Promise<void>;
@@ -55,10 +57,11 @@ interface CreatePaseoWorktreeInBackgroundDependencies {
     sessionLogger: Logger;
     terminalManager: TerminalManager | null;
     archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
-    scriptRouteStore: ScriptRouteStore | null;
+    serviceProxy: ServiceProxySubsystem | null;
     scriptRuntimeStore: WorkspaceScriptRuntimeStore | null;
     getDaemonTcpPort: (() => number | null) | null;
     getDaemonTcpHost: (() => string | null) | null;
+    serviceProxyPublicBaseUrl?: string | null;
     onScriptsChanged: ((workspaceId: string, workspaceDirectory: string) => void) | null;
 }
 interface CreatePaseoWorktreeWorkflowDependencies extends CreatePaseoWorktreeInBackgroundDependencies {
@@ -100,6 +103,7 @@ interface HandleWorkspaceSetupStatusRequestDependencies {
 }
 interface HandleCreatePaseoWorktreeRequestDependencies {
     paseoHome?: string;
+    worktreesRoot?: string;
     describeWorkspaceRecord: (result: CreatePaseoWorktreeResult) => Promise<WorkspaceDescriptorPayload>;
     emit: EmitSessionMessage;
     sessionLogger: Logger;

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

@@ -41,6 +41,7 @@ export async function buildAgentSessionConfig(dependencies, config, gitOptions,
             firstAgentContext,
             runSetup: false,
             paseoHome: dependencies.paseoHome,
+            worktreesRoot: dependencies.worktreesRoot,
         }, {
             resolveDefaultBranch: normalized.baseBranch
                 ? async () => normalized.baseBranch
@@ -241,6 +242,7 @@ export async function handleCreatePaseoWorktreeRequest(dependencies, request) {
     try {
         const commandResult = await createPaseoWorktreeCommand({
             paseoHome: dependencies.paseoHome,
+            worktreesRoot: dependencies.worktreesRoot,
             createPaseoWorktreeWorkflow: dependencies.createPaseoWorktreeWorkflow,
         }, {
             cwd: request.cwd,
@@ -304,6 +306,7 @@ export async function createPaseoWorktreeWorkflow(dependencies, input, options)
         ...input,
         runSetup: false,
         paseoHome: input.paseoHome ?? dependencies.paseoHome,
+        worktreesRoot: input.worktreesRoot ?? dependencies.worktreesRoot,
     }, options?.resolveDefaultBranch
         ? { resolveDefaultBranch: options.resolveDefaultBranch }
         : undefined);

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

@@ -228,6 +228,7 @@ export interface GitHubService {
     retainCurrentPullRequestStatusPoll?(options: {
         cwd: string;
         headRef: string;
+        headRepositoryOwner?: string;
         onStatus?: (status: GitHubCurrentPullRequestStatus | null) => void;
         onError?: (error: unknown) => void;
     }): {

package/dist/server/services/github-service.js

@@ -425,7 +425,10 @@ export function createGitHubService(options = {}) {
         return buildCacheKey({
             cwd: target.cwd,
             method: "getCurrentPullRequestStatus",
-            args: { headRef: target.headRef },
+            args: {
+                headRef: target.headRef,
+                headRepositoryOwner: target.headRepositoryOwner,
+            },
         });
     }
     function updatePollTargetAfterSuccess(update) {
@@ -465,6 +468,7 @@ export function createGitHubService(options = {}) {
             await api.getCurrentPullRequestStatus({
                 cwd: target.cwd,
                 headRef: target.headRef,
+                headRepositoryOwner: target.headRepositoryOwner,
                 reason: "self-heal-github",
             });
         }
@@ -601,6 +605,7 @@ export function createGitHubService(options = {}) {
                 updatePollTargetAfterSuccess({
                     cwd: input.cwd,
                     headRef: input.headRef,
+                    headRepositoryOwner: input.headRepositoryOwner,
                     status,
                     notify: input.reason === "self-heal-github",
                 });
@@ -795,6 +800,7 @@ export function createGitHubService(options = {}) {
                 target = {
                     cwd: input.cwd,
                     headRef: input.headRef,
+                    headRepositoryOwner: input.headRepositoryOwner,
                     retainCount: 0,
                     timer: null,
                     latestStatus: null,

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

@@ -130,6 +130,7 @@ export interface MergeFromBaseOptions {
 }
 export interface CheckoutContext {
     paseoHome?: string;
+    worktreesRoot?: string;
     logger?: Pick<Logger, "trace">;
     facts?: CheckoutSnapshotFacts | null;
 }
@@ -149,7 +150,6 @@ export type CheckoutSnapshotFacts = {
     comparisonBaseRef: string | null;
     branchRemoteName: string | null;
     branchMergeRef: string | null;
-    trackedOriginBranch: string | null;
     pullRequestLookupTarget: PullRequestStatusLookupTarget | null;
 };
 export declare function getCurrentBranch(cwd: string): Promise<string | null>;
@@ -159,8 +159,11 @@ export interface GitWorktreeEntry {
     branchRef?: string;
     isBare?: boolean;
 }
-/** Check whether a path contains a `.paseo/worktrees/` segment (both `/` and `\`). */
-export declare function isPaseoWorktreePath(p: string): boolean;
+/** Check whether a path is under Paseo's worktree root. */
+export declare function isPaseoWorktreePath(p: string, options?: {
+    paseoHome?: string;
+    worktreesRoot?: string;
+}): boolean;
 /** True when `child` is strictly inside `parent` (handles both `/` and `\`). */
 export declare function isDescendantPath(child: string, parent: string): boolean;
 export declare function parseWorktreeList(output: string): GitWorktreeEntry[];

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

@@ -7,7 +7,7 @@ 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 { isPaseoOwnedWorktreeCwd, resolvePaseoWorktreesBaseRoot } from "./worktree.js";
 import { readPaseoWorktreeMetadata } from "./worktree-metadata.js";
 const READ_ONLY_GIT_ENV = {
     GIT_OPTIONAL_LOCKS: "0",
@@ -570,7 +570,7 @@ export async function getMainRepoRoot(cwd) {
     });
     return getMainRepoRootFromCommonDir(cwd, resolveGitRevParsePath(cwd, commonDirOut));
 }
-async function getMainRepoRootFromCommonDir(cwd, commonDir) {
+async function getMainRepoRootFromCommonDir(cwd, commonDir, context) {
     if (!commonDir) {
         throw new Error("Not in a git repository");
     }
@@ -583,13 +583,20 @@ async function getMainRepoRootFromCommonDir(cwd, commonDir) {
         envOverlay: READ_ONLY_GIT_ENV,
     });
     const worktrees = parseWorktreeList(worktreeOut);
-    const nonBareNonPaseo = worktrees.filter((wt) => !wt.isBare && !isPaseoWorktreePath(wt.path));
+    const nonBareNonPaseo = worktrees.filter((wt) => !wt.isBare &&
+        !isPaseoWorktreePath(wt.path, {
+            paseoHome: context?.paseoHome,
+            worktreesRoot: context?.worktreesRoot,
+        }));
     const childrenOfBareRepo = nonBareNonPaseo.filter((wt) => isDescendantPath(wt.path, normalized));
     const mainChild = childrenOfBareRepo.find((wt) => basename(wt.path) === "main");
     return mainChild?.path ?? childrenOfBareRepo[0]?.path ?? nonBareNonPaseo[0]?.path ?? normalized;
 }
-/** Check whether a path contains a `.paseo/worktrees/` segment (both `/` and `\`). */
-export function isPaseoWorktreePath(p) {
+/** Check whether a path is under Paseo's worktree root. */
+export function isPaseoWorktreePath(p, options) {
+    if (options?.worktreesRoot || options?.paseoHome) {
+        return isDescendantPath(p, resolvePaseoWorktreesBaseRoot(options));
+    }
     return /[/\\]\.paseo[/\\]worktrees[/\\]/.test(p);
 }
 /** True when `child` is strictly inside `parent` (handles both `/` and `\`). */
@@ -669,7 +676,10 @@ async function getPaseoWorktreeForCwd(cwd, context, knownWorktreeRoot) {
     if (!/[\\/]worktrees[\\/]/.test(cwd)) {
         return { isPaseoOwnedWorktree: false };
     }
-    const ownership = await isPaseoOwnedWorktreeCwd(cwd, { paseoHome: context?.paseoHome });
+    const ownership = await isPaseoOwnedWorktreeCwd(cwd, {
+        paseoHome: context?.paseoHome,
+        worktreesRoot: context?.worktreesRoot,
+    });
     if (!ownership.allowed) {
         return { isPaseoOwnedWorktree: false };
     }
@@ -965,52 +975,46 @@ async function getAheadBehind(cwd, baseRef, currentBranch, context) {
     }
     return { ahead, behind };
 }
-async function getAheadOfOrigin(cwd, currentBranch, baseRef, context) {
+async function getAheadOfOrigin(cwd, currentBranch, context) {
     if (!currentBranch) {
         return null;
     }
-    const trackedOriginBranch = await getTrackedOriginBranch(cwd, currentBranch, context);
-    const originBranch = trackedOriginBranch ?? currentBranch;
+    const upstreamRef = await getConfiguredUpstreamRef(cwd, currentBranch, context);
+    if (!upstreamRef) {
+        return null;
+    }
     try {
-        const { stdout } = await runGitCommand(["rev-list", "--count", `origin/${originBranch}..${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
+        const { stdout } = await runGitCommand(["rev-list", "--count", `${upstreamRef}..${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
         const count = Number.parseInt(stdout.trim(), 10);
         return Number.isNaN(count) ? null : count;
     }
     catch {
-        if (trackedOriginBranch) {
-            return null;
-        }
-        if (!baseRef || normalizeLocalBranchRefName(baseRef) === currentBranch) {
-            return null;
-        }
-        try {
-            const comparisonBaseRef = await resolveBestComparisonBaseRef(cwd, baseRef, context);
-            const { stdout } = await runGitCommand(["rev-list", "--count", `${comparisonBaseRef}..${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
-            const count = Number.parseInt(stdout.trim(), 10);
-            return Number.isNaN(count) ? null : count;
-        }
-        catch {
-            return null;
-        }
+        return null;
     }
 }
-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") {
+async function getConfiguredUpstreamRef(cwd, currentBranch, context) {
+    const remoteName = context?.facts?.isGit && context.facts.currentBranch === currentBranch
+        ? context.facts.branchRemoteName
+        : await getGitConfigValue(cwd, `branch.${currentBranch}.remote`, context);
+    if (!remoteName) {
         return null;
     }
-    const mergeRef = await getGitConfigValue(cwd, `branch.${currentBranch}.merge`, context);
-    return parseBranchMergeHeadRef(mergeRef);
+    const mergeRef = context?.facts?.isGit && context.facts.currentBranch === currentBranch
+        ? context.facts.branchMergeRef
+        : await getGitConfigValue(cwd, `branch.${currentBranch}.merge`, context);
+    const upstreamBranch = parseBranchMergeHeadRef(mergeRef);
+    return upstreamBranch ? `${remoteName}/${upstreamBranch}` : null;
 }
 async function getBehindOfOrigin(cwd, currentBranch, context) {
     if (!currentBranch) {
         return null;
     }
+    const upstreamRef = await getConfiguredUpstreamRef(cwd, currentBranch, context);
+    if (!upstreamRef) {
+        return null;
+    }
     try {
-        const { stdout } = await runGitCommand(["rev-list", "--count", `${currentBranch}..origin/${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
+        const { stdout } = await runGitCommand(["rev-list", "--count", `${currentBranch}..${upstreamRef}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
         const count = Number.parseInt(stdout.trim(), 10);
         return Number.isNaN(count) ? null : count;
     }
@@ -1076,7 +1080,7 @@ export async function getCheckoutSnapshotFacts(cwd, context) {
         ? readPaseoWorktreeBaseRef(inspected.paseoWorktree.worktreeRoot)
         : null;
     const resolvedBaseRef = storedBaseRef ?? (await resolveBaseRef(cwd));
-    const mainRepoRoot = await getMainRepoRootFromCommonDir(cwd, inspected.gitCommonDir).catch(() => null);
+    const mainRepoRoot = await getMainRepoRootFromCommonDir(cwd, inspected.gitCommonDir, context).catch(() => null);
     let comparisonBaseRef = null;
     if (resolvedBaseRef &&
         inspected.currentBranch &&
@@ -1095,7 +1099,6 @@ export async function getCheckoutSnapshotFacts(cwd, context) {
             }
         }
     }
-    const trackedOriginBranch = branchRemoteName === "origin" ? parseBranchMergeHeadRef(branchMergeRef) : null;
     const pullRequestLookupTarget = inspected.currentBranch
         ? buildPullRequestLookupTargetFromBranchConfig({
             currentBranch: inspected.currentBranch,
@@ -1118,7 +1121,6 @@ export async function getCheckoutSnapshotFacts(cwd, context) {
         comparisonBaseRef,
         branchRemoteName,
         branchMergeRef,
-        trackedOriginBranch,
         pullRequestLookupTarget,
     };
 }
@@ -1228,7 +1230,7 @@ export async function getCheckoutStatus(cwd, context) {
             ? getAheadBehind(cwd, baseRef, currentBranch, factsContext)
             : Promise.resolve(null),
         hasRemote && currentBranch
-            ? getAheadOfOrigin(cwd, currentBranch, baseRef, factsContext)
+            ? getAheadOfOrigin(cwd, currentBranch, factsContext)
             : Promise.resolve(null),
         hasRemote && currentBranch
             ? getBehindOfOrigin(cwd, currentBranch, factsContext)

package/dist/server/utils/worktree.d.ts

@@ -83,6 +83,10 @@ export interface PaseoWorktreeOwnership {
     worktreeRoot?: string;
     worktreePath?: string;
 }
+export interface WorktreeRootOptions {
+    paseoHome?: string;
+    worktreesRoot?: string;
+}
 export type WorktreeSource = {
     kind: "branch-off";
     baseBranch: string;
@@ -104,11 +108,13 @@ export interface CreateWorktreeOptions {
     source: WorktreeSource;
     runSetup: boolean;
     paseoHome?: string;
+    worktreesRoot?: string;
 }
 interface ResolveExistingWorktreeForSlugOptions {
     slug: string;
     repoRoot: string;
     paseoHome?: string;
+    worktreesRoot?: string;
 }
 export declare class BranchAlreadyCheckedOutError extends Error {
     readonly branchName: string;
@@ -164,32 +170,31 @@ export declare function runWorktreeTeardownCommands(options: {
  */
 export declare function getGitCommonDir(cwd: string): Promise<string>;
 export declare function deriveWorktreeProjectHash(cwd: string): Promise<string>;
-export declare function getPaseoWorktreesRoot(cwd: string, paseoHome?: string): Promise<string>;
-export declare function computeWorktreePath(cwd: string, slug: string, paseoHome?: string): Promise<string>;
-export declare function isPaseoOwnedWorktreeCwd(cwd: string, options?: {
-    paseoHome?: string;
-}): Promise<PaseoWorktreeOwnership>;
-export declare function listPaseoWorktrees({ cwd, paseoHome, }: {
+export declare function resolvePaseoWorktreesBaseRoot(options?: WorktreeRootOptions): string;
+export declare function getPaseoWorktreesRoot(cwd: string, paseoHome?: string, worktreesRoot?: string): Promise<string>;
+export declare function computeWorktreePath(cwd: string, slug: string, paseoHome?: string, worktreesRoot?: string): Promise<string>;
+export declare function isPaseoOwnedWorktreeCwd(cwd: string, options?: WorktreeRootOptions): Promise<PaseoWorktreeOwnership>;
+export declare function listPaseoWorktrees({ cwd, paseoHome, worktreesRoot, }: {
     cwd: string;
     paseoHome?: string;
+    worktreesRoot?: string;
 }): Promise<PaseoWorktreeInfo[]>;
-export declare function resolveExistingWorktreeForSlug({ slug, repoRoot, paseoHome, }: ResolveExistingWorktreeForSlugOptions): Promise<WorktreeConfig | null>;
-export declare function resolvePaseoWorktreeRootForCwd(cwd: string, options?: {
-    paseoHome?: string;
-}): Promise<{
+export declare function resolveExistingWorktreeForSlug({ slug, repoRoot, paseoHome, worktreesRoot, }: ResolveExistingWorktreeForSlugOptions): Promise<WorktreeConfig | null>;
+export declare function resolvePaseoWorktreeRootForCwd(cwd: string, options?: WorktreeRootOptions): Promise<{
     repoRoot: string;
     worktreeRoot: string;
     worktreePath: string;
 } | null>;
-export declare function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, worktreesRoot, paseoHome, }: {
+export declare function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, worktreesRoot, paseoHome, worktreesBaseRoot, }: {
     cwd: string | null;
     worktreePath?: string;
     worktreeSlug?: string;
     worktreesRoot?: string;
     paseoHome?: string;
+    worktreesBaseRoot?: string;
 }): Promise<void>;
 /**
  * Create a git worktree with proper naming conventions
  */
-export declare const createWorktree: ({ cwd, source, worktreeSlug, runSetup, paseoHome, }: CreateWorktreeOptions) => Promise<WorktreeConfig>;
+export declare const createWorktree: ({ cwd, source, worktreeSlug, runSetup, paseoHome, worktreesRoot, }: CreateWorktreeOptions) => Promise<WorktreeConfig>;
 //# sourceMappingURL=worktree.d.ts.map