@getpaseo/server 0.1.88 → 0.1.89

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;
 }
@@ -159,8 +160,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 };
     }
@@ -1076,7 +1086,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 &&

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

package/dist/server/utils/worktree.js

@@ -2,7 +2,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { existsSync, mkdirSync, realpathSync, rmSync, statSync } from "fs";
 import { copyFile, rm, stat } from "fs/promises";
-import { join, basename, dirname, resolve, sep } from "path";
+import { join, basename, dirname, isAbsolute, resolve, sep } from "path";
 import net from "node:net";
 import { createHash } from "node:crypto";
 import stripAnsi from "strip-ansi";
@@ -17,6 +17,7 @@ import { resolvePaseoHome } from "../server/paseo-home.js";
 import { createExternalProcessEnv } from "../server/paseo-env.js";
 import { parseGitRevParsePath, resolveGitRevParsePath } from "./git-rev-parse-path.js";
 import { validateBranchSlug } from "@getpaseo/protocol/branch-slug";
+import { expandTilde } from "./path.js";
 export { slugify, validateBranchSlug } from "@getpaseo/protocol/branch-slug";
 const execFileAsync = promisify(execFile);
 const READ_ONLY_GIT_ENV = {
@@ -529,14 +530,26 @@ export async function deriveWorktreeProjectHash(cwd) {
         return deriveShortAlphanumericHash(normalizePathForOwnership(cwd));
     }
 }
-export async function getPaseoWorktreesRoot(cwd, paseoHome) {
-    const home = paseoHome ? resolve(paseoHome) : resolvePaseoHome();
+export function resolvePaseoWorktreesBaseRoot(options) {
+    if (options?.worktreesRoot) {
+        const expandedRoot = expandTilde(options.worktreesRoot);
+        if (isAbsolute(expandedRoot)) {
+            return resolve(expandedRoot);
+        }
+        const home = options.paseoHome ? resolve(options.paseoHome) : resolvePaseoHome();
+        return resolve(home, expandedRoot);
+    }
+    const home = options?.paseoHome ? resolve(options.paseoHome) : resolvePaseoHome();
+    return join(home, "worktrees");
+}
+export async function getPaseoWorktreesRoot(cwd, paseoHome, worktreesRoot) {
+    const baseRoot = resolvePaseoWorktreesBaseRoot({ paseoHome, worktreesRoot });
     const projectHash = await deriveWorktreeProjectHash(cwd);
-    return join(home, "worktrees", projectHash);
+    return join(baseRoot, projectHash);
 }
-export async function computeWorktreePath(cwd, slug, paseoHome) {
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
-    return join(worktreesRoot, slug);
+export async function computeWorktreePath(cwd, slug, paseoHome, worktreesRoot) {
+    const projectWorktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome, worktreesRoot);
+    return join(projectWorktreesRoot, slug);
 }
 function normalizePathForOwnership(input) {
     try {
@@ -565,9 +578,9 @@ export async function isPaseoOwnedWorktreeCwd(cwd, options) {
     catch {
         // ignore
     }
-    const paseoHome = options?.paseoHome ? resolve(options.paseoHome) : resolvePaseoHome();
-    const paseoWorktreesPrefix = normalizePathForOwnership(join(paseoHome, "worktrees")) + sep;
-    // Ownership is defined by the path living under $PASEO_HOME/worktrees/<hash>/<slug>[/...].
+    const worktreesBaseRoot = resolvePaseoWorktreesBaseRoot(options);
+    const paseoWorktreesPrefix = normalizePathForOwnership(worktreesBaseRoot) + sep;
+    // Ownership is defined by the path living under <worktrees-root>/<hash>/<slug>[/...].
     // The <hash>/<slug> prefix is Paseo-private — nothing else writes there — so the
     // path shape alone is sufficient proof of ownership, even when git has already
     // forgotten about the worktree.
@@ -587,7 +600,7 @@ export async function isPaseoOwnedWorktreeCwd(cwd, options) {
             worktreePath: resolvedCwd,
         };
     }
-    const worktreesRoot = join(paseoHome, "worktrees", parts[0]);
+    const worktreesRoot = join(worktreesBaseRoot, parts[0]);
     return {
         allowed: true,
         ...(repoRoot !== undefined ? { repoRoot } : {}),
@@ -639,22 +652,23 @@ function resolveWorktreeCreatedAtIso(worktreePath) {
         return new Date(0).toISOString();
     }
 }
-export async function listPaseoWorktrees({ cwd, paseoHome, }) {
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
+export async function listPaseoWorktrees({ cwd, paseoHome, worktreesRoot, }) {
+    const projectWorktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome, worktreesRoot);
     const { stdout } = await runGitCommand(["worktree", "list", "--porcelain"], {
         cwd,
         envOverlay: READ_ONLY_GIT_ENV,
     });
-    const rootPrefix = normalizePathForOwnership(worktreesRoot) + sep;
+    const rootPrefix = normalizePathForOwnership(projectWorktreesRoot) + sep;
     return parseWorktreeList(stdout)
         .map((entry) => Object.assign({}, entry, { path: normalizePathForOwnership(entry.path) }))
         .filter((entry) => entry.path.startsWith(rootPrefix))
         .map((entry) => Object.assign({}, entry, { createdAt: resolveWorktreeCreatedAtIso(entry.path) }));
 }
-export async function resolveExistingWorktreeForSlug({ slug, repoRoot, paseoHome, }) {
+export async function resolveExistingWorktreeForSlug({ slug, repoRoot, paseoHome, worktreesRoot, }) {
     const worktrees = await listPaseoWorktrees({
         cwd: repoRoot,
         paseoHome,
+        worktreesRoot,
     });
     const slugSuffix = `${sep}${slug}`;
     const existingWorktree = worktrees.find((worktree) => worktree.path.endsWith(slugSuffix));
@@ -682,7 +696,7 @@ export async function resolvePaseoWorktreeRootForCwd(cwd, options) {
     catch {
         return null;
     }
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, options?.paseoHome);
+    const worktreesRoot = await getPaseoWorktreesRoot(cwd, options?.paseoHome, options?.worktreesRoot);
     const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
     let worktreeRoot = null;
     try {
@@ -705,6 +719,7 @@ export async function resolvePaseoWorktreeRootForCwd(cwd, options) {
     const knownWorktrees = await listPaseoWorktrees({
         cwd,
         paseoHome: options?.paseoHome,
+        worktreesRoot: options?.worktreesRoot,
     });
     const match = knownWorktrees.find((entry) => entry.path === resolvedWorktreeRoot);
     if (!match) {
@@ -716,7 +731,7 @@ export async function resolvePaseoWorktreeRootForCwd(cwd, options) {
         worktreePath: match.path,
     };
 }
-export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, worktreesRoot, paseoHome, }) {
+export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, worktreesRoot, paseoHome, worktreesBaseRoot, }) {
     if (!worktreePath && !worktreeSlug) {
         throw new Error("worktreePath or worktreeSlug is required");
     }
@@ -728,7 +743,7 @@ export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, wor
         resolvedWorktreesRoot = worktreesRoot;
     }
     else if (cwd) {
-        resolvedWorktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
+        resolvedWorktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome, worktreesBaseRoot);
     }
     else {
         throw new Error("cwd or worktreesRoot is required to delete a Paseo worktree");
@@ -736,8 +751,10 @@ export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, wor
     const resolvedRoot = normalizePathForOwnership(resolvedWorktreesRoot) + sep;
     const requestedPath = worktreePath ?? join(resolvedWorktreesRoot, worktreeSlug);
     const resolvedRequested = normalizePathForOwnership(requestedPath);
-    const resolvedWorktree = (await resolvePaseoWorktreeRootForCwd(requestedPath, { paseoHome }))?.worktreePath ??
-        resolvedRequested;
+    const resolvedWorktree = (await resolvePaseoWorktreeRootForCwd(requestedPath, {
+        paseoHome,
+        worktreesRoot: worktreesBaseRoot,
+    }))?.worktreePath ?? resolvedRequested;
     if (!resolvedWorktree.startsWith(resolvedRoot)) {
         throw new Error("Refusing to delete non-Paseo worktree");
     }
@@ -812,9 +829,9 @@ async function removeDirectoryWithRetries(path) {
 /**
  * Create a git worktree with proper naming conventions
  */
-export const createWorktree = async ({ cwd, source, worktreeSlug, runSetup, paseoHome, }) => {
+export const createWorktree = async ({ cwd, source, worktreeSlug, runSetup, paseoHome, worktreesRoot, }) => {
     const sourcePlan = await resolveWorktreeSourcePlan({ cwd, source, desiredSlug: worktreeSlug });
-    let worktreePath = join(await getPaseoWorktreesRoot(cwd, paseoHome), worktreeSlug);
+    let worktreePath = join(await getPaseoWorktreesRoot(cwd, paseoHome, worktreesRoot), worktreeSlug);
     mkdirSync(dirname(worktreePath), { recursive: true });
     // Also handle worktree path collision
     let finalWorktreePath = worktreePath;

package/dist/src/server/persisted-config.js

@@ -49,6 +49,11 @@ const ProvidersSchema = z
     local: LocalSpeechProviderSchema.optional(),
 })
     .strict();
+const WorktreesConfigSchema = z
+    .object({
+    root: z.string().min(1).optional(),
+})
+    .strict();
 const BcryptHashSchema = z.string().regex(/^\$2[aby]\$\d{2}\$[./A-Za-z0-9]{53}$/, {
     message: "Expected a bcrypt hash",
 });
@@ -197,6 +202,17 @@ export const PersistedConfigSchema = z
         })
             .strict()
             .optional(),
+        serviceProxy: z
+            .object({
+            // COMPAT(serviceProxyEnabled): added 2026-06-02, remove after 2026-12-02.
+            // Parsed only to suppress optional public/listen layers for old configs;
+            // localhost service proxying remains always enabled.
+            enabled: z.boolean().optional(),
+            listen: z.string().optional(),
+            publicBaseUrl: z.string().url().optional(),
+        })
+            .strict()
+            .optional(),
         auth: DaemonAuthSchema.optional(),
     })
         .strict()
@@ -212,6 +228,7 @@ export const PersistedConfigSchema = z
         .strict()
         .optional(),
     providers: ProvidersSchema.optional(),
+    worktrees: WorktreesConfigSchema.optional(),
     agents: z
         .object({
         providers: z.preprocess(normalizeAgentProviders, ProviderOverridesSchema).optional(),