@hansjm10/volt-coding-agent 0.0.0-bootstrap.0 → 0.1.0

package/dist/daemon/worktree-manager.js

@@ -0,0 +1,1204 @@
+import { createHash, randomInt } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, readdir, realpath, rename } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { IROH_REMOTE_WORKTREE_ID_PATTERN } from "../core/remote/iroh/protocol.js";
+import { isIrohRemoteWorktreeParentWorkspaceNotFoundError, isIrohRemoteWorktreePersistenceError, } from "../core/remote/iroh/state-manager.js";
+import { spawnProcess, waitForChildProcess } from "../utils/child-process.js";
+import { resolveWorkspaceDirectory } from "./workspace-directory.js";
+/** join(agentDir, "worktrees") — sibling of sessions/, daemon/, trust.json. */
+export function getWorktreesRoot(agentDir) {
+    return join(resolve(agentDir), "worktrees");
+}
+export const WORKTREE_ID_PATTERN = IROH_REMOTE_WORKTREE_ID_PATTERN;
+/**
+ * Encode a workspace path into the per-workspace worktrees directory segment,
+ * reusing the `--<encoded-cwd>--` scheme from the session dirs so the layout
+ * survives workspace renames. Long encodings are shortened with a hash suffix
+ * to stay clear of Windows MAX_PATH limits.
+ */
+function getWorkspaceWorktreesSegment(workspacePath) {
+    const encoded = resolve(workspacePath)
+        .replace(/^[/\\]/, "")
+        .replace(/[/\\:]/g, "-");
+    if (encoded.length <= 80) {
+        return `--${encoded}--`;
+    }
+    const digest = createHash("sha1").update(encoded).digest("hex").slice(0, 8);
+    return `--${encoded.slice(0, 72)}-${digest}--`;
+}
+/** Per-workspace directory holding that workspace's worktree checkouts. */
+export function getWorkspaceWorktreesDir(agentDir, workspacePath) {
+    return join(getWorktreesRoot(agentDir), getWorkspaceWorktreesSegment(workspacePath));
+}
+/**
+ * Deterministic checkout path; the ONLY producer of checkout paths. Validates
+ * the id and asserts the resolved path stays under the worktrees root — never
+ * accepts a caller-supplied path.
+ */
+export function getWorktreeCheckoutPath(agentDir, workspacePath, worktreeId) {
+    if (!WORKTREE_ID_PATTERN.test(worktreeId)) {
+        throw new Error(`invalid worktree id: ${worktreeId}`);
+    }
+    const root = resolve(getWorktreesRoot(agentDir));
+    const checkoutPath = resolve(join(getWorkspaceWorktreesDir(agentDir, workspacePath), worktreeId));
+    const rootPrefix = `${root}${sep}`;
+    const contained = process.platform === "win32"
+        ? checkoutPath.toLowerCase().startsWith(rootPrefix.toLowerCase())
+        : checkoutPath.startsWith(rootPrefix);
+    if (!contained) {
+        throw new Error("worktree checkout path escapes the worktrees root");
+    }
+    return checkoutPath;
+}
+/**
+ * Convert a path relative to a daemon-managed worktree checkout back into the
+ * registered-workspace-relative path used on the remote protocol. Nested repo
+ * worktrees store sourceRootRelativePath (e.g. `Volt`), so a worktree cwd of
+ * `packages/coding-agent` displays as `Volt/packages/coding-agent`.
+ */
+export function getRegisteredWorkingDirectoryForWorktree(worktree, worktreeRelativePath) {
+    if (worktree.sourceRootRelativePath === undefined) {
+        return worktreeRelativePath;
+    }
+    return worktreeRelativePath === undefined
+        ? worktree.sourceRootRelativePath
+        : posix.join(worktree.sourceRootRelativePath, worktreeRelativePath);
+}
+/** win32-aware "path is inside root" prefix check on resolved paths. */
+function isPathContained(root, path) {
+    const resolvedRoot = resolve(root);
+    const resolvedPath = resolve(path);
+    const rootPrefix = `${resolvedRoot}${sep}`;
+    if (process.platform === "win32") {
+        const lowerPath = resolvedPath.toLowerCase();
+        return lowerPath === resolvedRoot.toLowerCase() || lowerPath.startsWith(rootPrefix.toLowerCase());
+    }
+    return resolvedPath === resolvedRoot || resolvedPath.startsWith(rootPrefix);
+}
+/** True when path is inside the daemon's worktrees root (a daemon-managed checkout or below). */
+export function isPathUnderWorktreesRoot(agentDir, path) {
+    const root = resolve(getWorktreesRoot(agentDir));
+    const resolved = resolve(path);
+    return resolved !== root && isPathContained(root, resolved);
+}
+/**
+ * Resolve the PARENT checkout of a daemon-managed worktree from the checkout's
+ * `.git` gitdir pointer (`gitdir: <parent>/.git/worktrees/<id>`), without a
+ * daemon round-trip or a git subprocess. Returns undefined when the path is
+ * not under the worktrees root or the pointer cannot be parsed. Used by the
+ * TUI to pin trust decisions to the parent workspace path — trust entries are
+ * never prompted for or persisted on worktree paths (design §5.1.9/§5.2.1).
+ */
+export function resolveWorktreeParentCheckout(agentDir, path) {
+    if (!isPathUnderWorktreesRoot(agentDir, path)) {
+        return undefined;
+    }
+    const root = resolve(getWorktreesRoot(agentDir));
+    const relativeSegments = resolve(path)
+        .slice(root.length + 1)
+        .split(sep)
+        .filter((segment) => segment.length > 0);
+    if (relativeSegments.length < 2) {
+        return undefined;
+    }
+    // Layout: <root>/<encoded-workspace-segment>/<worktreeId>/...
+    const checkoutPath = join(root, relativeSegments[0] ?? "", relativeSegments[1] ?? "");
+    let gitFileContents;
+    try {
+        gitFileContents = readFileSync(join(checkoutPath, ".git"), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const match = gitFileContents.match(/^gitdir:\s*(.+)\s*$/m);
+    if (!match?.[1]) {
+        return undefined;
+    }
+    const gitDir = match[1].trim();
+    if (!isAbsolute(gitDir)) {
+        return undefined;
+    }
+    // gitDir is <parent>/.git/worktrees/<name>; the parent checkout is three levels up.
+    const worktreesDir = dirname(resolve(gitDir));
+    const dotGitDir = dirname(worktreesDir);
+    if (worktreesDir.split(sep).pop() !== "worktrees" || dotGitDir.split(sep).pop() !== ".git") {
+        return undefined;
+    }
+    return dirname(dotGitDir);
+}
+/**
+ * Gate a worktree-bound conversation relay: the checkout must exist and the
+ * owning TUI must have advertised the worktrees control capability. Old TUIs
+ * (no capability) are never offered worktree-session relays (design §5.2.3).
+ */
+export function evaluateWorktreeRelayGate(worktree, tuiCapabilities, worktreesCapability) {
+    if (worktree === undefined) {
+        return { ok: true };
+    }
+    if (!existsSync(worktree.path)) {
+        return { ok: false, reason: "checkout_missing" };
+    }
+    if (tuiCapabilities === undefined || !tuiCapabilities.has(worktreesCapability)) {
+        return { ok: false, reason: "tui_not_capable" };
+    }
+    return { ok: true };
+}
+const DEFAULT_MAX_WORKTREES_PER_WORKSPACE = 16;
+const SLUG_ADJECTIVES = ["amber", "brisk", "calm", "dusky", "eager", "fresh", "keen", "lucid", "quiet", "swift"];
+const SLUG_NOUNS = ["basin", "cedar", "delta", "ember", "grove", "harbor", "mesa", "ridge", "summit", "vale"];
+function generateWorktreeIdSlug() {
+    const adjective = SLUG_ADJECTIVES[randomInt(SLUG_ADJECTIVES.length)];
+    const noun = SLUG_NOUNS[randomInt(SLUG_NOUNS.length)];
+    return `${adjective}-${noun}-${String(randomInt(100)).padStart(2, "0")}`;
+}
+/** Default runner: no shell, argv only, captured stdio. */
+export function createDefaultWorktreeGitRunner() {
+    return async (args, cwd) => {
+        try {
+            const child = spawnProcess("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+            let stdout = "";
+            let stderr = "";
+            child.stdout?.setEncoding("utf8");
+            child.stderr?.setEncoding("utf8");
+            child.stdout?.on("data", (chunk) => {
+                stdout += chunk;
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderr += chunk;
+            });
+            const code = await waitForChildProcess(child);
+            return { ok: code === 0, code, stdout, stderr };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const detail = message.includes("ENOENT") ? "git not found on daemon PATH; see docs/daemon.md" : message;
+            return { ok: false, code: null, stdout: "", stderr: detail };
+        }
+    };
+}
+/**
+ * Basic `git check-ref-format`-equivalent syntax gate for branch/baseRef
+ * values. Rejects option injection (leading '-') and git-invalid ref
+ * sequences; values are always passed as separate argv entries.
+ */
+export function isValidGitRefSyntax(ref) {
+    if (ref.length === 0 || ref.length > 255 || ref.startsWith("-")) {
+        return false;
+    }
+    if (/[\s~^:?*[\\\x00-\x1f\x7f]/.test(ref)) {
+        return false;
+    }
+    if (ref.includes("..") || ref.includes("@{") || ref.includes("//")) {
+        return false;
+    }
+    if (ref.startsWith("/") || ref.endsWith("/") || ref.endsWith(".") || ref.endsWith(".lock")) {
+        return false;
+    }
+    return true;
+}
+export class WorktreeManager {
+    agentDir;
+    stateManager;
+    auditLogger;
+    runGit;
+    maxWorktreesPerWorkspace;
+    hasActiveRuntimeForSession;
+    flushState;
+    now;
+    constructor(options) {
+        this.agentDir = options.agentDir;
+        this.stateManager = options.stateManager;
+        this.auditLogger = options.auditLogger;
+        this.runGit = options.runGit ?? createDefaultWorktreeGitRunner();
+        this.maxWorktreesPerWorkspace = options.maxWorktreesPerWorkspace ?? DEFAULT_MAX_WORKTREES_PER_WORKSPACE;
+        this.hasActiveRuntimeForSession = options.hasActiveRuntimeForSession;
+        this.flushState = options.flushState;
+        this.now = options.now ?? Date.now;
+    }
+    /** git worktree add; persists the record durably after git succeeds. */
+    async create(workspace, options = {}) {
+        const id = options.id ?? generateWorktreeIdSlug();
+        if (!WORKTREE_ID_PATTERN.test(id)) {
+            return { ok: false, error: "invalid_worktree_id" };
+        }
+        const branch = options.branch ?? `volt/${id}`;
+        const baseRef = options.baseRef ?? "HEAD";
+        if (!isValidGitRefSyntax(branch)) {
+            return { ok: false, error: "git_failed", detail: "invalid branch ref syntax" };
+        }
+        if (!isValidGitRefSyntax(baseRef)) {
+            return { ok: false, error: "git_failed", detail: "invalid baseRef ref syntax" };
+        }
+        try {
+            const result = await this.stateManager.runWorkspaceWorktreeLifecycle(workspace.name, async ({ workspace: registeredWorkspace, worktrees: existing }) => {
+                if (existing.length >= this.maxWorktreesPerWorkspace) {
+                    return { result: { ok: false, error: "worktree_limit_reached" } };
+                }
+                const checkoutPath = getWorktreeCheckoutPath(this.agentDir, registeredWorkspace.path, id);
+                if (existing.some((entry) => entry.id === id) || existsSync(checkoutPath)) {
+                    return { result: { ok: false, error: "worktree_exists" } };
+                }
+                const source = await this.resolveCreateSource(registeredWorkspace, options.workingDirectory);
+                if (!source.ok) {
+                    return { result: source };
+                }
+                const repoCheck = await this.runGit(["rev-parse", "--git-common-dir"], source.source.sourceRootPath);
+                if (!repoCheck.ok) {
+                    return {
+                        result: this.mapGitFailure(repoCheck.stderr, registeredWorkspace, checkoutPath, [
+                            source.source.sourceRootPath,
+                        ]),
+                    };
+                }
+                // Resolve a defaulted base to a concrete ref (the source checkout's branch,
+                // falling back to its commit sha) so merge-back guidance — aheadBehind,
+                // retention merge checks, `worktree diff` — has a stable base later.
+                const recordedBaseRef = options.baseRef ?? (await this.resolveDefaultBaseRef(source.source.sourceRootPath));
+                await mkdir(getWorkspaceWorktreesDir(this.agentDir, registeredWorkspace.path), {
+                    recursive: true,
+                    mode: 0o700,
+                });
+                const added = await this.runGit(["worktree", "add", checkoutPath, "-b", branch, baseRef], source.source.sourceRootPath);
+                if (!added.ok) {
+                    return {
+                        result: this.mapGitFailure(added.stderr, registeredWorkspace, checkoutPath, [
+                            source.source.sourceRootPath,
+                        ]),
+                    };
+                }
+                const worktree = {
+                    id,
+                    workspaceName: registeredWorkspace.name,
+                    path: checkoutPath,
+                    ...(source.source.sourceRootRelativePath === undefined
+                        ? {}
+                        : { sourceRootRelativePath: source.source.sourceRootRelativePath }),
+                    branch,
+                    ...(recordedBaseRef === undefined ? {} : { baseRef: recordedBaseRef }),
+                    createdAt: this.now(),
+                    sessionIds: [],
+                };
+                return { result: { ok: true, worktree }, worktree };
+            });
+            if (result.ok) {
+                try {
+                    await this.flushState?.();
+                }
+                catch {
+                    return {
+                        ok: false,
+                        error: "git_failed",
+                        detail: "worktree state could not be flushed; the checkout and daemon record were preserved",
+                    };
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            if (isIrohRemoteWorktreeParentWorkspaceNotFoundError(error)) {
+                return { ok: false, error: "worktree_source_unregistered" };
+            }
+            if (isIrohRemoteWorktreePersistenceError(error)) {
+                return {
+                    ok: false,
+                    error: "git_failed",
+                    detail: "worktree state could not be persisted; the created checkout was preserved for recovery",
+                };
+            }
+            throw error;
+        }
+    }
+    /** Adopt an existing git worktree checkout into daemon state; local control socket only. */
+    async adopt(workspace, options) {
+        const requestedPath = resolve(options.path);
+        if (options.id !== undefined && !WORKTREE_ID_PATTERN.test(options.id)) {
+            return { ok: false, error: "invalid_worktree_id" };
+        }
+        if (options.baseRef !== undefined && !isValidGitRefSyntax(options.baseRef)) {
+            return { ok: false, error: "git_failed", detail: "invalid baseRef ref syntax" };
+        }
+        if (!existsSync(requestedPath)) {
+            return { ok: false, error: "worktree_not_found", detail: "checkout path does not exist" };
+        }
+        try {
+            const result = await this.stateManager.runWorkspaceWorktreeLifecycle(workspace.name, async ({ workspace: registeredWorkspace, worktrees: existing }) => {
+                if (existing.length >= this.maxWorktreesPerWorkspace) {
+                    return { result: { ok: false, error: "worktree_limit_reached" } };
+                }
+                const topLevel = await this.runGit(["rev-parse", "--show-toplevel"], requestedPath);
+                if (!topLevel.ok) {
+                    return {
+                        result: this.mapGitFailure(topLevel.stderr, registeredWorkspace, requestedPath, [requestedPath]),
+                    };
+                }
+                const targetRootPath = await realpathOrResolve(topLevel.stdout.trim());
+                if (existing.some((entry) => entry.id === options.id || isSamePath(entry.path, targetRootPath))) {
+                    return { result: { ok: false, error: "worktree_exists" } };
+                }
+                const id = options.id ?? deriveAdoptedWorktreeId(targetRootPath, new Set(existing.map((entry) => entry.id)));
+                if (!WORKTREE_ID_PATTERN.test(id)) {
+                    return { result: { ok: false, error: "invalid_worktree_id" } };
+                }
+                const gitList = await this.runGit(["worktree", "list", "--porcelain"], targetRootPath);
+                if (!gitList.ok) {
+                    return {
+                        result: this.mapGitFailure(gitList.stderr, registeredWorkspace, targetRootPath, [
+                            requestedPath,
+                            targetRootPath,
+                        ]),
+                    };
+                }
+                const entries = parseWorktreeListEntries(gitList.stdout);
+                const targetEntry = await findWorktreeListEntryByPath(entries, targetRootPath);
+                if (targetEntry === undefined) {
+                    return {
+                        result: {
+                            ok: false,
+                            error: "worktree_not_found",
+                            detail: "checkout is not listed by git worktree",
+                        },
+                    };
+                }
+                const workspaceRootPath = await realpathOrResolve(registeredWorkspace.path);
+                const sourceRootPath = await findAdoptSourceRootPath(entries, workspaceRootPath, targetRootPath);
+                if (sourceRootPath === undefined) {
+                    return {
+                        result: {
+                            ok: false,
+                            error: "worktree_source_unregistered",
+                            detail: "worktree source checkout is not inside the registered workspace",
+                        },
+                    };
+                }
+                const sourceRootRelativePath = await findWorkspaceRelativePathForRealpath(workspaceRootPath, undefined, sourceRootPath);
+                if (sourceRootRelativePath === null) {
+                    return {
+                        result: {
+                            ok: false,
+                            error: "worktree_source_unregistered",
+                            detail: "worktree source checkout is not inside the registered workspace",
+                        },
+                    };
+                }
+                const branch = targetEntry.branch ?? targetEntry.detached ?? "HEAD";
+                if (!isValidGitRefSyntax(branch)) {
+                    return {
+                        result: { ok: false, error: "git_failed", detail: "invalid worktree branch ref syntax" },
+                    };
+                }
+                const baseRef = options.baseRef ?? (await this.resolveDefaultBaseRef(sourceRootPath));
+                const worktree = {
+                    id,
+                    workspaceName: registeredWorkspace.name,
+                    path: targetRootPath,
+                    ...(sourceRootRelativePath === undefined ? {} : { sourceRootRelativePath }),
+                    branch,
+                    ...(baseRef === undefined ? {} : { baseRef }),
+                    createdAt: this.now(),
+                    sessionIds: [],
+                };
+                return { result: { ok: true, worktree }, worktree };
+            });
+            if (result.ok) {
+                try {
+                    await this.flushState?.();
+                }
+                catch {
+                    return {
+                        ok: false,
+                        error: "git_failed",
+                        detail: "worktree state could not be flushed; the existing checkout and daemon record were preserved",
+                    };
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            if (isIrohRemoteWorktreeParentWorkspaceNotFoundError(error)) {
+                return { ok: false, error: "worktree_source_unregistered" };
+            }
+            if (isIrohRemoteWorktreePersistenceError(error)) {
+                return {
+                    ok: false,
+                    error: "git_failed",
+                    detail: "worktree state could not be persisted; the existing checkout was left unchanged",
+                };
+            }
+            throw error;
+        }
+    }
+    async validateWorkingDirectory(workspace, workingDirectory) {
+        const resolved = await resolveWorkspaceDirectory(workspace.path, workingDirectory);
+        if (!resolved.ok) {
+            return { ok: false, error: "invalid_working_directory", detail: resolved.error };
+        }
+        return { ok: true, directory: resolved.value };
+    }
+    async resolveWorktreeWorkingDirectory(workspace, worktree, workingDirectory) {
+        if (workingDirectory === undefined) {
+            const rootDirectory = await resolveWorkspaceDirectory(worktree.path);
+            return rootDirectory.ok
+                ? { ok: true, directory: rootDirectory.value }
+                : { ok: false, error: "invalid_working_directory", detail: rootDirectory.error };
+        }
+        const parentDirectory = await this.validateWorkingDirectory(workspace, workingDirectory);
+        if (!parentDirectory.ok) {
+            return parentDirectory;
+        }
+        const sourceRootPath = await this.resolveRecordSourceRootPath(workspace, worktree);
+        if (sourceRootPath === undefined || !isPathContained(sourceRootPath, parentDirectory.directory.absolutePath)) {
+            return {
+                ok: false,
+                error: "invalid_working_directory",
+                detail: "workingDirectory is outside the worktree source repository",
+            };
+        }
+        const worktreeRelativePath = getContainedRelativePath(sourceRootPath, parentDirectory.directory.absolutePath);
+        if (worktreeRelativePath === null) {
+            return {
+                ok: false,
+                error: "invalid_working_directory",
+                detail: "workingDirectory is outside the worktree source repository",
+            };
+        }
+        const worktreeDirectory = await resolveWorkspaceDirectory(worktree.path, worktreeRelativePath);
+        return worktreeDirectory.ok
+            ? { ok: true, directory: worktreeDirectory.value }
+            : { ok: false, error: "invalid_working_directory", detail: worktreeDirectory.error };
+    }
+    async resolveCreateSource(workspace, workingDirectory) {
+        const workspaceDirectory = await this.validateWorkingDirectory(workspace, workingDirectory);
+        if (!workspaceDirectory.ok) {
+            return workspaceDirectory;
+        }
+        const topLevel = await this.runGit(["-C", workspaceDirectory.directory.absolutePath, "rev-parse", "--show-toplevel"], workspace.path);
+        if (!topLevel.ok) {
+            const detail = sanitizeGitDetail(topLevel.stderr, [
+                workspace.path,
+                workspaceDirectory.directory.absolutePath,
+                getWorktreesRoot(this.agentDir),
+            ]);
+            return {
+                ok: false,
+                error: topLevel.stderr.toLowerCase().includes("not a git repository")
+                    ? "not_a_git_repository"
+                    : "git_failed",
+                ...(detail.length === 0 ? {} : { detail }),
+            };
+        }
+        const workspaceRootPath = await realpathOrResolve(workspace.path);
+        const sourceRootPath = await realpathOrResolve(topLevel.stdout.trim());
+        if (!isPathContained(workspaceRootPath, sourceRootPath)) {
+            return {
+                ok: false,
+                error: "invalid_working_directory",
+                detail: "git repository is outside the registered workspace",
+            };
+        }
+        const sourceRootRelativePath = await findWorkspaceRelativePathForRealpath(workspaceRootPath, workspaceDirectory.directory.relativePath, sourceRootPath);
+        if (sourceRootRelativePath === null) {
+            return {
+                ok: false,
+                error: "invalid_working_directory",
+                detail: "git repository is outside the registered workspace",
+            };
+        }
+        const workingDirectoryRelativePath = getContainedRelativePath(sourceRootPath, workspaceDirectory.directory.absolutePath);
+        if (workingDirectoryRelativePath === null) {
+            return {
+                ok: false,
+                error: "invalid_working_directory",
+                detail: "workingDirectory is outside the source repository",
+            };
+        }
+        return {
+            ok: true,
+            source: {
+                workspaceDirectory: workspaceDirectory.directory,
+                sourceRootPath,
+                ...(sourceRootRelativePath === undefined ? {} : { sourceRootRelativePath }),
+                ...(workingDirectoryRelativePath === undefined ? {} : { workingDirectoryRelativePath }),
+            },
+        };
+    }
+    async list(workspace) {
+        const records = await this.stateManager.listWorktrees(workspace.name);
+        const gitListBySourceRoot = new Map();
+        const statuses = [];
+        for (const record of records) {
+            const sourceRootPath = await this.resolveRecordSourceRootPath(workspace, record);
+            const knownCheckouts = sourceRootPath === undefined
+                ? undefined
+                : await this.getKnownWorktreeCheckouts(sourceRootPath, gitListBySourceRoot);
+            const onDisk = existsSync(record.path);
+            const available = onDisk &&
+                sourceRootPath !== undefined &&
+                (knownCheckouts === undefined || knownCheckouts.has(resolve(record.path)));
+            let dirty;
+            let aheadBehind;
+            if (available) {
+                // --no-optional-locks is a git-level option and must precede the subcommand.
+                const status = await this.runGit(["-C", record.path, "--no-optional-locks", "status", "--porcelain"], sourceRootPath);
+                dirty = status.ok ? status.stdout.trim().length > 0 : undefined;
+                aheadBehind = await this.computeAheadBehind(sourceRootPath, record);
+            }
+            statuses.push({
+                ...record,
+                available,
+                ...(dirty === undefined ? {} : { dirty }),
+                ...(aheadBehind === undefined ? {} : { aheadBehind }),
+            });
+        }
+        return statuses;
+    }
+    async getKnownWorktreeCheckouts(sourceRootPath, cache) {
+        const key = resolve(sourceRootPath);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const gitList = await this.runGit(["worktree", "list", "--porcelain"], sourceRootPath);
+        const knownCheckouts = gitList.ok ? parseWorktreeListCheckouts(gitList.stdout) : undefined;
+        cache.set(key, knownCheckouts);
+        return knownCheckouts;
+    }
+    async resolveRecordSourceRootPath(workspace, record) {
+        const resolved = await resolveWorkspaceDirectory(workspace.path, record.sourceRootRelativePath);
+        return resolved.ok ? resolved.value.absolutePath : undefined;
+    }
+    /** Concrete base for a defaulted create: current branch name, else commit sha. */
+    async resolveDefaultBaseRef(sourceRootPath) {
+        const symbolic = await this.runGit(["symbolic-ref", "--short", "-q", "HEAD"], sourceRootPath);
+        const shortRef = symbolic.ok ? symbolic.stdout.trim() : "";
+        if (shortRef.length > 0 && isValidGitRefSyntax(shortRef)) {
+            return shortRef;
+        }
+        const sha = await this.runGit(["rev-parse", "HEAD"], sourceRootPath);
+        const shaValue = sha.ok ? sha.stdout.trim() : "";
+        return /^[0-9a-f]{4,64}$/i.test(shaValue) ? shaValue : undefined;
+    }
+    /**
+     * Merge-back guidance (design §5.3): branch commits relative to the base
+     * ref, computed read-only in the source checkout. `left...right` with
+     * left = base and right = branch yields "behind<TAB>ahead".
+     */
+    async computeAheadBehind(sourceRootPath, record) {
+        const baseRef = record.baseRef ?? "HEAD";
+        const counted = await this.runGit(["rev-list", "--left-right", "--count", `${baseRef}...${record.branch}`], sourceRootPath);
+        if (!counted.ok) {
+            return undefined;
+        }
+        const match = counted.stdout.trim().match(/^(\d+)\s+(\d+)$/);
+        if (!match?.[1] || !match[2]) {
+            return undefined;
+        }
+        return { behind: Number.parseInt(match[1], 10), ahead: Number.parseInt(match[2], 10) };
+    }
+    /** Refuses dirty/busy unless force; `git worktree remove [--force]`, then drops the record. */
+    async remove(workspace, worktreeId, options = {}) {
+        const force = options.force === true;
+        const records = await this.stateManager.listWorktrees(workspace.name);
+        const record = records.find((entry) => entry.id === worktreeId);
+        if (!record) {
+            return { ok: false, error: "worktree_not_found" };
+        }
+        if (!force && this.hasActiveRuntimeForSession) {
+            const busy = record.sessionIds.some((sessionId) => this.hasActiveRuntimeForSession?.(workspace.name, sessionId));
+            if (busy) {
+                return { ok: false, error: "worktree_busy" };
+            }
+        }
+        const sourceRootPath = await this.resolveRecordSourceRootPath(workspace, record);
+        if (existsSync(record.path)) {
+            if (sourceRootPath === undefined) {
+                return { ok: false, error: "not_a_git_repository", detail: "worktree source repository is unavailable" };
+            }
+            if (!force) {
+                const status = await this.runGit(["-C", record.path, "--no-optional-locks", "status", "--porcelain"], sourceRootPath);
+                if (status.ok && status.stdout.trim().length > 0) {
+                    return { ok: false, error: "worktree_dirty", detail: "dirty" };
+                }
+            }
+            const args = force ? ["worktree", "remove", "--force", record.path] : ["worktree", "remove", record.path];
+            const removed = await this.runGit(args, sourceRootPath);
+            if (!removed.ok) {
+                return this.mapGitFailure(removed.stderr, workspace, record.path, [sourceRootPath]);
+            }
+        }
+        else {
+            // Checkout vanished out-of-band: clear the stale gitdir entry best-effort.
+            if (sourceRootPath !== undefined) {
+                await this.runGit(["worktree", "prune"], sourceRootPath).catch(() => undefined);
+            }
+        }
+        await this.stateManager.removeWorktree(workspace.name, worktreeId);
+        await this.flushState?.();
+        return { ok: true };
+    }
+    /**
+     * Reconcile persisted records vs filesystem vs `git worktree list`. Drops
+     * records without checkouts, quarantines unrecognized checkout directories
+     * (rename, never delete), and runs `git worktree prune` in each known source checkout.
+     */
+    async prune(workspace) {
+        const records = await this.stateManager.listWorktrees(workspace.name);
+        const removedRecords = [];
+        const sourceRootPaths = new Set();
+        for (const record of records) {
+            const sourceRootPath = await this.resolveRecordSourceRootPath(workspace, record);
+            if (sourceRootPath !== undefined) {
+                sourceRootPaths.add(sourceRootPath);
+            }
+            if (!existsSync(record.path)) {
+                await this.stateManager.removeWorktree(workspace.name, record.id);
+                removedRecords.push(record.id);
+            }
+        }
+        const parentSourceRootPath = await this.resolveRecordSourceRootPath(workspace, {
+            id: "root",
+            workspaceName: workspace.name,
+            path: workspace.path,
+            branch: "HEAD",
+            createdAt: 0,
+            sessionIds: [],
+        });
+        if (parentSourceRootPath !== undefined) {
+            sourceRootPaths.add(parentSourceRootPath);
+        }
+        const orphanCheckouts = [];
+        const workspaceDir = getWorkspaceWorktreesDir(this.agentDir, workspace.path);
+        const recordedPaths = new Set(records.map((record) => resolve(record.path)));
+        if (existsSync(workspaceDir)) {
+            for (const entry of await readdir(workspaceDir, { withFileTypes: true })) {
+                if (!entry.isDirectory() || entry.name.includes(".orphan-")) {
+                    continue;
+                }
+                const entryPath = resolve(join(workspaceDir, entry.name));
+                if (recordedPaths.has(entryPath)) {
+                    continue;
+                }
+                const quarantinePath = `${entryPath}.orphan-${this.now()}`;
+                try {
+                    await rename(entryPath, quarantinePath);
+                    orphanCheckouts.push(entry.name);
+                }
+                catch {
+                    // Quarantine is best-effort; a busy directory stays put for the next prune.
+                }
+            }
+        }
+        for (const sourceRootPath of sourceRootPaths) {
+            await this.runGit(["worktree", "prune"], sourceRootPath).catch(() => undefined);
+        }
+        if (removedRecords.length > 0) {
+            await this.flushState?.();
+        }
+        await this.logAudit({
+            type: "worktree_pruned",
+            workspace: workspace.name,
+            success: true,
+            details: { removedRecords, orphanCheckouts },
+        });
+        return { removedRecords, orphanCheckouts };
+    }
+    /**
+     * Retention removal (design §5.3): remove a worktree ONLY when it is not
+     * busy, has no uncommitted work, and its branch is fully merged into the
+     * base ref. Never forces; a skip returns the reason for the audit trail.
+     */
+    async removeIfCleanAndMerged(workspace, worktreeId) {
+        const record = (await this.stateManager.listWorktrees(workspace.name)).find((entry) => entry.id === worktreeId);
+        if (!record) {
+            return { removed: false, reason: "worktree_not_found" };
+        }
+        if (this.hasActiveRuntimeForSession &&
+            record.sessionIds.some((sessionId) => this.hasActiveRuntimeForSession?.(workspace.name, sessionId))) {
+            return { removed: false, reason: "busy" };
+        }
+        if (!existsSync(record.path)) {
+            return { removed: false, reason: "checkout_missing" };
+        }
+        const sourceRootPath = await this.resolveRecordSourceRootPath(workspace, record);
+        if (sourceRootPath === undefined) {
+            return { removed: false, reason: "source_unavailable" };
+        }
+        const status = await this.runGit(["-C", record.path, "--no-optional-locks", "status", "--porcelain"], sourceRootPath);
+        if (!status.ok || status.stdout.trim().length > 0) {
+            return { removed: false, reason: "dirty" };
+        }
+        const merged = await this.runGit(["merge-base", "--is-ancestor", record.branch, record.baseRef ?? "HEAD"], sourceRootPath);
+        if (!merged.ok) {
+            return { removed: false, reason: "unmerged" };
+        }
+        const removedResult = await this.remove(workspace, worktreeId, { force: false });
+        if (!removedResult.ok) {
+            return { removed: false, reason: removedResult.error };
+        }
+        return { removed: true };
+    }
+    /** Lookup used by conversation open/resume and relay preamble resolution. */
+    async resolveSessionWorktree(workspaceName, sessionId) {
+        return this.stateManager.findWorktreeForSession(workspaceName, sessionId);
+    }
+    async bindSession(workspaceName, worktreeId, sessionId) {
+        await this.stateManager.bindWorktreeSession(workspaceName, worktreeId, sessionId);
+        await this.flushState?.();
+    }
+    async findWorktree(workspaceName, worktreeId) {
+        const records = await this.stateManager.listWorktrees(workspaceName);
+        return records.find((entry) => entry.id === worktreeId);
+    }
+    /**
+     * Compatibility guard for post-unregister callers. Workspace unregister is
+     * deliberately non-destructive: persisted worktrees block the state mutation,
+     * and unknown checkout directories are preserved for manual reconciliation.
+     */
+    async cleanupUnregisteredWorkspace(workspace) {
+        const workspaceDir = getWorkspaceWorktreesDir(this.agentDir, workspace.path);
+        if (!existsSync(workspaceDir)) {
+            return;
+        }
+        let preservedEntryCount = 0;
+        try {
+            preservedEntryCount = (await readdir(workspaceDir)).length;
+        }
+        catch {
+            // Inspection is best-effort. Failure still leaves every path untouched.
+        }
+        const persistedWorktreeIds = (await this.stateManager.listWorktrees(workspace.name))
+            .map((worktree) => worktree.id)
+            .sort();
+        await this.logAudit({
+            type: "worktree_unregister_cleanup_skipped",
+            workspace: workspace.name,
+            success: false,
+            error: "workspace unregister never removes worktree checkouts",
+            details: {
+                persistedWorktreeIds,
+                preservedEntryCount,
+                reason: "non_destructive_workspace_unregister",
+            },
+        });
+    }
+    mapGitFailure(stderr, workspace, checkoutPath, extraPaths = []) {
+        const detail = sanitizeGitDetail(stderr, [
+            checkoutPath,
+            workspace.path,
+            ...extraPaths,
+            getWorktreesRoot(this.agentDir),
+        ]);
+        const lower = stderr.toLowerCase();
+        if (lower.includes("not a git repository")) {
+            return { ok: false, error: "not_a_git_repository", detail };
+        }
+        if (lower.includes("already exists")) {
+            return lower.includes("branch") || lower.includes("-b")
+                ? { ok: false, error: "worktree_branch_conflict", detail }
+                : { ok: false, error: "worktree_exists", detail };
+        }
+        if (lower.includes("contains modified or untracked files")) {
+            return { ok: false, error: "worktree_dirty", detail };
+        }
+        return { ok: false, error: "git_failed", detail };
+    }
+    async logAudit(event) {
+        try {
+            await this.auditLogger.log(event);
+        }
+        catch {
+            // Audit logging is best-effort.
+        }
+    }
+}
+async function realpathOrResolve(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+function getContainedRelativePath(root, child) {
+    const relativePath = relative(resolve(root), resolve(child));
+    if (relativePath.length === 0 || relativePath === ".") {
+        return undefined;
+    }
+    if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+        return null;
+    }
+    return relativePath.split(sep).join("/");
+}
+async function findWorkspaceRelativePathForRealpath(workspaceRootPath, selectedRelativePath, targetRealpath) {
+    const selectedSegments = selectedRelativePath?.split("/") ?? [];
+    for (let count = selectedSegments.length; count >= 0; count -= 1) {
+        const candidateRelativePath = count === 0 ? undefined : selectedSegments.slice(0, count).join("/");
+        const candidatePath = candidateRelativePath === undefined ? workspaceRootPath : resolve(workspaceRootPath, candidateRelativePath);
+        try {
+            const candidateRealpath = await realpath(candidatePath);
+            if (isSamePath(candidateRealpath, targetRealpath)) {
+                return candidateRelativePath;
+            }
+        }
+        catch {
+            // Ignore missing ancestors and fall back to the canonical realpath-relative form below.
+        }
+    }
+    return getContainedRelativePath(workspaceRootPath, targetRealpath);
+}
+function isSamePath(left, right) {
+    const resolvedLeft = resolve(left);
+    const resolvedRight = resolve(right);
+    return process.platform === "win32"
+        ? resolvedLeft.toLowerCase() === resolvedRight.toLowerCase()
+        : resolvedLeft === resolvedRight;
+}
+function parseWorktreeListEntries(porcelainOutput) {
+    const entries = [];
+    let current;
+    const pushCurrent = () => {
+        if (current !== undefined) {
+            entries.push(current);
+            current = undefined;
+        }
+    };
+    for (const line of porcelainOutput.split("\n")) {
+        if (line.length === 0) {
+            pushCurrent();
+            continue;
+        }
+        if (line.startsWith("worktree ")) {
+            pushCurrent();
+            current = { path: line.slice("worktree ".length).trim() };
+            continue;
+        }
+        if (current === undefined) {
+            continue;
+        }
+        if (line.startsWith("branch ")) {
+            const ref = line.slice("branch ".length).trim();
+            current.branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+            continue;
+        }
+        if (line.startsWith("detached ")) {
+            current.detached = line.slice("detached ".length).trim();
+        }
+    }
+    pushCurrent();
+    return entries;
+}
+function parseWorktreeListCheckouts(porcelainOutput) {
+    return new Set(parseWorktreeListEntries(porcelainOutput).map((entry) => resolve(entry.path)));
+}
+async function findWorktreeListEntryByPath(entries, path) {
+    for (const entry of entries) {
+        if (isSamePath(await realpathOrResolve(entry.path), path)) {
+            return entry;
+        }
+    }
+    return undefined;
+}
+async function findAdoptSourceRootPath(entries, workspaceRootPath, targetRootPath) {
+    for (const entry of entries) {
+        const entryPath = await realpathOrResolve(entry.path);
+        if (!isSamePath(entryPath, targetRootPath) && isPathContained(workspaceRootPath, entryPath)) {
+            return entryPath;
+        }
+    }
+    return undefined;
+}
+function deriveAdoptedWorktreeId(path, usedIds) {
+    const baseName = basename(path)
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^[^a-z0-9]+/, "")
+        .slice(0, 64);
+    const base = WORKTREE_ID_PATTERN.test(baseName) ? baseName : "adopted";
+    for (let index = 0; index < 100; index++) {
+        const suffix = index === 0 ? "" : `-${index}`;
+        const candidate = `${base.slice(0, 64 - suffix.length)}${suffix}`;
+        if (WORKTREE_ID_PATTERN.test(candidate) && !usedIds.has(candidate)) {
+            return candidate;
+        }
+    }
+    return generateWorktreeIdSlug();
+}
+/** Strip host paths from git stderr before it lands in an RPC detail field. */
+function sanitizeGitDetail(stderr, paths) {
+    let detail = stderr.trim();
+    for (const path of paths) {
+        while (detail.includes(path)) {
+            detail = detail.replace(path, "<redacted>");
+        }
+    }
+    return detail;
+}
+/**
+ * Opt-in worktree retention (design §5.3): when a worktree-bound runtime is
+ * disposed, schedule a TTL sweep that removes the worktree ONLY when it is
+ * clean and fully merged into its base ref; otherwise the skip is audited as
+ * worktree_retention_skipped_dirty and the checkout stays put.
+ */
+export class WorktreeRetentionSweeper {
+    options;
+    timers = new Map();
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    /** Hooked to IntegratedRuntimeRegistry.onRuntimeDisposed for worktree-bound entries. */
+    onRuntimeDisposed(workspaceName, worktreeId) {
+        if (this.disposed) {
+            return;
+        }
+        const policy = this.options.getRetentionPolicy();
+        if (policy === undefined || !policy.enabled) {
+            return;
+        }
+        const key = `${workspaceName}\0${worktreeId}`;
+        const existing = this.timers.get(key);
+        if (existing !== undefined) {
+            (this.options.clearTimer ?? clearTimeout)(existing);
+        }
+        const timer = (this.options.setTimer ?? setTimeout)(() => {
+            this.timers.delete(key);
+            void this.sweep(workspaceName, worktreeId);
+        }, policy.ttlMs);
+        timer.unref?.();
+        this.timers.set(key, timer);
+    }
+    async sweep(workspaceName, worktreeId) {
+        if (this.disposed) {
+            return;
+        }
+        try {
+            const state = await this.options.stateManager.getState();
+            const workspace = state.workspaces.find((entry) => entry.name === workspaceName);
+            if (!workspace) {
+                return;
+            }
+            const result = await this.options.manager.removeIfCleanAndMerged(workspace, worktreeId);
+            if (result.removed) {
+                await this.options.auditLogger.log({
+                    type: "worktree_retention_removed",
+                    workspace: workspaceName,
+                    success: true,
+                    details: { worktreeId },
+                });
+                return;
+            }
+            if (result.reason === "worktree_not_found") {
+                return;
+            }
+            await this.options.auditLogger.log({
+                type: "worktree_retention_skipped_dirty",
+                workspace: workspaceName,
+                success: false,
+                details: { worktreeId, reason: result.reason },
+            });
+        }
+        catch {
+            // Retention is best-effort; the next disposal reschedules.
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        for (const timer of this.timers.values()) {
+            (this.options.clearTimer ?? clearTimeout)(timer);
+        }
+        this.timers.clear();
+    }
+}
+export function isWorktreeControlRequest(request) {
+    return (request.type === "worktree_create" ||
+        request.type === "worktree_adopt" ||
+        request.type === "worktree_list" ||
+        request.type === "worktree_remove" ||
+        request.type === "worktree_prune" ||
+        request.type === "worktree_resolve" ||
+        request.type === "worktree_bind");
+}
+/**
+ * Shared `worktree_*` control-socket handler: used by the daemon skeleton
+ * (main.ts fallback) and the iroh service (which layers runtime-aware remove
+ * on top via hooks.removeWorktree). Control responses MAY include checkout
+ * paths — the no-paths rule applies to the iroh wire, not the local socket.
+ */
+export async function handleWorktreeControlRequest(connection, request, hooks) {
+    const state = await hooks.stateManager.getState();
+    const findWorkspace = (name) => state.workspaces.find((workspace) => workspace.name === name);
+    const sendWorkspaceNotFound = (name) => {
+        connection.send({
+            type: "error",
+            id: request.id,
+            code: "not_found",
+            message: `No registered workspace named ${name}`,
+        });
+    };
+    if (request.type === "worktree_create") {
+        const workspace = findWorkspace(request.workspaceName);
+        if (!workspace) {
+            sendWorkspaceNotFound(request.workspaceName);
+            return;
+        }
+        const created = await hooks.manager.create(workspace, {
+            ...(request.worktreeName === undefined ? {} : { id: request.worktreeName }),
+            ...(request.branch === undefined ? {} : { branch: request.branch }),
+            ...(request.baseRef === undefined ? {} : { baseRef: request.baseRef }),
+        });
+        if (!created.ok) {
+            connection.send({
+                type: "error",
+                id: request.id,
+                code: created.error,
+                message: created.detail ?? created.error,
+            });
+            return;
+        }
+        connection.send({
+            type: "worktree_result",
+            id: request.id,
+            worktree: toControlWorktreeStatus(created.worktree, true),
+        });
+        return;
+    }
+    if (request.type === "worktree_adopt") {
+        const workspace = findWorkspace(request.workspaceName);
+        if (!workspace) {
+            sendWorkspaceNotFound(request.workspaceName);
+            return;
+        }
+        const adopted = await hooks.manager.adopt(workspace, {
+            path: request.path,
+            ...(request.worktreeName === undefined ? {} : { id: request.worktreeName }),
+            ...(request.baseRef === undefined ? {} : { baseRef: request.baseRef }),
+        });
+        if (!adopted.ok) {
+            connection.send({
+                type: "error",
+                id: request.id,
+                code: adopted.error,
+                message: adopted.detail ?? adopted.error,
+            });
+            return;
+        }
+        connection.send({
+            type: "worktree_result",
+            id: request.id,
+            worktree: toControlWorktreeStatus(adopted.worktree, true),
+        });
+        return;
+    }
+    if (request.type === "worktree_list") {
+        const workspaces = resolveRequestWorkspaces(state.workspaces, request.workspaceName);
+        if (!workspaces.ok) {
+            sendWorkspaceNotFound(workspaces.missing);
+            return;
+        }
+        const worktrees = [];
+        for (const workspace of workspaces.workspaces) {
+            for (const status of await hooks.manager.list(workspace)) {
+                worktrees.push(toControlWorktreeStatus(status, status.available, status.dirty));
+            }
+        }
+        connection.send({ type: "worktrees_result", id: request.id, worktrees });
+        return;
+    }
+    if (request.type === "worktree_resolve") {
+        const worktrees = await hooks.stateManager.listWorktrees();
+        const match = worktrees.find((worktree) => isPathContained(worktree.path, request.path));
+        const workspace = match ? findWorkspace(match.workspaceName) : undefined;
+        if (!match || !workspace) {
+            connection.send({
+                type: "error",
+                id: request.id,
+                code: "not_found",
+                message: "path is not inside a daemon-managed worktree",
+            });
+            return;
+        }
+        connection.send({
+            type: "worktree_resolve_result",
+            id: request.id,
+            workspaceName: workspace.name,
+            workspacePath: workspace.path,
+            worktreeId: match.id,
+            worktreePath: match.path,
+        });
+        return;
+    }
+    if (request.type === "worktree_bind") {
+        const workspace = findWorkspace(request.workspaceName);
+        if (!workspace) {
+            sendWorkspaceNotFound(request.workspaceName);
+            return;
+        }
+        const record = await hooks.manager.findWorktree(request.workspaceName, request.worktreeId);
+        if (!record) {
+            connection.send({
+                type: "error",
+                id: request.id,
+                code: "worktree_not_found",
+                message: `No worktree ${request.worktreeId} in workspace ${request.workspaceName}`,
+            });
+            return;
+        }
+        await hooks.manager.bindSession(request.workspaceName, request.worktreeId, request.sessionId);
+        connection.send({ type: "ok", id: request.id });
+        return;
+    }
+    if (request.type === "worktree_remove") {
+        const workspace = findWorkspace(request.workspaceName);
+        if (!workspace) {
+            sendWorkspaceNotFound(request.workspaceName);
+            return;
+        }
+        const force = request.force === true;
+        const removed = hooks.removeWorktree
+            ? await hooks.removeWorktree(workspace, request.worktreeId, force)
+            : await hooks.manager.remove(workspace, request.worktreeId, { force });
+        if (!removed.ok) {
+            connection.send({
+                type: "error",
+                id: request.id,
+                code: removed.error,
+                message: removed.detail ?? removed.error,
+            });
+            return;
+        }
+        connection.send({ type: "ok", id: request.id });
+        return;
+    }
+    const workspaces = resolveRequestWorkspaces(state.workspaces, request.workspaceName);
+    if (!workspaces.ok) {
+        sendWorkspaceNotFound(workspaces.missing);
+        return;
+    }
+    const results = [];
+    for (const workspace of workspaces.workspaces) {
+        const pruned = await hooks.manager.prune(workspace);
+        results.push({ workspaceName: workspace.name, ...pruned });
+    }
+    connection.send({ type: "worktree_prune_result", id: request.id, results });
+}
+function resolveRequestWorkspaces(workspaces, workspaceName) {
+    if (workspaceName === undefined) {
+        return { ok: true, workspaces };
+    }
+    const workspace = workspaces.find((entry) => entry.name === workspaceName);
+    return workspace ? { ok: true, workspaces: [workspace] } : { ok: false, missing: workspaceName };
+}
+function toControlWorktreeStatus(worktree, available, dirty) {
+    return {
+        id: worktree.id,
+        workspaceName: worktree.workspaceName,
+        path: worktree.path,
+        branch: worktree.branch,
+        ...(worktree.baseRef === undefined ? {} : { baseRef: worktree.baseRef }),
+        createdAt: worktree.createdAt,
+        sessionIds: [...worktree.sessionIds],
+        ...(available === undefined ? {} : { available }),
+        ...(dirty === undefined ? {} : { dirty }),
+        ...(worktree.aheadBehind === undefined ? {} : { aheadBehind: worktree.aheadBehind }),
+    };
+}
+//# sourceMappingURL=worktree-manager.js.map