opencode-hive 0.6.0 → 0.8.1

package/dist/services/worktreeService.js

@@ -1,498 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import simpleGit from "simple-git";
-export class WorktreeService {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    getGit(cwd) {
-        return simpleGit(cwd || this.config.baseDir);
-    }
-    getWorktreesDir() {
-        return path.join(this.config.hiveDir, ".worktrees");
-    }
-    getWorktreePath(feature, step) {
-        return path.join(this.getWorktreesDir(), feature, step);
-    }
-    async getStepStatusPath(feature, step) {
-        const featurePath = path.join(this.config.hiveDir, "features", feature);
-        // Check v2 structure first (tasks/)
-        const tasksPath = path.join(featurePath, "tasks", step, "status.json");
-        try {
-            await fs.access(tasksPath);
-            return tasksPath;
-        }
-        catch { }
-        // Fall back to v1 structure (execution/)
-        return path.join(featurePath, "execution", step, "status.json");
-    }
-    getBranchName(feature, step) {
-        return `hive/${feature}/${step}`;
-    }
-    async create(feature, step, baseBranch) {
-        const worktreePath = this.getWorktreePath(feature, step);
-        const branchName = this.getBranchName(feature, step);
-        const git = this.getGit();
-        await fs.mkdir(path.dirname(worktreePath), { recursive: true });
-        const base = baseBranch || (await git.revparse(["HEAD"])).trim();
-        const existing = await this.get(feature, step);
-        if (existing) {
-            return existing;
-        }
-        try {
-            await git.raw(["worktree", "add", "-b", branchName, worktreePath, base]);
-        }
-        catch {
-            try {
-                await git.raw(["worktree", "add", worktreePath, branchName]);
-            }
-            catch (retryError) {
-                throw new Error(`Failed to create worktree: ${retryError}`);
-            }
-        }
-        const worktreeGit = this.getGit(worktreePath);
-        const commit = (await worktreeGit.revparse(["HEAD"])).trim();
-        return {
-            path: worktreePath,
-            branch: branchName,
-            commit,
-            feature,
-            step,
-        };
-    }
-    async get(feature, step) {
-        const worktreePath = this.getWorktreePath(feature, step);
-        const branchName = this.getBranchName(feature, step);
-        try {
-            await fs.access(worktreePath);
-            const worktreeGit = this.getGit(worktreePath);
-            const commit = (await worktreeGit.revparse(["HEAD"])).trim();
-            return {
-                path: worktreePath,
-                branch: branchName,
-                commit,
-                feature,
-                step,
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    async getDiff(feature, step, baseCommit) {
-        const worktreePath = this.getWorktreePath(feature, step);
-        const statusPath = await this.getStepStatusPath(feature, step);
-        let base = baseCommit;
-        if (!base) {
-            try {
-                const status = JSON.parse(await fs.readFile(statusPath, "utf-8"));
-                base = status.baseCommit; // Read baseCommit directly from task status
-            }
-            catch { }
-        }
-        if (!base) {
-            base = "HEAD~1";
-        }
-        const worktreeGit = this.getGit(worktreePath);
-        try {
-            await worktreeGit.raw(["add", "-A"]);
-            const status = await worktreeGit.status();
-            const hasStaged = status.staged.length > 0;
-            let diffContent = "";
-            let stat = "";
-            if (hasStaged) {
-                diffContent = await worktreeGit.diff(["--cached"]);
-                stat = diffContent ? await worktreeGit.diff(["--cached", "--stat"]) : "";
-            }
-            else {
-                diffContent = await worktreeGit.diff([`${base}..HEAD`]).catch(() => "");
-                stat = diffContent ? await worktreeGit.diff([`${base}..HEAD`, "--stat"]) : "";
-            }
-            const statLines = stat.split("\n").filter((l) => l.trim());
-            const filesChanged = statLines
-                .slice(0, -1)
-                .map((line) => line.split("|")[0].trim())
-                .filter(Boolean);
-            const summaryLine = statLines[statLines.length - 1] || "";
-            const insertMatch = summaryLine.match(/(\d+) insertion/);
-            const deleteMatch = summaryLine.match(/(\d+) deletion/);
-            return {
-                hasDiff: diffContent.length > 0,
-                diffContent,
-                filesChanged,
-                insertions: insertMatch ? parseInt(insertMatch[1], 10) : 0,
-                deletions: deleteMatch ? parseInt(deleteMatch[1], 10) : 0,
-            };
-        }
-        catch {
-            return {
-                hasDiff: false,
-                diffContent: "",
-                filesChanged: [],
-                insertions: 0,
-                deletions: 0,
-            };
-        }
-    }
-    async exportPatch(feature, step, baseBranch) {
-        const worktreePath = this.getWorktreePath(feature, step);
-        const patchPath = path.join(worktreePath, "..", `${step}.patch`);
-        const base = baseBranch || "HEAD~1";
-        const worktreeGit = this.getGit(worktreePath);
-        const diff = await worktreeGit.diff([`${base}...HEAD`]);
-        await fs.writeFile(patchPath, diff);
-        return patchPath;
-    }
-    async applyDiff(feature, step, baseBranch) {
-        const { hasDiff, diffContent, filesChanged } = await this.getDiff(feature, step, baseBranch);
-        if (!hasDiff) {
-            return { success: true, filesAffected: [] };
-        }
-        const patchPath = path.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
-        try {
-            await fs.writeFile(patchPath, diffContent);
-            const git = this.getGit();
-            await git.applyPatch(patchPath);
-            await fs.unlink(patchPath).catch(() => { });
-            return { success: true, filesAffected: filesChanged };
-        }
-        catch (error) {
-            await fs.unlink(patchPath).catch(() => { });
-            const err = error;
-            return {
-                success: false,
-                error: err.message || "Failed to apply patch",
-                filesAffected: [],
-            };
-        }
-    }
-    async revertDiff(feature, step, baseBranch) {
-        const { hasDiff, diffContent, filesChanged } = await this.getDiff(feature, step, baseBranch);
-        if (!hasDiff) {
-            return { success: true, filesAffected: [] };
-        }
-        const patchPath = path.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
-        try {
-            await fs.writeFile(patchPath, diffContent);
-            const git = this.getGit();
-            await git.applyPatch(patchPath, ["-R"]);
-            await fs.unlink(patchPath).catch(() => { });
-            return { success: true, filesAffected: filesChanged };
-        }
-        catch (error) {
-            await fs.unlink(patchPath).catch(() => { });
-            const err = error;
-            return {
-                success: false,
-                error: err.message || "Failed to revert patch",
-                filesAffected: [],
-            };
-        }
-    }
-    parseFilesFromDiff(diffContent) {
-        const files = [];
-        const regex = /^diff --git a\/(.+?) b\//gm;
-        let match;
-        while ((match = regex.exec(diffContent)) !== null) {
-            files.push(match[1]);
-        }
-        return [...new Set(files)];
-    }
-    async revertFromSavedDiff(diffPath) {
-        const diffContent = await fs.readFile(diffPath, "utf-8");
-        if (!diffContent.trim()) {
-            return { success: true, filesAffected: [] };
-        }
-        const filesChanged = this.parseFilesFromDiff(diffContent);
-        try {
-            const git = this.getGit();
-            await git.applyPatch(diffContent, ["-R"]);
-            return { success: true, filesAffected: filesChanged };
-        }
-        catch (error) {
-            const err = error;
-            return {
-                success: false,
-                error: err.message || "Failed to revert patch",
-                filesAffected: [],
-            };
-        }
-    }
-    async remove(feature, step, deleteBranch = false) {
-        const worktreePath = this.getWorktreePath(feature, step);
-        const branchName = this.getBranchName(feature, step);
-        const git = this.getGit();
-        try {
-            await git.raw(["worktree", "remove", worktreePath, "--force"]);
-        }
-        catch {
-            await fs.rm(worktreePath, { recursive: true, force: true });
-        }
-        try {
-            await git.raw(["worktree", "prune"]);
-        }
-        catch {
-            /* intentional */
-        }
-        if (deleteBranch) {
-            try {
-                await git.deleteLocalBranch(branchName, true);
-            }
-            catch {
-                /* intentional */
-            }
-        }
-    }
-    async list(feature) {
-        const worktreesDir = this.getWorktreesDir();
-        const results = [];
-        try {
-            const features = feature ? [feature] : await fs.readdir(worktreesDir);
-            for (const feat of features) {
-                const featurePath = path.join(worktreesDir, feat);
-                const stat = await fs.stat(featurePath).catch(() => null);
-                if (!stat?.isDirectory())
-                    continue;
-                const steps = await fs.readdir(featurePath).catch(() => []);
-                for (const step of steps) {
-                    const info = await this.get(feat, step);
-                    if (info) {
-                        results.push(info);
-                    }
-                }
-            }
-        }
-        catch {
-            /* intentional */
-        }
-        return results;
-    }
-    async cleanup(feature) {
-        const removed = [];
-        const git = this.getGit();
-        try {
-            await git.raw(["worktree", "prune"]);
-        }
-        catch {
-            /* intentional */
-        }
-        const worktreesDir = this.getWorktreesDir();
-        const features = feature ? [feature] : await fs.readdir(worktreesDir).catch(() => []);
-        for (const feat of features) {
-            const featurePath = path.join(worktreesDir, feat);
-            const stat = await fs.stat(featurePath).catch(() => null);
-            if (!stat?.isDirectory())
-                continue;
-            const steps = await fs.readdir(featurePath).catch(() => []);
-            for (const step of steps) {
-                const worktreePath = path.join(featurePath, step);
-                const stepStat = await fs.stat(worktreePath).catch(() => null);
-                if (!stepStat?.isDirectory())
-                    continue;
-                try {
-                    const worktreeGit = this.getGit(worktreePath);
-                    await worktreeGit.revparse(["HEAD"]);
-                }
-                catch {
-                    await this.remove(feat, step, false);
-                    removed.push(worktreePath);
-                }
-            }
-        }
-        return { removed, pruned: true };
-    }
-    async checkConflicts(feature, step, baseBranch) {
-        const { hasDiff, diffContent } = await this.getDiff(feature, step, baseBranch);
-        if (!hasDiff) {
-            return [];
-        }
-        const patchPath = path.join(this.config.hiveDir, ".worktrees", feature, `${step}-check.patch`);
-        try {
-            await fs.writeFile(patchPath, diffContent);
-            const git = this.getGit();
-            await git.applyPatch(patchPath, ["--check"]);
-            await fs.unlink(patchPath).catch(() => { });
-            return [];
-        }
-        catch (error) {
-            await fs.unlink(patchPath).catch(() => { });
-            const err = error;
-            const stderr = err.message || "";
-            const conflicts = stderr
-                .split("\n")
-                .filter((line) => line.includes("error: patch failed:"))
-                .map((line) => {
-                const match = line.match(/error: patch failed: (.+):/);
-                return match ? match[1] : null;
-            })
-                .filter((f) => f !== null);
-            return conflicts;
-        }
-    }
-    async checkConflictsFromSavedDiff(diffPath, reverse = false) {
-        try {
-            await fs.access(diffPath);
-        }
-        catch {
-            return [];
-        }
-        try {
-            const git = this.getGit();
-            const options = reverse ? ["--check", "-R"] : ["--check"];
-            await git.applyPatch(diffPath, options);
-            return [];
-        }
-        catch (error) {
-            const err = error;
-            const stderr = err.message || "";
-            const conflicts = stderr
-                .split("\n")
-                .filter((line) => line.includes("error: patch failed:"))
-                .map((line) => {
-                const match = line.match(/error: patch failed: (.+):/);
-                return match ? match[1] : null;
-            })
-                .filter((f) => f !== null);
-            return conflicts;
-        }
-    }
-    async commitChanges(feature, step, message) {
-        const worktreePath = this.getWorktreePath(feature, step);
-        try {
-            await fs.access(worktreePath);
-        }
-        catch {
-            return { committed: false, sha: "", message: "Worktree not found" };
-        }
-        const worktreeGit = this.getGit(worktreePath);
-        try {
-            await worktreeGit.add("-A");
-            const status = await worktreeGit.status();
-            const hasChanges = status.staged.length > 0 || status.modified.length > 0 || status.not_added.length > 0;
-            if (!hasChanges) {
-                const currentSha = (await worktreeGit.revparse(["HEAD"])).trim();
-                return { committed: false, sha: currentSha, message: "No changes to commit" };
-            }
-            const commitMessage = message || `hive(${step}): task changes`;
-            const result = await worktreeGit.commit(commitMessage, ["--allow-empty-message"]);
-            return {
-                committed: true,
-                sha: result.commit,
-                message: commitMessage,
-            };
-        }
-        catch (error) {
-            const err = error;
-            const currentSha = (await worktreeGit.revparse(["HEAD"]).catch(() => "")).trim();
-            return {
-                committed: false,
-                sha: currentSha,
-                message: err.message || "Commit failed",
-            };
-        }
-    }
-    async merge(feature, step, strategy = 'merge') {
-        const branchName = this.getBranchName(feature, step);
-        const git = this.getGit();
-        try {
-            const branches = await git.branch();
-            if (!branches.all.includes(branchName)) {
-                return { success: false, merged: false, error: `Branch ${branchName} not found` };
-            }
-            const currentBranch = branches.current;
-            const diffStat = await git.diff([`${currentBranch}...${branchName}`, "--stat"]);
-            const filesChanged = diffStat
-                .split("\n")
-                .filter(l => l.trim() && l.includes("|"))
-                .map(l => l.split("|")[0].trim());
-            if (strategy === 'squash') {
-                await git.raw(["merge", "--squash", branchName]);
-                const result = await git.commit(`hive: merge ${step} (squashed)`);
-                return {
-                    success: true,
-                    merged: true,
-                    sha: result.commit,
-                    filesChanged,
-                };
-            }
-            else if (strategy === 'rebase') {
-                const commits = await git.log([`${currentBranch}..${branchName}`]);
-                const commitsToApply = [...commits.all].reverse();
-                for (const commit of commitsToApply) {
-                    await git.raw(["cherry-pick", commit.hash]);
-                }
-                const head = (await git.revparse(["HEAD"])).trim();
-                return {
-                    success: true,
-                    merged: true,
-                    sha: head,
-                    filesChanged,
-                };
-            }
-            else {
-                const result = await git.merge([branchName, "--no-ff", "-m", `hive: merge ${step}`]);
-                const head = (await git.revparse(["HEAD"])).trim();
-                return {
-                    success: true,
-                    merged: !result.failed,
-                    sha: head,
-                    filesChanged,
-                    conflicts: result.conflicts?.map(c => c.file || String(c)) || [],
-                };
-            }
-        }
-        catch (error) {
-            const err = error;
-            if (err.message?.includes("CONFLICT") || err.message?.includes("conflict")) {
-                await git.raw(["merge", "--abort"]).catch(() => { });
-                await git.raw(["rebase", "--abort"]).catch(() => { });
-                await git.raw(["cherry-pick", "--abort"]).catch(() => { });
-                return {
-                    success: false,
-                    merged: false,
-                    error: "Merge conflicts detected",
-                    conflicts: this.parseConflictsFromError(err.message || ""),
-                };
-            }
-            return {
-                success: false,
-                merged: false,
-                error: err.message || "Merge failed",
-            };
-        }
-    }
-    async hasUncommittedChanges(feature, step) {
-        const worktreePath = this.getWorktreePath(feature, step);
-        try {
-            const worktreeGit = this.getGit(worktreePath);
-            const status = await worktreeGit.status();
-            return status.modified.length > 0 ||
-                status.not_added.length > 0 ||
-                status.staged.length > 0 ||
-                status.deleted.length > 0 ||
-                status.created.length > 0;
-        }
-        catch {
-            return false;
-        }
-    }
-    parseConflictsFromError(errorMessage) {
-        const conflicts = [];
-        const lines = errorMessage.split("\n");
-        for (const line of lines) {
-            if (line.includes("CONFLICT") && line.includes("Merge conflict in")) {
-                const match = line.match(/Merge conflict in (.+)/);
-                if (match)
-                    conflicts.push(match[1]);
-            }
-        }
-        return conflicts;
-    }
-}
-export function createWorktreeService(projectDir) {
-    return new WorktreeService({
-        baseDir: projectDir,
-        hiveDir: path.join(projectDir, ".hive"),
-    });
-}

package/dist/services/worktreeService.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/services/worktreeService.test.js

@@ -1,185 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import * as path from "path";
-import { WorktreeService } from "./worktreeService";
-const TEST_ROOT = "/tmp/hive-test-worktree";
-describe("WorktreeService", () => {
-    let service;
-    beforeEach(async () => {
-        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
-        fs.mkdirSync(TEST_ROOT, { recursive: true });
-        const { execSync } = await import("child_process");
-        execSync("git init", { cwd: TEST_ROOT });
-        execSync("git config user.email 'test@test.com'", { cwd: TEST_ROOT });
-        execSync("git config user.name 'Test'", { cwd: TEST_ROOT });
-        fs.writeFileSync(path.join(TEST_ROOT, "README.md"), "# Test");
-        execSync("git add . && git commit -m 'init'", { cwd: TEST_ROOT });
-        service = new WorktreeService({ baseDir: TEST_ROOT, hiveDir: path.join(TEST_ROOT, ".hive") });
-    });
-    afterEach(() => {
-        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
-    });
-    describe("create", () => {
-        it("creates a worktree", async () => {
-            const result = await service.create("my-feature", "01-setup");
-            expect(result.path).toContain(".hive/.worktrees/my-feature/01-setup");
-            expect(result.branch).toBe("hive/my-feature/01-setup");
-            expect(fs.existsSync(result.path)).toBe(true);
-        });
-        it("worktree contains files from base branch", async () => {
-            const result = await service.create("my-feature", "01-setup");
-            expect(fs.existsSync(path.join(result.path, "README.md"))).toBe(true);
-        });
-    });
-    describe("get", () => {
-        it("returns null for non-existing worktree", async () => {
-            const result = await service.get("nope", "nope");
-            expect(result).toBeNull();
-        });
-        it("returns worktree info after creation", async () => {
-            await service.create("my-feature", "01-task");
-            const result = await service.get("my-feature", "01-task");
-            expect(result).not.toBeNull();
-            expect(result.feature).toBe("my-feature");
-            expect(result.step).toBe("01-task");
-        });
-    });
-    describe("list", () => {
-        it("returns empty array when no worktrees", async () => {
-            const result = await service.list();
-            expect(result).toEqual([]);
-        });
-        it("lists all worktrees", async () => {
-            await service.create("feature-a", "01-task");
-            await service.create("feature-b", "01-task");
-            const result = await service.list();
-            expect(result.length).toBe(2);
-        });
-        it("filters by feature", async () => {
-            await service.create("feature-a", "01-task");
-            await service.create("feature-a", "02-task");
-            await service.create("feature-b", "01-task");
-            const result = await service.list("feature-a");
-            expect(result.length).toBe(2);
-            expect(result.every(w => w.feature === "feature-a")).toBe(true);
-        });
-    });
-    describe("remove", () => {
-        it("removes worktree", async () => {
-            const created = await service.create("my-feature", "01-task");
-            expect(fs.existsSync(created.path)).toBe(true);
-            await service.remove("my-feature", "01-task");
-            expect(fs.existsSync(created.path)).toBe(false);
-        });
-        it("removes branch when deleteBranch is true", async () => {
-            await service.create("my-feature", "01-task");
-            const { execSync } = await import("child_process");
-            await service.remove("my-feature", "01-task", true);
-            const branches = execSync("git branch", { cwd: TEST_ROOT, encoding: "utf-8" });
-            expect(branches).not.toContain("hive/my-feature/01-task");
-        });
-    });
-    describe("getDiff", () => {
-        it("returns empty diff when no changes", async () => {
-            await service.create("my-feature", "01-task");
-            const diff = await service.getDiff("my-feature", "01-task");
-            expect(diff.hasDiff).toBe(false);
-            expect(diff.diffContent).toBe("");
-            expect(diff.filesChanged).toEqual([]);
-        });
-        it("returns diff when files changed and committed", async () => {
-            const worktree = await service.create("my-feature", "01-task");
-            fs.writeFileSync(path.join(worktree.path, "new-file.txt"), "content");
-            const { execSync } = await import("child_process");
-            execSync("git add .", { cwd: worktree.path });
-            execSync("git commit -m 'add file'", { cwd: worktree.path });
-            const diff = await service.getDiff("my-feature", "01-task");
-            expect(diff.hasDiff).toBe(true);
-            expect(diff.filesChanged).toContain("new-file.txt");
-        });
-        it("returns diff for uncommitted staged changes", async () => {
-            const worktree = await service.create("my-feature", "01-task");
-            fs.writeFileSync(path.join(worktree.path, "uncommitted.txt"), "staged content");
-            const diff = await service.getDiff("my-feature", "01-task");
-            expect(diff.hasDiff).toBe(true);
-            expect(diff.filesChanged).toContain("uncommitted.txt");
-        });
-    });
-    describe("commitChanges", () => {
-        it("commits all staged changes", async () => {
-            const worktree = await service.create("my-feature", "01-task");
-            fs.writeFileSync(path.join(worktree.path, "file.txt"), "content");
-            const result = await service.commitChanges("my-feature", "01-task", "test commit");
-            expect(result.committed).toBe(true);
-            expect(result.sha).toBeTruthy();
-        });
-        it("returns committed=false when no changes", async () => {
-            await service.create("my-feature", "01-task");
-            const result = await service.commitChanges("my-feature", "01-task");
-            expect(result.committed).toBe(false);
-            expect(result.message).toBe("No changes to commit");
-        });
-        it("returns error when worktree not found", async () => {
-            const result = await service.commitChanges("nope", "nope");
-            expect(result.committed).toBe(false);
-            expect(result.message).toBe("Worktree not found");
-        });
-    });
-    describe("hasUncommittedChanges", () => {
-        it("returns false when no changes", async () => {
-            await service.create("my-feature", "01-task");
-            const result = await service.hasUncommittedChanges("my-feature", "01-task");
-            expect(result).toBe(false);
-        });
-        it("returns true when files modified", async () => {
-            const worktree = await service.create("my-feature", "01-task");
-            fs.writeFileSync(path.join(worktree.path, "new.txt"), "content");
-            const result = await service.hasUncommittedChanges("my-feature", "01-task");
-            expect(result).toBe(true);
-        });
-    });
-    describe("merge", () => {
-        it("merges task branch into main", async () => {
-            const worktree = await service.create("my-feature", "01-task");
-            fs.writeFileSync(path.join(worktree.path, "feature.txt"), "feature content");
-            const { execSync } = await import("child_process");
-            execSync("git add . && git commit -m 'feature'", { cwd: worktree.path });
-            const result = await service.merge("my-feature", "01-task");
-            expect(result.success).toBe(true);
-            expect(result.merged).toBe(true);
-            expect(fs.existsSync(path.join(TEST_ROOT, "feature.txt"))).toBe(true);
-        });
-        it("returns error for non-existent branch", async () => {
-            const result = await service.merge("nope", "nope");
-            expect(result.success).toBe(false);
-            expect(result.error).toContain("not found");
-        });
-        it("supports squash strategy", async () => {
-            const worktree = await service.create("my-feature", "01-task");
-            fs.writeFileSync(path.join(worktree.path, "file1.txt"), "1");
-            const { execSync } = await import("child_process");
-            execSync("git add . && git commit -m 'commit 1'", { cwd: worktree.path });
-            fs.writeFileSync(path.join(worktree.path, "file2.txt"), "2");
-            execSync("git add . && git commit -m 'commit 2'", { cwd: worktree.path });
-            const result = await service.merge("my-feature", "01-task", "squash");
-            expect(result.success).toBe(true);
-            expect(result.merged).toBe(true);
-        });
-    });
-    describe("cleanup", () => {
-        it("removes invalid worktrees for a feature", async () => {
-            const wt1 = await service.create("cleanup-test", "01-task");
-            const wt2 = await service.create("cleanup-test", "02-task");
-            fs.writeFileSync(path.join(wt1.path, ".git"), "gitdir: /nonexistent\n");
-            fs.writeFileSync(path.join(wt2.path, ".git"), "gitdir: /nonexistent\n");
-            expect(fs.existsSync(wt1.path)).toBe(true);
-            expect(fs.existsSync(wt2.path)).toBe(true);
-            const result = await service.cleanup("cleanup-test");
-            expect(result.removed.length).toBe(2);
-            expect(fs.existsSync(wt1.path)).toBe(false);
-            expect(fs.existsSync(wt2.path)).toBe(false);
-            const remaining = await service.list("cleanup-test");
-            expect(remaining).toEqual([]);
-        });
-    });
-});