@getpaseo/server 0.1.87 → 0.1.89

package/dist/server/server/workspace-git-service.js

@@ -71,6 +71,7 @@ export class WorkspaceGitServiceImpl {
         this.checkoutDiffCache = new LRUCache({ max: WORKSPACE_GIT_CHECKOUT_DIFF_CACHE_MAX });
         this.logger = options.logger.child({ module: "workspace-git-service" });
         this.paseoHome = options.paseoHome;
+        this.worktreesRoot = options.worktreesRoot;
         this.deps = resolveWorkspaceGitServiceDeps(options.deps);
     }
     registerWorkspace(params, listener) {
@@ -112,6 +113,7 @@ export class WorkspaceGitServiceImpl {
         try {
             const status = await this.deps.getCheckoutStatus(normalizedCwd, {
                 paseoHome: this.paseoHome,
+                worktreesRoot: this.worktreesRoot,
                 logger: this.logger,
             });
             if (!status.isGit) {
@@ -152,7 +154,10 @@ export class WorkspaceGitServiceImpl {
         const normalizedCwd = normalizeWorkspaceId(cwd);
         const normalizedOptions = this.normalizeCheckoutDiffOptions(options);
         const key = this.buildCheckoutDiffCacheKey(normalizedCwd, normalizedOptions);
-        return this.readAuxiliaryCache(this.checkoutDiffCache, key, readOptions, () => this.deps.getCheckoutDiff(normalizedCwd, normalizedOptions, { paseoHome: this.paseoHome }));
+        return this.readAuxiliaryCache(this.checkoutDiffCache, key, readOptions, () => this.deps.getCheckoutDiff(normalizedCwd, normalizedOptions, {
+            paseoHome: this.paseoHome,
+            worktreesRoot: this.worktreesRoot,
+        }));
     }
     normalizeCheckoutDiffOptions(options) {
         return {
@@ -221,6 +226,7 @@ export class WorkspaceGitServiceImpl {
         return this.readAuxiliaryCache(this.worktreeListCache, key, options, () => this.deps.listPaseoWorktrees({
             cwd: repoRoot,
             paseoHome: this.paseoHome,
+            worktreesRoot: this.worktreesRoot,
         }));
     }
     async resolveRepoRoot(cwd, options) {
@@ -380,7 +386,7 @@ export class WorkspaceGitServiceImpl {
             debounceTimer: null,
             selfHealTimer: null,
             githubPollSubscription: null,
-            githubPollHeadRef: null,
+            githubPollKey: null,
             refreshState: { status: "idle" },
             latestGit: null,
             latestGitLoadedAtMs: null,
@@ -676,21 +682,26 @@ export class WorkspaceGitServiceImpl {
             this.stopGitHubPollForTarget(target);
             return;
         }
-        const headRef = git.currentBranch;
-        const hasGitHubRemote = target.cachedGitHubRemote?.remoteUrl === git.remoteUrl &&
+        const pollTarget = this.resolveGitHubPollTarget(target);
+        const remoteUrl = git.remoteUrl;
+        const hasGitHubRemote = target.cachedGitHubRemote?.remoteUrl === remoteUrl &&
             target.cachedGitHubRemote.identity !== null;
-        if (!headRef || !hasGitHubRemote) {
+        if (!pollTarget || remoteUrl === null || !hasGitHubRemote) {
             this.stopGitHubPollForTarget(target);
             return;
         }
-        if (target.githubPollHeadRef === headRef && target.githubPollSubscription) {
+        const pollKey = buildWorkspaceGitHubPollKey(remoteUrl, pollTarget);
+        if (target.githubPollKey === pollKey && target.githubPollSubscription) {
             return;
         }
         this.stopGitHubPollForTarget(target);
-        target.githubPollHeadRef = headRef;
+        target.githubPollKey = pollKey;
         target.githubPollSubscription = this.deps.github.retainCurrentPullRequestStatusPoll({
             cwd: target.cwd,
-            headRef,
+            headRef: pollTarget.headRef,
+            ...(pollTarget.headRepositoryOwner
+                ? { headRepositoryOwner: pollTarget.headRepositoryOwner }
+                : {}),
             onStatus: (status) => {
                 if (!this.isActiveObservedWorkspaceTarget(target)) {
                     return;
@@ -700,14 +711,33 @@ export class WorkspaceGitServiceImpl {
                 });
             },
             onError: (error) => {
-                this.logger.warn({ err: error, cwd: target.cwd, headRef, reason: "self-heal-github" }, "Failed to run GitHub self-heal refresh");
+                this.logger.warn({
+                    err: error,
+                    cwd: target.cwd,
+                    headRef: pollTarget.headRef,
+                    headRepositoryOwner: pollTarget.headRepositoryOwner,
+                    reason: "self-heal-github",
+                }, "Failed to run GitHub self-heal refresh");
             },
         });
     }
+    resolveGitHubPollTarget(target) {
+        const git = target.latestGit;
+        if (!git?.currentBranch) {
+            return null;
+        }
+        const lookupTarget = target.latestFacts?.isGit && target.latestFacts.currentBranch === git.currentBranch
+            ? target.latestFacts.pullRequestLookupTarget
+            : null;
+        if (lookupTarget) {
+            return lookupTarget;
+        }
+        return { headRef: git.currentBranch };
+    }
     stopGitHubPollForTarget(target) {
         target.githubPollSubscription?.unsubscribe();
         target.githubPollSubscription = null;
-        target.githubPollHeadRef = null;
+        target.githubPollKey = null;
     }
     addWorkingTreeWatcher(target, watchPath, shouldTryRecursive) {
         if (target.watchedPaths.has(watchPath)) {
@@ -998,7 +1028,11 @@ export class WorkspaceGitServiceImpl {
         target.lastShellOutAtMs = now.getTime();
         const cwd = target.cwd;
         const previousGitHubPollKey = this.getGitHubPollKey(target);
-        const baseContext = { paseoHome: this.paseoHome, logger: this.logger };
+        const baseContext = {
+            paseoHome: this.paseoHome,
+            worktreesRoot: this.worktreesRoot,
+            logger: this.logger,
+        };
         const facts = await this.loadCheckoutFacts(target, {
             ...baseContext,
             allowRecent: !request.force,
@@ -1075,7 +1109,11 @@ export class WorkspaceGitServiceImpl {
         if (!githubRemote || githubRemote.remoteUrl !== git.remoteUrl || !githubRemote.identity) {
             return null;
         }
-        return JSON.stringify([git.remoteUrl, git.currentBranch]);
+        const pollTarget = this.resolveGitHubPollTarget(target);
+        if (!pollTarget) {
+            return null;
+        }
+        return buildWorkspaceGitHubPollKey(git.remoteUrl, pollTarget);
     }
     rememberGitHubSnapshot(target, github, options) {
         if (target.closed || this.workspaceTargets.get(target.cwd) !== target) {
@@ -1317,6 +1355,9 @@ function buildGitHubSnapshotFromStatus(status) {
         error: null,
     };
 }
+function buildWorkspaceGitHubPollKey(remoteUrl, target) {
+    return JSON.stringify([remoteUrl, target.headRef, target.headRepositoryOwner ?? null]);
+}
 async function runGitFetch(cwd) {
     await runGitCommand(["fetch", "origin", "--prune"], {
         cwd,

package/dist/server/server/workspace-registry.d.ts

@@ -39,6 +39,7 @@ declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
     updatedAt: z.ZodString;
     archivedAt: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    workspaceId: string;
     cwd: string;
     createdAt: string;
     updatedAt: string;
@@ -46,8 +47,8 @@ declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
     kind: "worktree" | "local_checkout" | "directory";
     projectId: string;
     displayName: string;
-    workspaceId: string;
 }, {
+    workspaceId: string;
     cwd: string;
     createdAt: string;
     updatedAt: string;
@@ -55,7 +56,6 @@ declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
     kind: "worktree" | "local_checkout" | "directory";
     projectId: string;
     displayName: string;
-    workspaceId: string;
 }>;
 export type PersistedProjectRecord = z.infer<typeof PersistedProjectRecordSchema>;
 export type PersistedWorkspaceRecord = z.infer<typeof PersistedWorkspaceRecordSchema>;

package/dist/server/server/workspace-service-env.d.ts

@@ -8,6 +8,7 @@ export interface BuildWorkspaceServiceEnvOptions {
     branchName: string | null;
     daemonPort: number | null | undefined;
     daemonListenHost: string | null | undefined;
+    serviceProxyPublicBaseUrl?: string | null;
     peers: readonly WorkspaceServicePeer[];
 }
 export declare function normalizeServiceEnvName(scriptName: string): string;

package/dist/server/server/workspace-service-env.js

@@ -1,4 +1,4 @@
-import { buildScriptHostname } from "../utils/script-hostname.js";
+import { projectServiceProxyUrls } from "./service-proxy.js";
 export function normalizeServiceEnvName(scriptName) {
     return scriptName
         .toUpperCase()
@@ -16,24 +16,28 @@ export function buildWorkspaceServiceEnv(options) {
         HOST: resolveServiceBindHost(options.daemonListenHost),
         PASEO_PORT: String(selfPeer.port),
     };
-    if (options.daemonPort !== null && options.daemonPort !== undefined) {
-        env.PASEO_URL = buildServiceProxyUrl({
-            projectSlug: options.projectSlug,
-            branchName: options.branchName,
-            scriptName: options.scriptName,
-            daemonPort: options.daemonPort,
-        });
+    const selfProxyUrl = buildServiceProxyUrl({
+        projectSlug: options.projectSlug,
+        branchName: options.branchName,
+        scriptName: options.scriptName,
+        daemonPort: options.daemonPort,
+        serviceProxyPublicBaseUrl: options.serviceProxyPublicBaseUrl,
+    });
+    if (selfProxyUrl) {
+        env.PASEO_URL = selfProxyUrl;
     }
     for (const peer of options.peers) {
         const envName = normalizeServiceEnvName(peer.scriptName);
         env[`PASEO_SERVICE_${envName}_PORT`] = String(peer.port);
-        if (options.daemonPort !== null && options.daemonPort !== undefined) {
-            env[`PASEO_SERVICE_${envName}_URL`] = buildServiceProxyUrl({
-                projectSlug: options.projectSlug,
-                branchName: options.branchName,
-                scriptName: peer.scriptName,
-                daemonPort: options.daemonPort,
-            });
+        const peerProxyUrl = buildServiceProxyUrl({
+            projectSlug: options.projectSlug,
+            branchName: options.branchName,
+            scriptName: peer.scriptName,
+            daemonPort: options.daemonPort,
+            serviceProxyPublicBaseUrl: options.serviceProxyPublicBaseUrl,
+        });
+        if (peerProxyUrl) {
+            env[`PASEO_SERVICE_${envName}_URL`] = peerProxyUrl;
         }
     }
     return env;
@@ -42,12 +46,13 @@ export function resolveServiceBindHost(daemonListenHost) {
     return isLoopbackListenHost(daemonListenHost) ? "127.0.0.1" : "0.0.0.0";
 }
 function buildServiceProxyUrl(options) {
-    const hostname = buildScriptHostname({
+    return projectServiceProxyUrls({
         projectSlug: options.projectSlug,
         branchName: options.branchName,
         scriptName: options.scriptName,
-    });
-    return `http://${hostname}:${options.daemonPort}`;
+        daemonPort: options.daemonPort,
+        publicBaseUrl: options.serviceProxyPublicBaseUrl,
+    }).proxyUrl;
 }
 function isLoopbackListenHost(host) {
     if (!host) {

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

@@ -13,10 +13,12 @@ export declare function listPaseoWorktreesCommand(dependencies: ListPaseoWorktre
 type CreatePaseoWorktreeWorkflow<Result extends CreatePaseoWorktreeResult> = (input: CreatePaseoWorktreeInput) => Promise<Result>;
 export interface CreatePaseoWorktreeCommandDependencies<Result extends CreatePaseoWorktreeResult = CreatePaseoWorktreeResult> {
     paseoHome?: string;
+    worktreesRoot?: string;
     createPaseoWorktreeWorkflow?: CreatePaseoWorktreeWorkflow<Result>;
 }
 export type CreatePaseoWorktreeCommandInput = Omit<CreatePaseoWorktreeInput, "paseoHome" | "runSetup"> & {
     paseoHome?: string;
+    worktreesRoot?: string;
 };
 export type CreatePaseoWorktreeCommandResult<Result extends CreatePaseoWorktreeResult> = {
     ok: true;

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/terminal/terminal-manager.js

@@ -1,6 +1,7 @@
 import { createTerminal, } from "./terminal.js";
 import { captureTerminalLines } from "./terminal-capture.js";
 import { resolve, sep, win32, posix } from "node:path";
+import { isSameOrDescendantPath } from "../server/path-utils.js";
 export function createTerminalManager() {
     const terminalsByCwd = new Map();
     const terminalsById = new Map();
@@ -99,7 +100,16 @@ export function createTerminalManager() {
     return {
         async getTerminals(cwd) {
             assertAbsolutePath(cwd);
-            return terminalsByCwd.get(cwd) ?? [];
+            // Terminals are bucketed by exact cwd, but an agent can open a terminal in
+            // a subdirectory of the workspace. A query for the workspace root must
+            // surface those too, so aggregate every bucket at or below `cwd`.
+            const sessions = [];
+            for (const [bucketCwd, bucketSessions] of terminalsByCwd) {
+                if (isSameOrDescendantPath(cwd, bucketCwd)) {
+                    sessions.push(...bucketSessions);
+                }
+            }
+            return sessions;
         },
         async createTerminal(options) {
             assertAbsolutePath(options.cwd);

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

@@ -9,6 +9,7 @@ export interface TerminalSessionControllerOptions {
     hasBinaryChannel: () => boolean;
     isPathWithinRoot: (rootPath: string, candidatePath: string) => boolean;
     sessionLogger: pino.Logger;
+    clientSupportsWrapReflow?: () => boolean;
 }
 export interface TerminalSessionControllerMetrics {
     directorySubscriptionCount: number;
@@ -21,6 +22,7 @@ export declare class TerminalSessionController {
     private readonly hasBinaryChannel;
     private readonly isPathWithinRoot;
     private readonly sessionLogger;
+    private readonly clientSupportsWrapReflow;
     private readonly subscribedDirectories;
     private unsubscribeTerminalsChanged;
     private readonly exitSubscriptions;
@@ -45,7 +47,7 @@ export declare class TerminalSessionController {
     private handleTerminalsChanged;
     private handleSubscribeTerminalsRequest;
     private handleUnsubscribeTerminalsRequest;
-    private emitInitialTerminalsChangedSnapshot;
+    private emitTerminalsSnapshotForRoot;
     private handleListTerminalsRequest;
     private getAllTerminalSessions;
     private handleCreateTerminalRequest;