@ferueda/grove 0.1.2 → 0.3.0

package/dist/pool.js

@@ -1,11 +1,13 @@
 import { join, basename, dirname, isAbsolute, relative } from "node:path";
 import { mkdir, rm } from "node:fs/promises";
-import { getDefaultBranch, addWorktree, resetWorktree, removeWorktree, isDirty, fetchOrigin, } from "./git/index.js";
+import { existsSync } from "node:fs";
+import { getDefaultBranch, addWorktree, resetWorktree, removeWorktree, isDirty, fetchOrigin, checkoutBranch, checkoutDetached, getHeadSha, resolveRef, deleteBranch, } from "./git/index.js";
 import { withStateLock } from "./lock.js";
 import { readState, writeState, healState } from "./state.js";
 import { reserveOwner, ownerAlive, isWorktreeInUse, findInWorktree } from "./process/detect.js";
 import { runHooks } from "./hooks.js";
-import { GroveExhaustedError, WorktreeDestroyingError, WorktreeInUseError, WorktreeNotManagedError, } from "./errors.js";
+import { GroveExhaustedError, WorktreeDestroyingError, WorktreeNotManagedError, LeaseNotFoundError, LeaseConflictError, LeaseAlreadyExistsError, LeaseQuarantinedError, UnsafeCleanupError, PathOutsidePoolError, BranchDeleteFailedError, } from "./errors.js";
+import { entryToLease, listWorktrees, listLeases, inspectLease } from "./queries.js";
 export class Grove {
     poolDir;
     config;
@@ -13,248 +15,444 @@ export class Grove {
         this.poolDir = poolDir;
         this.config = config;
     }
-    async acquire() {
+    async runHook(hookNames, workDir, env = {}) {
+        if (!hookNames || hookNames.length === 0)
+            return;
+        try {
+            await runHooks(hookNames, workDir, {
+                stdout: process.stderr,
+                stderr: process.stderr,
+                timeoutMs: this.config.hookTimeoutMs,
+                env,
+                onFailure: this.config.onHookFailure,
+            });
+        }
+        catch (err) {
+            if (err.code === "HOOK_FAILED") {
+                throw err;
+            }
+        }
+    }
+    async findOrAllocateSlot(state, defaultBranch) {
+        for (const wt of state.worktrees) {
+            if (wt.destroying || wt.state === "destroying" || wt.state === "releasing" || wt.state === "quarantined" || wt.leaseId)
+                continue;
+            const { inUse } = await isWorktreeInUse(wt.path);
+            const alive = await ownerAlive(wt);
+            if (inUse || alive)
+                continue;
+            const dirty = await isDirty(wt.path);
+            if (dirty)
+                continue;
+            try {
+                await resetWorktree(wt.path, defaultBranch);
+            }
+            catch {
+                continue;
+            }
+            return { entry: wt, isNew: false };
+        }
+        const maxTrees = this.config.maxTrees || 16;
+        if (state.worktrees.length >= maxTrees) {
+            throw new GroveExhaustedError(`Exhausted worktrees (max ${maxTrees})`);
+        }
+        const nextId = this.nextName(state);
+        const repoName = basename(this.config.repoRoot);
+        const wtPath = join(this.poolDir, nextId, repoName);
+        await mkdir(dirname(wtPath), { recursive: true });
+        await addWorktree(this.config.repoRoot, wtPath, defaultBranch);
+        const entry = {
+            name: nextId,
+            path: wtPath,
+            created_at: new Date().toISOString(),
+            state: "available",
+        };
+        state.worktrees.push(entry);
+        return { entry, isNew: true };
+    }
+    async acquire(options) {
         const branch = await getDefaultBranch(this.config.repoRoot);
-        if (this.config.fetchOnAcquire !== false) {
+        const shouldFetch = options ? options.fetchOnAcquire !== false : this.config.fetchOnAcquire !== false;
+        if (shouldFetch) {
             await fetchOrigin(this.config.repoRoot);
         }
-        let acquiredPath = "";
-        let acquiredName = "";
-        let runPostCreate = false;
+        if (!options) {
+            // Ephemeral acquire
+            let acquiredPath = "";
+            let acquiredName = "";
+            let runPostCreate = false;
+            await withStateLock(this.poolDir, async () => {
+                let state = await readState(this.poolDir);
+                state = await healState(state);
+                const { entry, isNew } = await this.findOrAllocateSlot(state, branch);
+                await reserveOwner(entry);
+                entry.state = "available";
+                await writeState(this.poolDir, state);
+                acquiredPath = entry.path;
+                acquiredName = entry.name;
+                runPostCreate = isNew;
+            });
+            if (runPostCreate) {
+                await this.runHook(this.config.hooks?.postCreate, acquiredPath);
+            }
+            return { path: acquiredPath, name: acquiredName };
+        }
+        // LEASE MODE
+        // LEASE MODE
+        let targetWtPath = "";
+        let isNewSlot = false;
+        let returningExisting = false;
         await withStateLock(this.poolDir, async () => {
             let state = await readState(this.poolDir);
             state = await healState(state);
-            for (const wt of state.worktrees) {
-                if (wt.destroying)
-                    continue;
-                const inUse = (await ownerAlive(wt)) || (await isWorktreeInUse(wt.path));
-                if (inUse)
-                    continue;
-                const dirty = await isDirty(wt.path);
-                if (dirty) {
-                    continue; // Do not destructively reset dirty worktrees
+            // Check existing lease
+            const existing = state.worktrees.find(w => w.leaseId === options.leaseId);
+            if (existing) {
+                if (options.ifLeased === "fail") {
+                    throw new LeaseAlreadyExistsError(`Lease ${options.leaseId} already exists`);
                 }
-                try {
-                    await resetWorktree(wt.path, branch); // Always reset clean worktrees to default branch
+                if (existing.state === "quarantined") {
+                    throw new LeaseQuarantinedError(`Lease ${options.leaseId} is quarantined`);
                 }
-                catch {
-                    continue;
+                if (!existsSync(existing.path)) {
+                    existing.state = "quarantined";
+                    await writeState(this.poolDir, state);
+                    throw new LeaseQuarantinedError(`Lease ${options.leaseId} path missing`);
                 }
-                await reserveOwner(wt);
+                // Check compatibility
+                if (options.mode === "branch") {
+                    if (existing.branch !== options.branch) {
+                        throw new LeaseConflictError(`Lease conflict: requested branch ${options.branch}, existing has ${existing.branch}`);
+                    }
+                }
+                else if (options.mode === "detached") {
+                    if (existing.baseRef !== options.ref && existing.baseSha !== options.ref && existing.acquiredHeadSha !== options.ref) {
+                        throw new LeaseConflictError(`Lease conflict: requested ref ${options.ref} does not match existing detached base or SHA`);
+                    }
+                }
+                await reserveOwner(existing);
                 await writeState(this.poolDir, state);
-                acquiredPath = wt.path;
-                acquiredName = wt.name;
-                runPostCreate = true;
-                return;
-            }
-            const maxTrees = this.config.maxTrees || 16;
-            if (state.worktrees.length >= maxTrees) {
-                throw new GroveExhaustedError(`Exhausted worktrees (max ${maxTrees})`);
+                targetWtPath = existing.path;
+                returningExisting = true;
+                return; // we can return existing
             }
-            const nextId = this.nextName(state);
-            const repoName = basename(this.config.repoRoot);
-            const wtPath = join(this.poolDir, nextId, repoName);
-            await mkdir(dirname(wtPath), { recursive: true });
-            await addWorktree(this.config.repoRoot, wtPath, branch);
-            const entry = {
-                name: nextId,
-                path: wtPath,
-                created_at: new Date().toISOString(),
-            };
+            // Need to acquire a new slot for the lease
+            const { entry, isNew } = await this.findOrAllocateSlot(state, branch);
+            entry.leaseId = options.leaseId;
+            entry.ownerId = options.ownerId;
+            entry.state = "leased";
+            entry.branch = options.mode === "branch" ? options.branch : undefined;
+            entry.updatedAt = new Date().toISOString();
             await reserveOwner(entry);
-            state.worktrees.push(entry);
             await writeState(this.poolDir, state);
-            acquiredPath = wtPath;
-            acquiredName = nextId;
-            runPostCreate = true;
+            targetWtPath = entry.path;
+            isNewSlot = isNew;
         });
-        if (runPostCreate && this.config.hooks?.postCreate) {
-            try {
-                await runHooks(this.config.hooks.postCreate, acquiredPath, {
-                    stdout: process.stderr,
-                    stderr: process.stderr,
-                });
+        if (isNewSlot) {
+            await this.runHook(this.config.hooks?.postCreate, targetWtPath);
+        }
+        if (returningExisting) {
+            return this.inspect(options.leaseId);
+        }
+        // Atomicity: checkout and set head
+        try {
+            let baseSha;
+            let baseRef;
+            if (options.mode === "branch") {
+                if (options.createBranch) {
+                    baseRef = options.createBranch.from;
+                    baseSha = await resolveRef(this.config.repoRoot, baseRef);
+                }
+                await checkoutBranch(targetWtPath, options.branch, options.createBranch);
             }
-            catch {
-                // hook failure does not fail acquire
+            else {
+                baseRef = options.ref;
+                baseSha = await resolveRef(this.config.repoRoot, baseRef);
+                await checkoutDetached(targetWtPath, options.ref);
             }
+            const headSha = await getHeadSha(targetWtPath);
+            await withStateLock(this.poolDir, async () => {
+                const state = await readState(this.poolDir);
+                const wt = state.worktrees.find(w => w.path === targetWtPath);
+                if (wt) {
+                    wt.acquiredHeadSha = headSha;
+                    wt.currentHeadSha = headSha;
+                    wt.baseRef = baseRef;
+                    wt.baseSha = baseSha;
+                    await writeState(this.poolDir, state);
+                }
+            });
         }
-        return { path: acquiredPath, name: acquiredName };
+        catch (err) {
+            // Quarantine on failure
+            await withStateLock(this.poolDir, async () => {
+                const state = await readState(this.poolDir);
+                const wt = state.worktrees.find(w => w.path === targetWtPath);
+                if (wt) {
+                    wt.state = "quarantined";
+                    await writeState(this.poolDir, state);
+                }
+            });
+            throw err;
+        }
+        const leaseData = await this.inspect(options.leaseId);
+        await this.runHook(this.config.hooks?.postAcquire, targetWtPath, this.leaseEnv(leaseData));
+        return leaseData;
     }
-    async release(worktreePath) {
-        const branch = await getDefaultBranch(this.config.repoRoot);
+    async release(leaseIdOrPath, options) {
+        if (!options) {
+            // Ephemeral release
+            const branch = await getDefaultBranch(this.config.repoRoot);
+            await withStateLock(this.poolDir, async () => {
+                const state = await readState(this.poolDir);
+                const wt = state.worktrees.find((w) => w.path === leaseIdOrPath);
+                if (!wt) {
+                    throw new WorktreeNotManagedError(`worktree ${leaseIdOrPath} is not managed by grove`);
+                }
+                if (wt.destroying || wt.state === "destroying") {
+                    throw new WorktreeDestroyingError(`worktree ${leaseIdOrPath} is being destroyed`);
+                }
+            });
+            await resetWorktree(leaseIdOrPath, branch);
+            await withStateLock(this.poolDir, async () => {
+                const state = await readState(this.poolDir);
+                const wt = state.worktrees.find((w) => w.path === leaseIdOrPath);
+                if (!wt)
+                    return;
+                wt.owner_pid = undefined;
+                wt.owner_started_at = undefined;
+                wt.state = "available";
+                wt.leaseId = undefined;
+                await writeState(this.poolDir, state);
+            });
+            return;
+        }
+        // LEASE MODE RELEASE
+        let targetWtPath = "";
+        let leaseEnvVars = {};
         await withStateLock(this.poolDir, async () => {
             const state = await readState(this.poolDir);
-            const wt = state.worktrees.find((w) => w.path === worktreePath);
-            if (!wt) {
-                throw new WorktreeNotManagedError(`worktree ${worktreePath} is not managed by grove`);
+            const wt = state.worktrees.find(w => w.leaseId === leaseIdOrPath || w.path === leaseIdOrPath);
+            if (!wt || !wt.leaseId) {
+                throw new LeaseNotFoundError(`Lease ${leaseIdOrPath} not found`);
             }
-            if (wt.destroying) {
-                throw new WorktreeDestroyingError(`worktree ${worktreePath} is being destroyed`);
+            const { inUse, unverified } = await isWorktreeInUse(wt.path);
+            const alive = await ownerAlive(wt);
+            if (options.cleanup === "reset" && !options.force) {
+                if (inUse || alive || unverified) {
+                    throw new UnsafeCleanupError(`Unsafe cleanup: active processes or unverified safety. Use force: true.`);
+                }
             }
+            wt.state = "releasing";
+            wt.pendingCleanup = options;
+            await writeState(this.poolDir, state);
+            targetWtPath = wt.path;
+            leaseEnvVars = this.leaseEnv(entryToLease(wt, unverified ? "unverified" : "verified", this.config.repoRoot));
         });
-        await resetWorktree(worktreePath, branch);
+        await this.runHook(this.config.hooks?.preRelease, targetWtPath, leaseEnvVars);
+        try {
+            if (options.cleanup === "reset") {
+                await resetWorktree(targetWtPath, options.resetTo || await getDefaultBranch(this.config.repoRoot));
+            }
+            // quarantine handles marking unusable, preserve does nothing to files
+        }
+        catch (err) {
+            await withStateLock(this.poolDir, async () => {
+                const state = await readState(this.poolDir);
+                const wt = state.worktrees.find(w => w.path === targetWtPath);
+                if (wt) {
+                    wt.state = "quarantined";
+                    await writeState(this.poolDir, state);
+                }
+            });
+            throw new UnsafeCleanupError(`Cleanup failed: ${err.message}`);
+        }
+        let finalLease = null;
         await withStateLock(this.poolDir, async () => {
             const state = await readState(this.poolDir);
-            const wt = state.worktrees.find((w) => w.path === worktreePath);
-            if (!wt) {
-                throw new WorktreeNotManagedError(`worktree ${worktreePath} is not managed by grove`);
-            }
-            if (wt.destroying) {
-                throw new WorktreeDestroyingError(`worktree ${worktreePath} is being destroyed`);
-            }
+            const wt = state.worktrees.find(w => w.path === targetWtPath);
+            if (!wt)
+                return;
             wt.owner_pid = undefined;
             wt.owner_started_at = undefined;
-            await writeState(this.poolDir, state);
-        });
-    }
-    nextName(state) {
-        let max = 0;
-        for (const wt of state.worktrees) {
-            const n = parseInt(wt.name, 10);
-            if (!isNaN(n) && n > max) {
-                max = n;
+            wt.pendingCleanup = undefined;
+            if (options.cleanup === "quarantine") {
+                wt.state = "quarantined";
             }
-        }
-        return (max + 1).toString();
-    }
-    async list() {
-        const result = [];
-        await withStateLock(this.poolDir, async () => {
-            let state = await readState(this.poolDir);
-            state = await healState(state);
-            await writeState(this.poolDir, state);
-            const cwd = process.cwd();
-            for (const wt of state.worktrees) {
-                if (wt.destroying)
-                    continue;
-                let status = "available";
-                const processes = await findInWorktree(wt.path);
-                const alive = await ownerAlive(wt);
-                if (alive) {
-                    status = "in-use";
-                }
-                else if (processes.length > 0) {
-                    status = "in-use";
-                    if (cwdInWorktree(cwd, wt.path)) {
-                        status = "you're here";
-                    }
-                }
-                else if (await isDirty(wt.path)) {
-                    status = "dirty";
-                }
-                result.push({
-                    name: wt.name,
-                    path: wt.path,
-                    status,
-                    processes,
-                });
+            else if (options.cleanup === "reset") {
+                wt.state = "available";
+                const tempId = wt.leaseId; // capture to return lease metadata
+                wt.leaseId = undefined;
+                finalLease = entryToLease({ ...wt, leaseId: tempId }, "verified", this.config.repoRoot);
+            }
+            else if (options.cleanup === "preserve") {
+                wt.state = "leased";
             }
+            await writeState(this.poolDir, state);
         });
-        return result;
+        await this.runHook(this.config.hooks?.postRelease, targetWtPath, leaseEnvVars);
+        return finalLease || this.inspect(leaseIdOrPath);
     }
-    async destroy(worktreePath, options) {
-        let reserved;
+    async destroy(leaseIdOrPath, options) {
+        let targetWtPath = "";
+        let leaseEnvVars = {};
+        let branchToDelete;
         await withStateLock(this.poolDir, async () => {
             const state = await readState(this.poolDir);
-            const idx = state.worktrees.findIndex((wt) => wt.path === worktreePath);
+            const idx = state.worktrees.findIndex(w => w.leaseId === leaseIdOrPath || w.path === leaseIdOrPath);
             const targetWt = state.worktrees[idx];
             if (!targetWt) {
-                throw new WorktreeNotManagedError(`worktree ${worktreePath} is not managed by grove`);
+                throw new WorktreeNotManagedError(`worktree ${leaseIdOrPath} not managed by grove`);
             }
+            const { inUse, unverified } = await isWorktreeInUse(targetWt.path);
+            const alive = await ownerAlive(targetWt);
             if (!options?.force) {
-                const inUse = (await ownerAlive(targetWt)) || (await isWorktreeInUse(targetWt.path));
-                if (inUse) {
-                    throw new WorktreeInUseError(`worktree ${worktreePath} is in use by an agent. Use --force to override`);
+                if (inUse || alive || unverified) {
+                    throw new UnsafeCleanupError(`worktree ${targetWt.path} is in use or unverified. Use --force to override`);
+                }
+            }
+            if (options?.deleteBranch && targetWt.branch) {
+                const safePrefixes = this.config.safeDeleteBranchPrefixes || [];
+                if (!safePrefixes.some(p => targetWt.branch.startsWith(p))) {
+                    throw new UnsafeCleanupError(`Branch ${targetWt.branch} does not match safe-delete prefixes`);
                 }
+                branchToDelete = targetWt.branch;
             }
             targetWt.destroying = true;
+            targetWt.state = "destroying";
             await reserveOwner(targetWt);
-            reserved = { ...targetWt };
+            targetWtPath = targetWt.path;
+            leaseEnvVars = targetWt.leaseId ? this.leaseEnv(entryToLease(targetWt, unverified ? "unverified" : "verified", this.config.repoRoot)) : {};
             await writeState(this.poolDir, state);
         });
-        if (this.config.hooks?.preDestroy) {
-            try {
-                await runHooks(this.config.hooks.preDestroy, worktreePath, {
-                    stdout: process.stderr,
-                    stderr: process.stderr,
-                });
-            }
-            catch { }
-        }
+        await this.executeDestroy(targetWtPath, leaseEnvVars, branchToDelete, options);
+    }
+    async executeDestroy(targetWtPath, leaseEnvVars, branchToDelete, options) {
+        await this.runHook(this.config.hooks?.preDestroy, targetWtPath, leaseEnvVars);
         await withStateLock(this.poolDir, async () => {
             const state = await readState(this.poolDir);
-            const idx = state.worktrees.findIndex((wt) => wt.path === worktreePath);
-            if (idx === -1)
+            const idx = state.worktrees.findIndex((wt) => wt.path === targetWtPath);
+            const wt = state.worktrees[idx];
+            if (!wt)
                 return;
-            if (!sameDestroyReservation(state.worktrees[idx], reserved)) {
+            if (!wt.destroying && wt.state !== "destroying")
                 return;
-            }
             try {
-                await removeWorktree(this.config.repoRoot, worktreePath);
+                await removeWorktree(this.config.repoRoot, targetWtPath);
             }
             catch { }
-            assertPathWithinPool(this.poolDir, worktreePath);
+            this.assertPathWithinPool(this.poolDir, targetWtPath);
             try {
-                await rm(dirname(worktreePath), { recursive: true, force: true });
+                await rm(dirname(targetWtPath), { recursive: true, force: true });
             }
             catch { }
+            let branchDeleteError;
+            if (branchToDelete) {
+                try {
+                    await deleteBranch(this.config.repoRoot, branchToDelete, options?.force);
+                }
+                catch (err) {
+                    branchDeleteError = err;
+                }
+            }
             state.worktrees.splice(idx, 1);
             await writeState(this.poolDir, state);
+            if (branchDeleteError) {
+                throw new BranchDeleteFailedError(`Branch deletion failed: ${branchDeleteError.message}`);
+            }
         });
     }
     async destroyAll(options) {
-        let worktrees = [];
+        const targets = [];
         await withStateLock(this.poolDir, async () => {
             const state = await readState(this.poolDir);
-            if (!options?.force) {
-                for (const wt of state.worktrees) {
-                    const inUse = (await ownerAlive(wt)) || (await isWorktreeInUse(wt.path));
-                    if (inUse) {
-                        throw new WorktreeInUseError(`worktree ${wt.path} is in use by an agent. Use --force to override`);
+            // Phase 1: validate all
+            for (const wt of state.worktrees) {
+                const { inUse, unverified } = await isWorktreeInUse(wt.path);
+                const alive = await ownerAlive(wt);
+                if (!options?.force) {
+                    if (inUse || alive || unverified) {
+                        throw new UnsafeCleanupError(`worktree ${wt.path} is in use or unverified. Use --force to override`);
                     }
                 }
             }
+            // Phase 2: reserve all
             for (const wt of state.worktrees) {
                 wt.destroying = true;
+                wt.state = "destroying";
                 await reserveOwner(wt);
+                const { unverified } = await findInWorktree(wt.path);
+                const env = wt.leaseId ? this.leaseEnv(entryToLease(wt, unverified ? "unverified" : "verified", this.config.repoRoot)) : {};
+                targets.push({ path: wt.path, env });
             }
-            worktrees = state.worktrees.map((wt) => ({ ...wt }));
             await writeState(this.poolDir, state);
         });
-        for (const wt of worktrees) {
-            if (this.config.hooks?.preDestroy) {
-                try {
-                    await runHooks(this.config.hooks.preDestroy, wt.path, {
-                        stdout: process.stderr,
-                        stderr: process.stderr,
-                    });
-                }
-                catch { }
+        // Phase 3: execute destructs outside the shared lock
+        const errors = [];
+        await Promise.all(targets.map(async (target) => {
+            try {
+                await this.executeDestroy(target.path, target.env, undefined, options);
             }
+            catch (err) {
+                errors.push(err);
+            }
+        }));
+        if (errors.length > 0) {
+            throw errors[0]; // Propagate the first failure (e.g. BranchDeleteFailedError)
         }
+    }
+    async repair(options) {
         await withStateLock(this.poolDir, async () => {
             const state = await readState(this.poolDir);
-            const remove = new Set();
-            for (const wt of worktrees) {
-                const idx = state.worktrees.findIndex((s) => s.path === wt.path);
-                if (idx === -1 || !sameDestroyReservation(state.worktrees[idx], wt)) {
-                    continue;
+            const wt = state.worktrees.find(w => w.leaseId === options.leaseId);
+            if (!wt)
+                throw new LeaseNotFoundError(`Lease ${options.leaseId} not found`);
+            const { inUse, unverified } = await isWorktreeInUse(wt.path);
+            const alive = await ownerAlive(wt);
+            if (options.action === "force-destroy") {
+                if (!options.force && (inUse || alive || unverified)) {
+                    throw new UnsafeCleanupError("Cannot force-destroy: processes running or unverified. Use force: true");
                 }
-                remove.add(wt.path);
-                try {
-                    await removeWorktree(this.config.repoRoot, wt.path);
-                }
-                catch { }
-                assertPathWithinPool(this.poolDir, wt.path);
-                try {
-                    await rm(dirname(wt.path), { recursive: true, force: true });
+            }
+            if (options.action === "quarantine") {
+                wt.state = "quarantined";
+                wt.pendingCleanup = undefined;
+                await writeState(this.poolDir, state);
+                return;
+            }
+            if (options.action === "resume-cleanup") {
+                if (!wt.pendingCleanup) {
+                    throw new UnsafeCleanupError("No pending cleanup to resume");
                 }
-                catch { }
+                // we will let the outside call handle it, just leave state as is
+            }
+            if (options.action === "force-destroy") {
+                // Handled by explicit call outside
             }
-            state.worktrees = state.worktrees.filter((wt) => !remove.has(wt.path));
-            await writeState(this.poolDir, state);
         });
+        if (options.action === "resume-cleanup") {
+            const wt = await this.inspect(options.leaseId);
+            if (wt?.pendingCleanup) {
+                return this.release(options.leaseId, wt.pendingCleanup);
+            }
+        }
+        if (options.action === "force-destroy") {
+            await this.destroy(options.leaseId, { force: true });
+            return;
+        }
+        const res = await this.inspect(options.leaseId);
+        if (!res)
+            throw new LeaseNotFoundError("Lease not found after repair");
+        return res;
+    }
+    async inspect(leaseIdOrPath) {
+        return inspectLease(leaseIdOrPath, this.poolDir, this.config);
+    }
+    async list(_options) {
+        return listWorktrees(this.poolDir);
+    }
+    async listLeases(_options) {
+        return listLeases(this.poolDir, this.config);
     }
     async findByPath(worktreePath) {
         const state = await readState(this.poolDir);
@@ -265,20 +463,35 @@ export class Grove {
         }
         return null;
     }
-}
-function sameDestroyReservation(current, reserved) {
-    return (current.path === reserved.path &&
-        current.destroying &&
-        current.owner_pid === reserved.owner_pid &&
-        current.owner_started_at === reserved.owner_started_at);
-}
-function cwdInWorktree(cwd, worktreePath) {
-    const rel = relative(worktreePath, cwd);
-    return !rel.startsWith("..") && !isAbsolute(rel);
-}
-function assertPathWithinPool(poolDir, targetPath) {
-    const rel = relative(poolDir, targetPath);
-    if (rel.startsWith("..") || isAbsolute(rel)) {
-        throw new Error("Security violation: target path is outside the pool boundary");
+    nextName(state) {
+        let max = 0;
+        for (const wt of state.worktrees) {
+            const n = parseInt(wt.name, 10);
+            if (!isNaN(n) && n > max) {
+                max = n;
+            }
+        }
+        return (max + 1).toString();
+    }
+    cwdInWorktree(cwd, worktreePath) {
+        const rel = relative(worktreePath, cwd);
+        return !rel.startsWith("..") && !isAbsolute(rel);
+    }
+    assertPathWithinPool(poolDir, targetPath) {
+        const rel = relative(poolDir, targetPath);
+        if (rel.startsWith("..") || isAbsolute(rel)) {
+            throw new PathOutsidePoolError("Security violation: target path is outside the pool boundary");
+        }
+    }
+    leaseEnv(lease) {
+        const e = {
+            GROVE_LEASE_ID: lease.leaseId,
+            GROVE_SLOT_NAME: lease.slotName,
+            GROVE_REPO_ROOT: lease.repoRoot,
+            GROVE_WORKTREE_PATH: lease.path,
+        };
+        if (lease.branch)
+            e.GROVE_BRANCH = lease.branch;
+        return e;
     }
 }