@getpaseo/server 0.1.88 → 0.1.90

package/dist/server/server/websocket-server.js

@@ -202,7 +202,7 @@ function requireWebSocketServices(params) {
  * WebSocket server that only accepts sockets + parses/forwards messages to the session layer.
  */
 export class VoiceAssistantWebSocketServer {
-    constructor(server, logger, serverId, agentManager, agentStorage, downloadTokenStore, paseoHome, daemonConfigStore, mcpBaseUrl, wsConfig, auth, speech, terminalManager, dictation, daemonVersion, onLifecycleIntent, projectRegistry, workspaceRegistry, chatService, loopService, scheduleService, checkoutDiffManager, scriptRouteStore, scriptRuntimeStore, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, workspaceGitService, github, pushNotificationSender, providerSnapshotManager, daemonRuntimeConfig) {
+    constructor(server, logger, serverId, agentManager, agentStorage, downloadTokenStore, paseoHome, daemonConfigStore, mcpBaseUrl, wsConfig, auth, speech, terminalManager, dictation, daemonVersion, onLifecycleIntent, projectRegistry, workspaceRegistry, chatService, loopService, scheduleService, checkoutDiffManager, serviceProxy, scriptRuntimeStore, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, workspaceGitService, github, pushNotificationSender, providerSnapshotManager, daemonRuntimeConfig, serviceProxyPublicBaseUrl) {
         this.pendingConnections = new Map();
         this.sessions = new Map();
         this.externalSessionsByKey = new Map();
@@ -238,6 +238,7 @@ export class VoiceAssistantWebSocketServer {
         this.workspaceGitService = workspaceGitService ?? createFallbackWorkspaceGitService();
         this.downloadTokenStore = downloadTokenStore;
         this.paseoHome = paseoHome;
+        this.worktreesRoot = daemonRuntimeConfig?.worktreesRoot;
         this.daemonConfigStore = daemonConfigStore;
         this.mcpBaseUrl = mcpBaseUrl;
         this.assignOptionalServices({
@@ -245,11 +246,12 @@ export class VoiceAssistantWebSocketServer {
             terminalManager,
             dictation,
             onLifecycleIntent,
-            scriptRouteStore,
+            serviceProxy,
             scriptRuntimeStore,
             onBranchChanged,
             getDaemonTcpPort,
             getDaemonTcpHost,
+            serviceProxyPublicBaseUrl,
             resolveScriptHealth,
         });
         if (!providerSnapshotManager) {
@@ -286,11 +288,12 @@ export class VoiceAssistantWebSocketServer {
         this.terminalManager = params.terminalManager ?? null;
         this.dictation = params.dictation ?? null;
         this.onLifecycleIntent = params.onLifecycleIntent ?? null;
-        this.scriptRouteStore = params.scriptRouteStore ?? null;
+        this.serviceProxy = params.serviceProxy ?? null;
         this.scriptRuntimeStore = params.scriptRuntimeStore ?? null;
         this.onBranchChanged = params.onBranchChanged ?? null;
         this.getDaemonTcpPort = params.getDaemonTcpPort ?? null;
         this.getDaemonTcpHost = params.getDaemonTcpHost ?? null;
+        this.serviceProxyPublicBaseUrl = params.serviceProxyPublicBaseUrl ?? null;
         this.resolveScriptHealth = params.resolveScriptHealth ?? null;
     }
     createWebSocketServer(server, wsConfig, auth) {
@@ -550,6 +553,7 @@ export class VoiceAssistantWebSocketServer {
             downloadTokenStore: this.downloadTokenStore,
             pushTokenStore: this.pushTokenStore,
             paseoHome: this.paseoHome,
+            worktreesRoot: this.worktreesRoot,
             agentManager: this.agentManager,
             agentStorage: this.agentStorage,
             projectRegistry: this.projectRegistry,
@@ -567,12 +571,13 @@ export class VoiceAssistantWebSocketServer {
             tts: () => this.speech?.resolveTts() ?? null,
             terminalManager: this.terminalManager,
             providerSnapshotManager: this.providerSnapshotManager,
-            scriptRouteStore: this.scriptRouteStore ?? undefined,
+            serviceProxy: this.serviceProxy ?? undefined,
             scriptRuntimeStore: this.scriptRuntimeStore ?? undefined,
             workspaceSetupSnapshots: this.workspaceSetupSnapshots,
             onBranchChanged: this.onBranchChanged ?? undefined,
             getDaemonTcpPort: this.getDaemonTcpPort ?? undefined,
             getDaemonTcpHost: this.getDaemonTcpHost ?? undefined,
+            serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
             resolveScriptHealth: this.resolveScriptHealth ?? undefined,
             voice: {
                 turnDetection: () => this.speech?.resolveTurnDetection() ?? null,

package/dist/server/server/workspace-bootstrap-dedupe.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pure dedupe decision for the bootstrap flush.
+ *
+ * During the bootstrap window the session buffers workspace updates that
+ * race with the initial `fetch_workspaces_response`. The flush step decides
+ * which buffered updates still carry new information and which are
+ * redundant with what the client just received in the snapshot.
+ *
+ * Returns `true` (emit) when ANY of:
+ *   - the status changed from the snapshot
+ *   - the statusEnteredAt changed from the snapshot (including the
+ *     null↔value transition that the unmask case produces)
+ *   - the update's activityAtMs is strictly newer than the snapshot's
+ *   - the snapshot has no activityAtMs and the update has one (new activity
+ *     where there was none)
+ *
+ * Returns `false` (drop) when the status pair is unchanged AND the update
+ * is not strictly newer than the snapshot in activity. The both-null
+ * activity case falls through to drop — there is genuinely no new info.
+ */
+export interface BootstrapUpdateSnapshot {
+    status: string;
+    statusEnteredAt: string | null;
+    activityAtMs: number | null;
+}
+export interface BootstrapUpdateCheckInput {
+    /** Snapshot captured from the fetch_workspaces_response. `null` means
+     * the workspace was not in the snapshot (first-time subscription). */
+    snapshot: BootstrapUpdateSnapshot | null;
+    /** Pending update buffered during the bootstrap window. */
+    update: BootstrapUpdateSnapshot;
+}
+export declare function shouldEmitPendingBootstrapUpdate(input: BootstrapUpdateCheckInput): boolean;
+//# sourceMappingURL=workspace-bootstrap-dedupe.d.ts.map

package/dist/server/server/workspace-bootstrap-dedupe.js

@@ -0,0 +1,23 @@
+export function shouldEmitPendingBootstrapUpdate(input) {
+    const { snapshot, update } = input;
+    if (!snapshot) {
+        return true;
+    }
+    if (snapshot.status !== update.status) {
+        return true;
+    }
+    const snapshotEnteredAt = snapshot.statusEnteredAt ?? null;
+    const updateEnteredAt = update.statusEnteredAt ?? null;
+    if (snapshotEnteredAt !== updateEnteredAt) {
+        return true;
+    }
+    // Status pair is unchanged. The only remaining signal is activity.
+    if (update.activityAtMs === null) {
+        return false;
+    }
+    if (snapshot.activityAtMs === null) {
+        return true;
+    }
+    return update.activityAtMs > snapshot.activityAtMs;
+}
+//# sourceMappingURL=workspace-bootstrap-dedupe.js.map

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

@@ -44,6 +44,12 @@ export declare function summarizeFetchWorkspacesEntries(entries: Iterable<FetchW
 export declare class WorkspaceDirectory {
     private readonly deps;
     private readonly archivingByWorkspaceId;
+    /**
+     * Per-workspace last-seen winning bucket + entered-at. Persists across
+     * `buildDescriptorMap` calls inside the daemon process; reset on cold start.
+     * Server-internal; never crosses the wire.
+     */
+    private readonly bucketHistoryByWorkspaceId;
     private readonly pager;
     constructor(deps: WorkspaceDirectoryDeps);
     markArchiving(workspaceIds: Iterable<string>, archivingAt: string): void;
@@ -52,6 +58,8 @@ export declare class WorkspaceDirectory {
         includeGitData: boolean;
         workspaceIds?: Iterable<string>;
     }): Promise<Map<string, WorkspaceDescriptorPayload>>;
+    private resolveStatusEnteredAt;
+    private findNewestAgentTimestampInBucket;
     resolveRegisteredWorkspaceIdForCwd(cwd: string, workspaces: PersistedWorkspaceRecord[]): string;
     listDescriptors(): Promise<WorkspaceDescriptorPayload[]>;
     matchesFilter(input: {

package/dist/server/server/workspace-directory.js

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { sep } from "node:path";
 import { deriveAgentStateBucket, getWorkspaceStateBucketPriority, } from "@getpaseo/protocol/agent-state-bucket";
+import { getParentAgentIdFromLabels, isDelegatedAgent } from "@getpaseo/protocol/agent-labels";
 import { SortablePager } from "./pagination/sortable-pager.js";
 import { normalizeWorkspaceId } from "./workspace-registry-model.js";
 const FETCH_WORKSPACES_SORT_KEYS = [
@@ -34,6 +35,12 @@ export class WorkspaceDirectory {
     constructor(deps) {
         this.deps = deps;
         this.archivingByWorkspaceId = new Map();
+        /**
+         * Per-workspace last-seen winning bucket + entered-at. Persists across
+         * `buildDescriptorMap` calls inside the daemon process; reset on cold start.
+         * Server-internal; never crosses the wire.
+         */
+        this.bucketHistoryByWorkspaceId = new Map();
         this.pager = new SortablePager({
             validKeys: FETCH_WORKSPACES_SORT_KEYS,
             defaultSort: [{ key: "activity_at", direction: "desc" }],
@@ -92,14 +99,31 @@ export class WorkspaceDirectory {
                 archivingAt: this.archivingByWorkspaceId.get(workspaceId) ?? null,
             });
         }
-        for (const agent of agents) {
-            if (agent.archivedAt) {
-                continue;
+        const activeAgents = agents.filter((agent) => !agent.archivedAt && this.deps.isProviderVisibleToClient(agent.provider));
+        const activeAgentsById = new Map(activeAgents.map((agent) => [agent.id, agent]));
+        for (const agent of activeAgents) {
+            let workspaceAgent = agent;
+            let bucket;
+            if (isDelegatedAgent(agent)) {
+                if (agent.status !== "running") {
+                    continue;
+                }
+                const parentAgent = resolveDelegationRootAgent(agent, activeAgentsById);
+                if (!parentAgent) {
+                    continue;
+                }
+                workspaceAgent = parentAgent;
+                bucket = "running";
             }
-            if (!this.deps.isProviderVisibleToClient(agent.provider)) {
-                continue;
+            else {
+                bucket = deriveAgentStateBucket({
+                    status: agent.status,
+                    pendingPermissionCount: agent.pendingPermissions?.length ?? 0,
+                    requiresAttention: agent.requiresAttention,
+                    attentionReason: agent.attentionReason ?? null,
+                });
             }
-            const workspaceId = workspaceIdsByDirectory.get(normalizeWorkspaceId(agent.cwd));
+            const workspaceId = workspaceIdsByDirectory.get(normalizeWorkspaceId(workspaceAgent.cwd));
             if (workspaceId === undefined) {
                 continue;
             }
@@ -107,17 +131,104 @@ export class WorkspaceDirectory {
             if (!existing) {
                 continue;
             }
-            const bucket = deriveAgentStateBucket({
+            if (getWorkspaceStateBucketPriority(bucket) < getWorkspaceStateBucketPriority(existing.status)) {
+                existing.status = bucket;
+            }
+        }
+        // Resolve the workspace-level `statusEnteredAt` (see aggregate semantics
+        // on `resolveStatusEnteredAt`).
+        const nowIso = new Date().toISOString();
+        for (const [workspaceId, descriptor] of descriptorsByWorkspaceId) {
+            const contributingAgents = agents.filter((agent) => !agent.archivedAt &&
+                this.deps.isProviderVisibleToClient(agent.provider) &&
+                workspaceIdsByDirectory.get(normalizeWorkspaceId(agent.cwd)) === workspaceId);
+            const result = this.resolveStatusEnteredAt({
+                workspaceId,
+                winningBucket: descriptor.status,
+                contributingAgents,
+                previous: this.bucketHistoryByWorkspaceId.get(workspaceId) ?? null,
+                nowIso,
+            });
+            descriptor.statusEnteredAt = result.statusEnteredAt;
+            if (result.recordUpdate) {
+                this.bucketHistoryByWorkspaceId.set(workspaceId, result.recordUpdate);
+            }
+            else if (result.recordDelete) {
+                this.bucketHistoryByWorkspaceId.delete(workspaceId);
+            }
+        }
+        return descriptorsByWorkspaceId;
+    }
+    // Aggregate the workspace-level `statusEnteredAt` from its contributing
+    // agents. Aggregate semantics:
+    //   - winning bucket = highest-priority across contributing agents;
+    //   - entry time = best-effort timestamp from agents in the winning bucket;
+    //   - priority unmasking: when the winning bucket transitions (e.g. a
+    //     higher-priority bucket cleared), the new entry time is "now";
+    //   - same-bucket emits reuse the previous entered-at;
+    //   - empty workspaces that never had contributing agents get
+    //     `statusEnteredAt: null`.
+    //   - when archived agents leave a previously active workspace empty, keep
+    //     the previous done timestamp or stamp the transition to done now.
+    resolveStatusEnteredAt(params) {
+        const { winningBucket, contributingAgents, previous, nowIso } = params;
+        if (contributingAgents.length === 0) {
+            if (!previous) {
+                return { statusEnteredAt: null };
+            }
+            const enteredAt = previous.bucket === "done" ? previous.enteredAt : nowIso;
+            return {
+                statusEnteredAt: enteredAt,
+                recordUpdate: { bucket: "done", enteredAt },
+            };
+        }
+        if (!previous) {
+            const newestInWinningBucket = this.findNewestAgentTimestampInBucket(contributingAgents, winningBucket);
+            const enteredAt = newestInWinningBucket ?? nowIso;
+            return {
+                statusEnteredAt: enteredAt,
+                recordUpdate: { bucket: winningBucket, enteredAt },
+            };
+        }
+        if (previous.bucket !== winningBucket) {
+            return {
+                statusEnteredAt: nowIso,
+                recordUpdate: { bucket: winningBucket, enteredAt: nowIso },
+            };
+        }
+        return {
+            statusEnteredAt: previous.enteredAt,
+            recordUpdate: previous,
+        };
+    }
+    // Best-effort newest timestamp across contributing agents whose derived
+    // bucket matches `winningBucket`. Uses available agent fields:
+    //   - `attentionTimestamp` when attention is set (covers attention/failed)
+    //   - `updatedAt` as a general fallback for any bucket
+    // Returns `null` if no matching agent has a parseable timestamp.
+    findNewestAgentTimestampInBucket(contributingAgents, winningBucket) {
+        const candidates = contributingAgents
+            .filter((agent) => {
+            const derived = deriveAgentStateBucket({
                 status: agent.status,
                 pendingPermissionCount: agent.pendingPermissions?.length ?? 0,
                 requiresAttention: agent.requiresAttention,
                 attentionReason: agent.attentionReason ?? null,
             });
-            if (getWorkspaceStateBucketPriority(bucket) < getWorkspaceStateBucketPriority(existing.status)) {
-                existing.status = bucket;
+            return derived === winningBucket;
+        })
+            .map((agent) => {
+            // Prefer attentionTimestamp when the agent has attention set — this is
+            // the most accurate "entered current status" signal.
+            if (agent.attentionTimestamp) {
+                return agent.attentionTimestamp;
             }
-        }
-        return descriptorsByWorkspaceId;
+            // Fall back to updatedAt as a general proxy for recent activity.
+            return agent.updatedAt;
+        })
+            .filter((value) => typeof value === "string" && value.length > 0)
+            .sort();
+        return candidates.at(-1) ?? null;
     }
     resolveRegisteredWorkspaceIdForCwd(cwd, workspaces) {
         const normalizedCwd = normalizeWorkspaceId(cwd);
@@ -211,4 +322,23 @@ export class WorkspaceDirectory {
         };
     }
 }
+function resolveDelegationRootAgent(agent, activeAgentsById) {
+    const seen = new Set([agent.id]);
+    let current = agent;
+    while (true) {
+        const parentAgentId = getParentAgentIdFromLabels(current.labels);
+        if (!parentAgentId) {
+            return current;
+        }
+        if (seen.has(parentAgentId)) {
+            return null;
+        }
+        const parent = activeAgentsById.get(parentAgentId);
+        if (!parent) {
+            return null;
+        }
+        seen.add(parentAgentId);
+        current = parent;
+    }
+}
 //# sourceMappingURL=workspace-directory.js.map

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

@@ -150,11 +150,13 @@ interface WorkspaceGitServiceDependencies {
 interface WorkspaceGitServiceOptions {
     logger: pino.Logger;
     paseoHome: string;
+    worktreesRoot?: string;
     deps?: Partial<WorkspaceGitServiceDependencies>;
 }
 export declare class WorkspaceGitServiceImpl implements WorkspaceGitService {
     private readonly logger;
     private readonly paseoHome;
+    private readonly worktreesRoot;
     private readonly deps;
     private readonly snapshotUpdatedListeners;
     private readonly workspaceTargets;
@@ -219,6 +221,7 @@ export declare class WorkspaceGitServiceImpl implements WorkspaceGitService {
     private scheduleWorkspaceRefresh;
     private startWorkspaceSubscriptionTimers;
     private updateGitHubPollForTarget;
+    private resolveGitHubPollTarget;
     private stopGitHubPollForTarget;
     private addWorkingTreeWatcher;
     private ensureLinuxRepoTreeWatchers;

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-registry.js

@@ -1,7 +1,6 @@
-import { randomUUID } from "node:crypto";
 import { promises as fs } from "node:fs";
-import path from "node:path";
 import { z } from "zod";
+import { writeJsonFileAtomic } from "./atomic-file.js";
 const PersistedProjectRecordSchema = z.object({
     projectId: z.string(),
     rootPath: z.string(),
@@ -110,10 +109,7 @@ class FileBackedRegistry {
     }
     async persist() {
         const records = Array.from(this.cache.values());
-        await fs.mkdir(path.dirname(this.filePath), { recursive: true });
-        const tempPath = `${this.filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
-        await fs.writeFile(tempPath, JSON.stringify(records, null, 2), "utf8");
-        await fs.rename(tempPath, this.filePath);
+        await writeJsonFileAtomic(this.filePath, records);
     }
     async enqueuePersist() {
         const nextPersist = this.persistQueue.then(() => this.persist());

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;