opencode-hive 0.8.0 → 0.8.2

package/dist/services/taskService.js

@@ -1,382 +0,0 @@
-import * as fs from 'fs';
-import { getTasksPath, getTaskPath, getTaskStatusPath, getTaskReportPath, getTaskSpecPath, getSubtasksPath, getSubtaskPath, getSubtaskStatusPath, getSubtaskSpecPath, getSubtaskReportPath, getPlanPath, ensureDir, readJson, writeJson, readText, writeText, fileExists, } from '../utils/paths.js';
-export class TaskService {
-    projectRoot;
-    constructor(projectRoot) {
-        this.projectRoot = projectRoot;
-    }
-    sync(featureName) {
-        const planPath = getPlanPath(this.projectRoot, featureName);
-        const planContent = readText(planPath);
-        if (!planContent) {
-            throw new Error(`No plan.md found for feature '${featureName}'`);
-        }
-        const planTasks = this.parseTasksFromPlan(planContent);
-        const existingTasks = this.list(featureName);
-        const result = {
-            created: [],
-            removed: [],
-            kept: [],
-            manual: [],
-        };
-        const existingByName = new Map(existingTasks.map(t => [t.folder, t]));
-        for (const existing of existingTasks) {
-            if (existing.origin === 'manual') {
-                result.manual.push(existing.folder);
-                continue;
-            }
-            if (existing.status === 'done' || existing.status === 'in_progress') {
-                result.kept.push(existing.folder);
-                continue;
-            }
-            if (existing.status === 'cancelled') {
-                this.deleteTask(featureName, existing.folder);
-                result.removed.push(existing.folder);
-                continue;
-            }
-            const stillInPlan = planTasks.some(p => p.folder === existing.folder);
-            if (!stillInPlan) {
-                this.deleteTask(featureName, existing.folder);
-                result.removed.push(existing.folder);
-            }
-            else {
-                result.kept.push(existing.folder);
-            }
-        }
-        for (const planTask of planTasks) {
-            if (!existingByName.has(planTask.folder)) {
-                this.createFromPlan(featureName, planTask, planTasks);
-                result.created.push(planTask.folder);
-            }
-        }
-        return result;
-    }
-    create(featureName, name, order) {
-        const tasksPath = getTasksPath(this.projectRoot, featureName);
-        const existingFolders = this.listFolders(featureName);
-        const nextOrder = order ?? this.getNextOrder(existingFolders);
-        const folder = `${String(nextOrder).padStart(2, '0')}-${name}`;
-        const taskPath = getTaskPath(this.projectRoot, featureName, folder);
-        ensureDir(taskPath);
-        const status = {
-            status: 'pending',
-            origin: 'manual',
-        };
-        writeJson(getTaskStatusPath(this.projectRoot, featureName, folder), status);
-        return folder;
-    }
-    createFromPlan(featureName, task, allTasks) {
-        const taskPath = getTaskPath(this.projectRoot, featureName, task.folder);
-        ensureDir(taskPath);
-        const status = {
-            status: 'pending',
-            origin: 'plan',
-        };
-        writeJson(getTaskStatusPath(this.projectRoot, featureName, task.folder), status);
-        // Write enhanced spec.md with full context
-        const specLines = [
-            `# Task ${task.order}: ${task.name}`,
-            '',
-            `**Feature:** ${featureName}`,
-            `**Folder:** ${task.folder}`,
-            `**Status:** pending`,
-            '',
-            '---',
-            '',
-            '## Description',
-            '',
-            task.description || '_No description provided in plan_',
-            '',
-        ];
-        // Add prior tasks section if not first task
-        if (task.order > 1) {
-            const priorTasks = allTasks.filter(t => t.order < task.order);
-            if (priorTasks.length > 0) {
-                specLines.push('---', '', '## Prior Tasks', '');
-                for (const prior of priorTasks) {
-                    specLines.push(`- **${prior.order}. ${prior.name}** (${prior.folder})`);
-                }
-                specLines.push('');
-            }
-        }
-        // Add next tasks section if not last task
-        const nextTasks = allTasks.filter(t => t.order > task.order);
-        if (nextTasks.length > 0) {
-            specLines.push('---', '', '## Upcoming Tasks', '');
-            for (const next of nextTasks) {
-                specLines.push(`- **${next.order}. ${next.name}** (${next.folder})`);
-            }
-            specLines.push('');
-        }
-        writeText(getTaskSpecPath(this.projectRoot, featureName, task.folder), specLines.join('\n'));
-    }
-    writeSpec(featureName, taskFolder, content) {
-        const specPath = getTaskSpecPath(this.projectRoot, featureName, taskFolder);
-        writeText(specPath, content);
-        return specPath;
-    }
-    update(featureName, taskFolder, updates) {
-        const statusPath = getTaskStatusPath(this.projectRoot, featureName, taskFolder);
-        const current = readJson(statusPath);
-        if (!current) {
-            throw new Error(`Task '${taskFolder}' not found`);
-        }
-        const updated = {
-            ...current,
-            ...updates,
-        };
-        if (updates.status === 'in_progress' && !current.startedAt) {
-            updated.startedAt = new Date().toISOString();
-        }
-        if (updates.status === 'done' && !current.completedAt) {
-            updated.completedAt = new Date().toISOString();
-        }
-        writeJson(statusPath, updated);
-        return updated;
-    }
-    get(featureName, taskFolder) {
-        const statusPath = getTaskStatusPath(this.projectRoot, featureName, taskFolder);
-        const status = readJson(statusPath);
-        if (!status)
-            return null;
-        return {
-            folder: taskFolder,
-            name: taskFolder.replace(/^\d+-/, ''),
-            status: status.status,
-            origin: status.origin,
-            summary: status.summary,
-        };
-    }
-    list(featureName) {
-        const folders = this.listFolders(featureName);
-        return folders
-            .map(folder => this.get(featureName, folder))
-            .filter((t) => t !== null);
-    }
-    writeReport(featureName, taskFolder, report) {
-        const reportPath = getTaskReportPath(this.projectRoot, featureName, taskFolder);
-        writeText(reportPath, report);
-        return reportPath;
-    }
-    listFolders(featureName) {
-        const tasksPath = getTasksPath(this.projectRoot, featureName);
-        if (!fileExists(tasksPath))
-            return [];
-        return fs.readdirSync(tasksPath, { withFileTypes: true })
-            .filter(d => d.isDirectory())
-            .map(d => d.name)
-            .sort();
-    }
-    deleteTask(featureName, taskFolder) {
-        const taskPath = getTaskPath(this.projectRoot, featureName, taskFolder);
-        if (fileExists(taskPath)) {
-            fs.rmSync(taskPath, { recursive: true });
-        }
-    }
-    getNextOrder(existingFolders) {
-        if (existingFolders.length === 0)
-            return 1;
-        const orders = existingFolders
-            .map(f => parseInt(f.split('-')[0], 10))
-            .filter(n => !isNaN(n));
-        return Math.max(...orders, 0) + 1;
-    }
-    parseTasksFromPlan(content) {
-        const tasks = [];
-        const lines = content.split('\n');
-        let currentTask = null;
-        let descriptionLines = [];
-        for (const line of lines) {
-            // Check for task header: ### N. Task Name
-            const taskMatch = line.match(/^###\s+(\d+)\.\s+(.+)$/);
-            if (taskMatch) {
-                // Save previous task if exists
-                if (currentTask) {
-                    currentTask.description = descriptionLines.join('\n').trim();
-                    tasks.push(currentTask);
-                }
-                const order = parseInt(taskMatch[1], 10);
-                const rawName = taskMatch[2].trim();
-                const folderName = rawName.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
-                const folder = `${String(order).padStart(2, '0')}-${folderName}`;
-                currentTask = {
-                    folder,
-                    order,
-                    name: rawName,
-                    description: '',
-                };
-                descriptionLines = [];
-            }
-            else if (currentTask) {
-                // Check for end of task section (next ## header or ### without number)
-                if (line.match(/^##\s+/) || line.match(/^###\s+[^0-9]/)) {
-                    currentTask.description = descriptionLines.join('\n').trim();
-                    tasks.push(currentTask);
-                    currentTask = null;
-                    descriptionLines = [];
-                }
-                else {
-                    descriptionLines.push(line);
-                }
-            }
-        }
-        // Don't forget the last task
-        if (currentTask) {
-            currentTask.description = descriptionLines.join('\n').trim();
-            tasks.push(currentTask);
-        }
-        return tasks;
-    }
-    createSubtask(featureName, taskFolder, name, type) {
-        const subtasksPath = getSubtasksPath(this.projectRoot, featureName, taskFolder);
-        ensureDir(subtasksPath);
-        const existingFolders = this.listSubtaskFolders(featureName, taskFolder);
-        const taskOrder = parseInt(taskFolder.split('-')[0], 10);
-        const nextOrder = existingFolders.length + 1;
-        const subtaskId = `${taskOrder}.${nextOrder}`;
-        const folderName = `${nextOrder}-${this.slugify(name)}`;
-        const subtaskPath = getSubtaskPath(this.projectRoot, featureName, taskFolder, folderName);
-        ensureDir(subtaskPath);
-        const subtaskStatus = {
-            status: 'pending',
-            type,
-            createdAt: new Date().toISOString(),
-        };
-        writeJson(getSubtaskStatusPath(this.projectRoot, featureName, taskFolder, folderName), subtaskStatus);
-        const specContent = `# Subtask: ${name}\n\n**Type:** ${type || 'custom'}\n**ID:** ${subtaskId}\n\n## Instructions\n\n_Add detailed instructions here_\n`;
-        writeText(getSubtaskSpecPath(this.projectRoot, featureName, taskFolder, folderName), specContent);
-        return {
-            id: subtaskId,
-            name,
-            folder: folderName,
-            status: 'pending',
-            type,
-            createdAt: subtaskStatus.createdAt,
-        };
-    }
-    updateSubtask(featureName, taskFolder, subtaskId, status) {
-        const subtaskFolder = this.findSubtaskFolder(featureName, taskFolder, subtaskId);
-        if (!subtaskFolder) {
-            throw new Error(`Subtask '${subtaskId}' not found in task '${taskFolder}'`);
-        }
-        const statusPath = getSubtaskStatusPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-        const current = readJson(statusPath);
-        if (!current) {
-            throw new Error(`Subtask status not found for '${subtaskId}'`);
-        }
-        const updated = { ...current, status };
-        if (status === 'done' && !current.completedAt) {
-            updated.completedAt = new Date().toISOString();
-        }
-        writeJson(statusPath, updated);
-        const name = subtaskFolder.replace(/^\d+-/, '');
-        return {
-            id: subtaskId,
-            name,
-            folder: subtaskFolder,
-            status,
-            type: current.type,
-            createdAt: current.createdAt,
-            completedAt: updated.completedAt,
-        };
-    }
-    listSubtasks(featureName, taskFolder) {
-        const folders = this.listSubtaskFolders(featureName, taskFolder);
-        const taskOrder = parseInt(taskFolder.split('-')[0], 10);
-        return folders.map((folder, index) => {
-            const statusPath = getSubtaskStatusPath(this.projectRoot, featureName, taskFolder, folder);
-            const status = readJson(statusPath);
-            const name = folder.replace(/^\d+-/, '');
-            const subtaskOrder = parseInt(folder.split('-')[0], 10) || (index + 1);
-            return {
-                id: `${taskOrder}.${subtaskOrder}`,
-                name,
-                folder,
-                status: status?.status || 'pending',
-                type: status?.type,
-                createdAt: status?.createdAt,
-                completedAt: status?.completedAt,
-            };
-        });
-    }
-    deleteSubtask(featureName, taskFolder, subtaskId) {
-        const subtaskFolder = this.findSubtaskFolder(featureName, taskFolder, subtaskId);
-        if (!subtaskFolder) {
-            throw new Error(`Subtask '${subtaskId}' not found in task '${taskFolder}'`);
-        }
-        const subtaskPath = getSubtaskPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-        if (fileExists(subtaskPath)) {
-            fs.rmSync(subtaskPath, { recursive: true });
-        }
-    }
-    getSubtask(featureName, taskFolder, subtaskId) {
-        const subtaskFolder = this.findSubtaskFolder(featureName, taskFolder, subtaskId);
-        if (!subtaskFolder)
-            return null;
-        const statusPath = getSubtaskStatusPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-        const status = readJson(statusPath);
-        if (!status)
-            return null;
-        const taskOrder = parseInt(taskFolder.split('-')[0], 10);
-        const subtaskOrder = parseInt(subtaskFolder.split('-')[0], 10);
-        const name = subtaskFolder.replace(/^\d+-/, '');
-        return {
-            id: `${taskOrder}.${subtaskOrder}`,
-            name,
-            folder: subtaskFolder,
-            status: status.status,
-            type: status.type,
-            createdAt: status.createdAt,
-            completedAt: status.completedAt,
-        };
-    }
-    writeSubtaskSpec(featureName, taskFolder, subtaskId, content) {
-        const subtaskFolder = this.findSubtaskFolder(featureName, taskFolder, subtaskId);
-        if (!subtaskFolder) {
-            throw new Error(`Subtask '${subtaskId}' not found in task '${taskFolder}'`);
-        }
-        const specPath = getSubtaskSpecPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-        writeText(specPath, content);
-        return specPath;
-    }
-    writeSubtaskReport(featureName, taskFolder, subtaskId, content) {
-        const subtaskFolder = this.findSubtaskFolder(featureName, taskFolder, subtaskId);
-        if (!subtaskFolder) {
-            throw new Error(`Subtask '${subtaskId}' not found in task '${taskFolder}'`);
-        }
-        const reportPath = getSubtaskReportPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-        writeText(reportPath, content);
-        return reportPath;
-    }
-    readSubtaskSpec(featureName, taskFolder, subtaskId) {
-        const subtaskFolder = this.findSubtaskFolder(featureName, taskFolder, subtaskId);
-        if (!subtaskFolder)
-            return null;
-        const specPath = getSubtaskSpecPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-        return readText(specPath);
-    }
-    readSubtaskReport(featureName, taskFolder, subtaskId) {
-        const subtaskFolder = this.findSubtaskFolder(featureName, taskFolder, subtaskId);
-        if (!subtaskFolder)
-            return null;
-        const reportPath = getSubtaskReportPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-        return readText(reportPath);
-    }
-    listSubtaskFolders(featureName, taskFolder) {
-        const subtasksPath = getSubtasksPath(this.projectRoot, featureName, taskFolder);
-        if (!fileExists(subtasksPath))
-            return [];
-        return fs.readdirSync(subtasksPath, { withFileTypes: true })
-            .filter(d => d.isDirectory())
-            .map(d => d.name)
-            .sort();
-    }
-    findSubtaskFolder(featureName, taskFolder, subtaskId) {
-        const folders = this.listSubtaskFolders(featureName, taskFolder);
-        const subtaskOrder = subtaskId.split('.')[1];
-        return folders.find(f => f.startsWith(`${subtaskOrder}-`)) || null;
-    }
-    slugify(name) {
-        return name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
-    }
-}

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

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

package/dist/services/taskService.test.js

@@ -1,290 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import { TaskService } from "./taskService";
-import { FeatureService } from "./featureService";
-import { PlanService } from "./planService";
-import { getTaskPath, getTaskStatusPath, getTaskReportPath, getSubtaskPath, getSubtaskStatusPath, getSubtaskSpecPath } from "../utils/paths";
-const TEST_ROOT = "/tmp/hive-test-task";
-describe("TaskService", () => {
-    let taskService;
-    let featureService;
-    let planService;
-    beforeEach(() => {
-        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
-        fs.mkdirSync(TEST_ROOT, { recursive: true });
-        featureService = new FeatureService(TEST_ROOT);
-        planService = new PlanService(TEST_ROOT);
-        taskService = new TaskService(TEST_ROOT);
-        featureService.create("test-feature");
-    });
-    afterEach(() => {
-        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
-    });
-    describe("sync", () => {
-        it("throws when no plan exists", () => {
-            featureService.create("no-plan");
-            expect(() => taskService.sync("no-plan")).toThrow();
-        });
-        it("creates tasks from plan", () => {
-            planService.write("test-feature", `# Plan
-
-## Tasks
-
-### 1. Setup Database
-Description
-
-### 2. Create API
-Description
-`);
-            const result = taskService.sync("test-feature");
-            expect(result.created).toContain("01-setup-database");
-            expect(result.created).toContain("02-create-api");
-            expect(result.created.length).toBe(2);
-        });
-        it("keeps done tasks even if removed from plan", () => {
-            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. First Task\nDesc`);
-            taskService.sync("test-feature");
-            taskService.update("test-feature", "01-first-task", { status: "done" });
-            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. Different Task\nDesc`);
-            const result = taskService.sync("test-feature");
-            expect(result.kept).toContain("01-first-task");
-        });
-        it("removes cancelled tasks", () => {
-            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. Task One\nDesc`);
-            taskService.sync("test-feature");
-            taskService.update("test-feature", "01-task-one", { status: "cancelled" });
-            const result = taskService.sync("test-feature");
-            expect(result.removed).toContain("01-task-one");
-        });
-        it("preserves manual tasks", () => {
-            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. Plan Task\nDesc`);
-            taskService.sync("test-feature");
-            taskService.create("test-feature", "manual-task");
-            const result = taskService.sync("test-feature");
-            expect(result.manual).toContain("02-manual-task");
-        });
-    });
-    describe("create", () => {
-        it("creates a manual task", () => {
-            const folder = taskService.create("test-feature", "my-task");
-            expect(folder).toBe("01-my-task");
-            expect(fs.existsSync(getTaskPath(TEST_ROOT, "test-feature", folder))).toBe(true);
-        });
-        it("auto-increments order", () => {
-            taskService.create("test-feature", "first");
-            taskService.create("test-feature", "second");
-            const third = taskService.create("test-feature", "third");
-            expect(third).toBe("03-third");
-        });
-        it("respects explicit order", () => {
-            const folder = taskService.create("test-feature", "specific", 10);
-            expect(folder).toBe("10-specific");
-        });
-        it("creates task with pending status and manual origin", () => {
-            const folder = taskService.create("test-feature", "test");
-            const task = taskService.get("test-feature", folder);
-            expect(task?.status).toBe("pending");
-            expect(task?.origin).toBe("manual");
-        });
-    });
-    describe("update", () => {
-        it("updates task status", () => {
-            const folder = taskService.create("test-feature", "task");
-            taskService.update("test-feature", folder, { status: "in_progress" });
-            const task = taskService.get("test-feature", folder);
-            expect(task?.status).toBe("in_progress");
-        });
-        it("sets startedAt when status becomes in_progress", () => {
-            const folder = taskService.create("test-feature", "task");
-            taskService.update("test-feature", folder, { status: "in_progress" });
-            const statusPath = getTaskStatusPath(TEST_ROOT, "test-feature", folder);
-            const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
-            expect(status.startedAt).toBeDefined();
-        });
-        it("sets completedAt when status becomes done", () => {
-            const folder = taskService.create("test-feature", "task");
-            taskService.update("test-feature", folder, { status: "done" });
-            const statusPath = getTaskStatusPath(TEST_ROOT, "test-feature", folder);
-            const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
-            expect(status.completedAt).toBeDefined();
-        });
-        it("updates summary", () => {
-            const folder = taskService.create("test-feature", "task");
-            taskService.update("test-feature", folder, { summary: "Completed setup" });
-            const task = taskService.get("test-feature", folder);
-            expect(task?.summary).toBe("Completed setup");
-        });
-        it("throws for non-existing task", () => {
-            expect(() => taskService.update("test-feature", "nope", { status: "done" })).toThrow();
-        });
-    });
-    describe("get", () => {
-        it("returns task info", () => {
-            const folder = taskService.create("test-feature", "my-task");
-            const task = taskService.get("test-feature", folder);
-            expect(task).not.toBeNull();
-            expect(task.folder).toBe("01-my-task");
-            expect(task.name).toBe("my-task");
-            expect(task.status).toBe("pending");
-            expect(task.origin).toBe("manual");
-        });
-        it("returns null for non-existing task", () => {
-            expect(taskService.get("test-feature", "nope")).toBeNull();
-        });
-    });
-    describe("list", () => {
-        it("returns empty array when no tasks", () => {
-            expect(taskService.list("test-feature")).toEqual([]);
-        });
-        it("returns all tasks sorted", () => {
-            taskService.create("test-feature", "third", 3);
-            taskService.create("test-feature", "first", 1);
-            taskService.create("test-feature", "second", 2);
-            const tasks = taskService.list("test-feature");
-            expect(tasks.length).toBe(3);
-            expect(tasks[0].folder).toBe("01-first");
-            expect(tasks[1].folder).toBe("02-second");
-            expect(tasks[2].folder).toBe("03-third");
-        });
-    });
-    describe("writeReport", () => {
-        it("writes report file", () => {
-            const folder = taskService.create("test-feature", "task");
-            const report = "## Summary\n\nCompleted the task successfully.";
-            taskService.writeReport("test-feature", folder, report);
-            const reportPath = getTaskReportPath(TEST_ROOT, "test-feature", folder);
-            expect(fs.readFileSync(reportPath, "utf-8")).toBe(report);
-        });
-    });
-    describe("subtasks", () => {
-        let taskFolder;
-        beforeEach(() => {
-            taskFolder = taskService.create("test-feature", "parent-task");
-        });
-        describe("createSubtask", () => {
-            it("creates subtask folder with status.json and spec.md", () => {
-                const subtask = taskService.createSubtask("test-feature", taskFolder, "Write tests", "test");
-                expect(subtask.id).toBe("1.1");
-                expect(subtask.name).toBe("Write tests");
-                expect(subtask.folder).toBe("1-write-tests");
-                expect(subtask.status).toBe("pending");
-                expect(subtask.type).toBe("test");
-                const subtaskPath = getSubtaskPath(TEST_ROOT, "test-feature", taskFolder, subtask.folder);
-                expect(fs.existsSync(subtaskPath)).toBe(true);
-                const statusPath = getSubtaskStatusPath(TEST_ROOT, "test-feature", taskFolder, subtask.folder);
-                expect(fs.existsSync(statusPath)).toBe(true);
-                const specPath = getSubtaskSpecPath(TEST_ROOT, "test-feature", taskFolder, subtask.folder);
-                expect(fs.existsSync(specPath)).toBe(true);
-                expect(fs.readFileSync(specPath, "utf-8")).toContain("Write tests");
-            });
-            it("auto-increments subtask order", () => {
-                const first = taskService.createSubtask("test-feature", taskFolder, "First", "test");
-                const second = taskService.createSubtask("test-feature", taskFolder, "Second", "implement");
-                const third = taskService.createSubtask("test-feature", taskFolder, "Third", "verify");
-                expect(first.id).toBe("1.1");
-                expect(second.id).toBe("1.2");
-                expect(third.id).toBe("1.3");
-            });
-        });
-        describe("listSubtasks", () => {
-            it("returns empty array when no subtasks", () => {
-                expect(taskService.listSubtasks("test-feature", taskFolder)).toEqual([]);
-            });
-            it("returns all subtasks sorted by order", () => {
-                taskService.createSubtask("test-feature", taskFolder, "Third", "verify");
-                taskService.createSubtask("test-feature", taskFolder, "First", "test");
-                const subtasks = taskService.listSubtasks("test-feature", taskFolder);
-                expect(subtasks.length).toBe(2);
-                expect(subtasks[0].folder).toBe("1-third");
-                expect(subtasks[1].folder).toBe("2-first");
-            });
-        });
-        describe("updateSubtask", () => {
-            it("updates subtask status", () => {
-                const subtask = taskService.createSubtask("test-feature", taskFolder, "Test", "test");
-                const updated = taskService.updateSubtask("test-feature", taskFolder, subtask.id, "in_progress");
-                expect(updated.status).toBe("in_progress");
-            });
-            it("sets completedAt when status becomes done", () => {
-                const subtask = taskService.createSubtask("test-feature", taskFolder, "Test", "test");
-                const updated = taskService.updateSubtask("test-feature", taskFolder, subtask.id, "done");
-                expect(updated.completedAt).toBeDefined();
-            });
-            it("throws for non-existing subtask", () => {
-                expect(() => taskService.updateSubtask("test-feature", taskFolder, "1.99", "done")).toThrow();
-            });
-        });
-        describe("deleteSubtask", () => {
-            it("removes subtask folder", () => {
-                const subtask = taskService.createSubtask("test-feature", taskFolder, "ToDelete", "test");
-                const subtaskPath = getSubtaskPath(TEST_ROOT, "test-feature", taskFolder, subtask.folder);
-                expect(fs.existsSync(subtaskPath)).toBe(true);
-                taskService.deleteSubtask("test-feature", taskFolder, subtask.id);
-                expect(fs.existsSync(subtaskPath)).toBe(false);
-            });
-            it("throws for non-existing subtask", () => {
-                expect(() => taskService.deleteSubtask("test-feature", taskFolder, "1.99")).toThrow();
-            });
-        });
-        describe("getSubtask", () => {
-            it("returns subtask info", () => {
-                const created = taskService.createSubtask("test-feature", taskFolder, "MySubtask", "implement");
-                const subtask = taskService.getSubtask("test-feature", taskFolder, created.id);
-                expect(subtask).not.toBeNull();
-                expect(subtask.id).toBe("1.1");
-                expect(subtask.name).toBe("mysubtask");
-                expect(subtask.folder).toBe("1-mysubtask");
-                expect(subtask.type).toBe("implement");
-            });
-            it("returns null for non-existing subtask", () => {
-                expect(taskService.getSubtask("test-feature", taskFolder, "1.99")).toBeNull();
-            });
-        });
-        describe("writeSubtaskSpec", () => {
-            it("writes spec.md content", () => {
-                const subtask = taskService.createSubtask("test-feature", taskFolder, "Test", "test");
-                const content = "# Custom Spec\n\nDetailed instructions here.";
-                const specPath = taskService.writeSubtaskSpec("test-feature", taskFolder, subtask.id, content);
-                expect(fs.readFileSync(specPath, "utf-8")).toBe(content);
-            });
-            it("throws for non-existing subtask", () => {
-                expect(() => taskService.writeSubtaskSpec("test-feature", taskFolder, "1.99", "content")).toThrow();
-            });
-        });
-        describe("writeSubtaskReport", () => {
-            it("writes report.md content", () => {
-                const subtask = taskService.createSubtask("test-feature", taskFolder, "Test", "test");
-                const content = "# Report\n\nCompleted successfully.";
-                const reportPath = taskService.writeSubtaskReport("test-feature", taskFolder, subtask.id, content);
-                expect(fs.readFileSync(reportPath, "utf-8")).toBe(content);
-            });
-            it("throws for non-existing subtask", () => {
-                expect(() => taskService.writeSubtaskReport("test-feature", taskFolder, "1.99", "content")).toThrow();
-            });
-        });
-        describe("readSubtaskSpec", () => {
-            it("reads spec.md content", () => {
-                const subtask = taskService.createSubtask("test-feature", taskFolder, "Test", "test");
-                const content = "Custom spec content";
-                taskService.writeSubtaskSpec("test-feature", taskFolder, subtask.id, content);
-                const spec = taskService.readSubtaskSpec("test-feature", taskFolder, subtask.id);
-                expect(spec).toBe(content);
-            });
-            it("returns null for non-existing subtask", () => {
-                expect(taskService.readSubtaskSpec("test-feature", taskFolder, "1.99")).toBeNull();
-            });
-        });
-        describe("readSubtaskReport", () => {
-            it("reads report.md content", () => {
-                const subtask = taskService.createSubtask("test-feature", taskFolder, "Test", "test");
-                const content = "Report content";
-                taskService.writeSubtaskReport("test-feature", taskFolder, subtask.id, content);
-                const report = taskService.readSubtaskReport("test-feature", taskFolder, subtask.id);
-                expect(report).toBe(content);
-            });
-            it("returns null for non-existing subtask", () => {
-                expect(taskService.readSubtaskReport("test-feature", taskFolder, "1.99")).toBeNull();
-            });
-        });
-    });
-});