@getpaseo/server 0.1.87 → 0.1.89

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

@@ -29,12 +29,15 @@ export class TerminalSessionController {
         this.hasBinaryChannel = options.hasBinaryChannel;
         this.isPathWithinRoot = options.isPathWithinRoot;
         this.sessionLogger = options.sessionLogger;
+        this.clientSupportsWrapReflow = options.clientSupportsWrapReflow ?? (() => false);
     }
     start() {
         if (!this.terminalManager) {
             return;
         }
-        this.unsubscribeTerminalsChanged = this.terminalManager.subscribeTerminalsChanged((event) => this.handleTerminalsChanged(event));
+        this.unsubscribeTerminalsChanged = this.terminalManager.subscribeTerminalsChanged((event) => {
+            void this.handleTerminalsChanged(event);
+        });
     }
     getMetrics() {
         return {
@@ -173,23 +176,25 @@ export class TerminalSessionController {
             ...(title ? { title } : {}),
         };
     }
-    handleTerminalsChanged(event) {
-        if (!this.subscribedDirectories.has(event.cwd)) {
-            return;
+    async handleTerminalsChanged(event) {
+        // A terminal can live in a subdirectory of a subscribed workspace root (an
+        // agent can open one there). Deliver the change to every subscribed root at
+        // or above the terminal's cwd, keyed by that root, carrying the full
+        // aggregated list — so the client's cache replacement doesn't drop the
+        // terminals that live directly at the root.
+        const matchingRoots = Array.from(this.subscribedDirectories).filter((root) => this.isPathWithinRoot(root, event.cwd));
+        for (const root of matchingRoots) {
+            await this.emitTerminalsSnapshotForRoot(root);
         }
-        this.emitTerminalsChangedSnapshot({
-            cwd: event.cwd,
-            terminals: event.terminals.map((terminal) => Object.assign({ id: terminal.id, name: terminal.name }, terminal.title ? { title: terminal.title } : {})),
-        });
     }
     handleSubscribeTerminalsRequest(msg) {
         this.subscribedDirectories.add(msg.cwd);
-        void this.emitInitialTerminalsChangedSnapshot(msg.cwd);
+        void this.emitTerminalsSnapshotForRoot(msg.cwd);
     }
     handleUnsubscribeTerminalsRequest(msg) {
         this.subscribedDirectories.delete(msg.cwd);
     }
-    async emitInitialTerminalsChangedSnapshot(cwd) {
+    async emitTerminalsSnapshotForRoot(cwd) {
         if (!this.terminalManager || !this.subscribedDirectories.has(cwd)) {
             return;
         }
@@ -618,7 +623,9 @@ export class TerminalSessionController {
         }
     }
     async emitLegacySnapshot(activeStream, terminalManager) {
-        const snapshot = await terminalManager.getTerminalState(activeStream.terminalId);
+        const snapshot = await terminalManager.getTerminalState(activeStream.terminalId, {
+            includeWrapFlags: this.clientSupportsWrapReflow(),
+        });
         if (this.activeStreams.get(activeStream.slot) !== activeStream) {
             return { shouldContinue: false };
         }
@@ -637,7 +644,10 @@ export class TerminalSessionController {
         if (snapshotOptions === null) {
             return { shouldContinue: true };
         }
-        const snapshot = await terminalManager.getTerminalState(activeStream.terminalId, snapshotOptions);
+        const snapshot = await terminalManager.getTerminalState(activeStream.terminalId, {
+            ...snapshotOptions,
+            includeWrapFlags: this.clientSupportsWrapReflow(),
+        });
         if (this.activeStreams.get(activeStream.slot) !== activeStream) {
             return { shouldContinue: false };
         }

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

@@ -13,6 +13,7 @@ export interface TerminalStateSnapshot {
 }
 export interface TerminalStateSnapshotOptions {
     scrollbackLines?: number;
+    includeWrapFlags?: boolean;
 }
 export interface TerminalSubscribeOptions {
     initialSnapshot?: "state" | "ready";

package/dist/server/terminal/terminal.js

@@ -232,6 +232,32 @@ function extractScrollback(terminal, options) {
     }
     return scrollback;
 }
+// xterm marks a line `isWrapped` when it is a continuation of the PREVIOUS line.
+// The snapshot carries the inverse, tmux-style flag — "this row continues onto the
+// next row" — so the client can rejoin and reflow logical lines. So row y's flag is
+// whether line y+1 is a wrapped continuation.
+function lineContinuesToNext(terminal, absoluteRow) {
+    return terminal.buffer.active.getLine(absoluteRow + 1)?.isWrapped === true;
+}
+function extractGridWrapped(terminal) {
+    const baseY = terminal.buffer.active.baseY;
+    const wrapped = [];
+    for (let row = 0; row < terminal.rows; row++) {
+        wrapped.push(lineContinuesToNext(terminal, baseY + row));
+    }
+    return wrapped;
+}
+function extractScrollbackWrapped(terminal, options) {
+    const scrollbackLines = terminal.buffer.active.baseY;
+    const startRow = typeof options?.scrollbackLines === "number"
+        ? Math.max(0, scrollbackLines - options.scrollbackLines)
+        : 0;
+    const wrapped = [];
+    for (let row = startRow; row < scrollbackLines; row++) {
+        wrapped.push(lineContinuesToNext(terminal, row));
+    }
+    return wrapped;
+}
 function extractCursorState(terminal) {
     const coreService = terminal
         ._core?.coreService;
@@ -659,6 +685,14 @@ export async function createTerminal(options) {
             }),
             cursor: extractCursorState(terminal),
             ...(title ? { title } : {}),
+            ...(snapshotOptions?.includeWrapFlags
+                ? {
+                    gridWrapped: extractGridWrapped(terminal),
+                    scrollbackWrapped: extractScrollbackWrapped(terminal, {
+                        scrollbackLines: snapshotOptions?.scrollbackLines,
+                    }),
+                }
+                : {}),
         };
     }
     function getStateSnapshot(snapshotOptions) {

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",
@@ -375,7 +375,7 @@ function buildGitDiffArgs(args) {
     return ["diff", ...(args.ignoreWhitespace ? ["-w"] : []), ...args.extra];
 }
 const TRACKED_DIFF_NUMSTAT_MAX_BYTES = 2 * 1024 * 1024; // 2MB
-const TRACKED_MAX_CHANGED_LINES = 40000;
+const TRACKED_DIFF_PER_FILE_MAX_CHARS = 1024 * 1024;
 const EMPTY_TREE_OBJECT_ID = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 function isUnbornHeadDiffError(error) {
     return (error instanceof Error &&
@@ -423,11 +423,56 @@ async function getTrackedNumstatByPath(cwd, refs, ignoreWhitespace = false) {
     }
     return stats;
 }
-function isTrackedDiffTooLarge(stat) {
-    if (!stat || stat.isBinary) {
-        return false;
+function extractTrackedDiffMetadataPath(section, prefix) {
+    const line = section.split("\n").find((candidate) => candidate.startsWith(prefix));
+    if (!line) {
+        return null;
+    }
+    const path = line.slice(prefix.length).replace(/\t.*$/, "").trimEnd();
+    if (path === "/dev/null") {
+        return null;
     }
-    return stat.additions + stat.deletions > TRACKED_MAX_CHANGED_LINES;
+    return path.startsWith("a/") || path.startsWith("b/") ? path.slice(2) : path;
+}
+function extractTrackedDiffSectionPath(section) {
+    const firstLineEnd = section.indexOf("\n");
+    const firstLine = firstLineEnd === -1 ? section : section.slice(0, firstLineEnd);
+    const header = firstLine.startsWith("diff --git ") ? firstLine.slice("diff --git ".length) : "";
+    const prefixedPathMatch = header.match(/^a\/(.+) b\/(.+)$/);
+    if (prefixedPathMatch) {
+        return prefixedPathMatch[2] ?? null;
+    }
+    const metadataPath = extractTrackedDiffMetadataPath(section, "+++ ") ??
+        extractTrackedDiffMetadataPath(section, "--- ");
+    if (metadataPath) {
+        return metadataPath;
+    }
+    const pathMatch = header.match(/^(\S+)\s+(\S+)$/);
+    return pathMatch?.[2] ?? null;
+}
+function splitTrackedDiffSections(diffText) {
+    const starts = [];
+    const diffHeaderPattern = /^diff --git /gm;
+    let match;
+    while ((match = diffHeaderPattern.exec(diffText))) {
+        starts.push(match.index);
+    }
+    const sections = [];
+    for (let index = 0; index < starts.length; index += 1) {
+        const start = starts[index];
+        const end = starts[index + 1] ?? diffText.length;
+        const text = diffText.slice(start, end);
+        const path = extractTrackedDiffSectionPath(text);
+        if (!path) {
+            continue;
+        }
+        sections.push({
+            path,
+            text,
+            isTooLarge: text.length > TRACKED_DIFF_PER_FILE_MAX_CHARS,
+        });
+    }
+    return sections;
 }
 export class NotGitRepoError extends Error {
     constructor(cwd) {
@@ -525,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");
     }
@@ -538,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 `\`). */
@@ -624,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 };
     }
@@ -1031,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 &&
@@ -1500,6 +1555,62 @@ async function processUntrackedChange(input) {
         status: "ok",
     });
 }
+async function processTrackedChanges(input) {
+    const { cwd, refsForDiff, trackedChanges, ignoreWhitespace, appendDiff } = input;
+    const trackedChangeByPath = new Map(trackedChanges.map((change) => [change.path, change]));
+    const trackedNumstatByPath = trackedChanges.length > 0
+        ? await getTrackedNumstatByPath(cwd, refsForDiff, ignoreWhitespace)
+        : new Map();
+    const trackedDiffPaths = [];
+    const trackedPlaceholderByPath = new Map();
+    for (const change of trackedChanges) {
+        const stat = trackedNumstatByPath.get(change.path) ?? null;
+        if (stat?.isBinary) {
+            trackedPlaceholderByPath.set(change.path, { status: "binary", stat });
+            continue;
+        }
+        trackedDiffPaths.push(change.path);
+    }
+    let trackedDiffText = "";
+    let trackedDiffTruncated = false;
+    if (trackedDiffPaths.length > 0) {
+        const trackedDiffResult = await runGitCommand(buildGitDiffArgs({
+            ignoreWhitespace,
+            extra: [...getCheckoutDiffRefArgs(refsForDiff), "--", ...trackedDiffPaths],
+        }), {
+            cwd,
+            envOverlay: READ_ONLY_GIT_ENV,
+            maxOutputBytes: TOTAL_DIFF_MAX_BYTES,
+        });
+        trackedDiffTruncated = trackedDiffResult.truncated;
+        const visibleTrackedDiffs = [];
+        const sections = splitTrackedDiffSections(trackedDiffResult.stdout);
+        for (let index = 0; index < sections.length; index += 1) {
+            const section = sections[index];
+            const isTruncatedTail = trackedDiffTruncated && index === sections.length - 1;
+            if (section.isTooLarge || isTruncatedTail) {
+                trackedPlaceholderByPath.set(section.path, {
+                    status: "too_large",
+                    stat: trackedNumstatByPath.get(section.path) ?? null,
+                });
+                continue;
+            }
+            visibleTrackedDiffs.push(section.text);
+        }
+        trackedDiffText = visibleTrackedDiffs.join("");
+        appendDiff(trackedDiffText);
+        if (trackedDiffTruncated) {
+            appendDiff("# tracked diff truncated\n");
+        }
+    }
+    return {
+        trackedChangeByPath,
+        trackedNumstatByPath,
+        trackedPlaceholderByPath,
+        trackedDiffText,
+        trackedDiffTruncated,
+    };
+}
 async function resolveCheckoutDiffRefs(cwd, compare, context) {
     if (compare.mode === "uncommitted") {
         return { baseRef: "HEAD", includeUntracked: true };
@@ -1565,42 +1676,13 @@ export async function getCheckoutDiff(cwd, compare, context) {
     };
     const trackedChanges = changes.filter((change) => !change.isUntracked);
     const untrackedChanges = changes.filter((change) => change.isUntracked === true);
-    const trackedChangeByPath = new Map(trackedChanges.map((change) => [change.path, change]));
-    const trackedNumstatByPath = trackedChanges.length > 0
-        ? await getTrackedNumstatByPath(cwd, effectiveRefsForDiff, ignoreWhitespace)
-        : new Map();
-    const trackedDiffPaths = [];
-    const trackedPlaceholderByPath = new Map();
-    for (const change of trackedChanges) {
-        const stat = trackedNumstatByPath.get(change.path) ?? null;
-        if (stat?.isBinary) {
-            trackedPlaceholderByPath.set(change.path, { status: "binary", stat });
-            continue;
-        }
-        if (isTrackedDiffTooLarge(stat)) {
-            trackedPlaceholderByPath.set(change.path, { status: "too_large", stat });
-            continue;
-        }
-        trackedDiffPaths.push(change.path);
-    }
-    let trackedDiffText = "";
-    let trackedDiffTruncated = false;
-    if (trackedDiffPaths.length > 0) {
-        const trackedDiffResult = await runGitCommand(buildGitDiffArgs({
-            ignoreWhitespace,
-            extra: [...getCheckoutDiffRefArgs(effectiveRefsForDiff), "--", ...trackedDiffPaths],
-        }), {
-            cwd,
-            envOverlay: READ_ONLY_GIT_ENV,
-            maxOutputBytes: TOTAL_DIFF_MAX_BYTES,
-        });
-        trackedDiffText = trackedDiffResult.stdout;
-        trackedDiffTruncated = trackedDiffResult.truncated;
-        appendDiff(trackedDiffText);
-        if (trackedDiffTruncated) {
-            appendDiff("# tracked diff truncated\n");
-        }
-    }
+    const trackedDiff = await processTrackedChanges({
+        cwd,
+        refsForDiff: effectiveRefsForDiff,
+        trackedChanges,
+        ignoreWhitespace,
+        appendDiff,
+    });
     const appendTrackedPlaceholderComment = (change, status) => {
         if (status === "binary") {
             appendDiff(`# ${change.path}: binary diff omitted\n`);
@@ -1612,11 +1694,11 @@ export async function getCheckoutDiff(cwd, compare, context) {
         await appendStructuredTrackedDiffs({
             cwd,
             trackedChanges,
-            trackedChangeByPath,
-            trackedNumstatByPath,
-            trackedPlaceholderByPath,
-            trackedDiffText,
-            trackedDiffTruncated,
+            trackedChangeByPath: trackedDiff.trackedChangeByPath,
+            trackedNumstatByPath: trackedDiff.trackedNumstatByPath,
+            trackedPlaceholderByPath: trackedDiff.trackedPlaceholderByPath,
+            trackedDiffText: trackedDiff.trackedDiffText,
+            trackedDiffTruncated: trackedDiff.trackedDiffTruncated,
             refsForDiff: effectiveRefsForDiff,
             ignoreWhitespace,
             structured,
@@ -1626,7 +1708,7 @@ export async function getCheckoutDiff(cwd, compare, context) {
     }
     else {
         for (const change of trackedChanges) {
-            const placeholder = trackedPlaceholderByPath.get(change.path);
+            const placeholder = trackedDiff.trackedPlaceholderByPath.get(change.path);
             if (placeholder) {
                 appendTrackedPlaceholderComment(change, placeholder.status);
             }

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;