opencode-hive 0.6.0 → 0.8.0

package/dist/index.js

@@ -12,13 +12,14 @@ const HIVE_SYSTEM_PROMPT = `
 
 Plan-first development: Write plan → User reviews → Approve → Execute tasks
 
-### Tools (17 total)
+### Tools (24 total)
 
 | Domain | Tools |
 |--------|-------|
 | Feature | hive_feature_create, hive_feature_list, hive_feature_complete |
 | Plan | hive_plan_write, hive_plan_read, hive_plan_approve |
 | Task | hive_tasks_sync, hive_task_create, hive_task_update |
+| Subtask | hive_subtask_create, hive_subtask_update, hive_subtask_list, hive_subtask_spec_write, hive_subtask_report_write |
 | Exec | hive_exec_start, hive_exec_complete, hive_exec_abort |
 | Merge | hive_merge, hive_worktree_list |
 | Context | hive_context_write, hive_context_read, hive_context_list |
@@ -37,6 +38,21 @@ Plan-first development: Write plan → User reviews → Approve → Execute task
 **Important:** \`hive_exec_complete\` commits changes to task branch but does NOT merge.
 Use \`hive_merge\` to explicitly integrate changes. Worktrees persist until manually removed.
 
+### Subtasks & TDD
+
+For complex tasks, break work into subtasks:
+
+\`\`\`
+hive_subtask_create(task, "Write failing tests", "test")
+hive_subtask_create(task, "Implement until green", "implement")
+hive_subtask_create(task, "Run test suite", "verify")
+\`\`\`
+
+Subtask types: test, implement, review, verify, research, debug, custom
+
+**Test-Driven Development**: For implementation tasks, consider writing tests first.
+Tests define "done" and provide feedback loops that improve quality.
+
 ### Plan Format
 
 \`\`\`markdown
@@ -529,6 +545,115 @@ const plugin = async (ctx) => {
                     }).join('\n');
                 },
             }),
+            hive_subtask_create: tool({
+                description: 'Create a subtask within a task. Use for TDD: create test/implement/verify subtasks.',
+                args: {
+                    task: tool.schema.string().describe('Task folder name'),
+                    name: tool.schema.string().describe('Subtask description'),
+                    type: tool.schema.enum(['test', 'implement', 'review', 'verify', 'research', 'debug', 'custom']).optional().describe('Subtask type'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ task, name, type, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    try {
+                        const subtask = taskService.createSubtask(feature, task, name, type);
+                        return `Subtask created: ${subtask.id} - ${subtask.name} [${subtask.type || 'custom'}]`;
+                    }
+                    catch (e) {
+                        return `Error: ${e.message}`;
+                    }
+                },
+            }),
+            hive_subtask_update: tool({
+                description: 'Update subtask status',
+                args: {
+                    task: tool.schema.string().describe('Task folder name'),
+                    subtask: tool.schema.string().describe('Subtask ID (e.g., "1.1")'),
+                    status: tool.schema.enum(['pending', 'in_progress', 'done', 'cancelled']).describe('New status'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ task, subtask, status, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    try {
+                        const updated = taskService.updateSubtask(feature, task, subtask, status);
+                        return `Subtask ${updated.id} updated: ${updated.status}`;
+                    }
+                    catch (e) {
+                        return `Error: ${e.message}`;
+                    }
+                },
+            }),
+            hive_subtask_list: tool({
+                description: 'List all subtasks for a task',
+                args: {
+                    task: tool.schema.string().describe('Task folder name'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ task, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    try {
+                        const subtasks = taskService.listSubtasks(feature, task);
+                        if (subtasks.length === 0)
+                            return "No subtasks for this task.";
+                        return subtasks.map(s => {
+                            const typeTag = s.type ? ` [${s.type}]` : '';
+                            const statusIcon = s.status === 'done' ? '✓' : s.status === 'in_progress' ? '→' : '○';
+                            return `${statusIcon} ${s.id}: ${s.name}${typeTag}`;
+                        }).join('\n');
+                    }
+                    catch (e) {
+                        return `Error: ${e.message}`;
+                    }
+                },
+            }),
+            hive_subtask_spec_write: tool({
+                description: 'Write spec.md for a subtask (detailed instructions)',
+                args: {
+                    task: tool.schema.string().describe('Task folder name'),
+                    subtask: tool.schema.string().describe('Subtask ID (e.g., "1.1")'),
+                    content: tool.schema.string().describe('Spec content (markdown)'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ task, subtask, content, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    try {
+                        const specPath = taskService.writeSubtaskSpec(feature, task, subtask, content);
+                        return `Subtask spec written: ${specPath}`;
+                    }
+                    catch (e) {
+                        return `Error: ${e.message}`;
+                    }
+                },
+            }),
+            hive_subtask_report_write: tool({
+                description: 'Write report.md for a subtask (what was done)',
+                args: {
+                    task: tool.schema.string().describe('Task folder name'),
+                    subtask: tool.schema.string().describe('Subtask ID (e.g., "1.1")'),
+                    content: tool.schema.string().describe('Report content (markdown)'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ task, subtask, content, feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    try {
+                        const reportPath = taskService.writeSubtaskReport(feature, task, subtask, content);
+                        return `Subtask report written: ${reportPath}`;
+                    }
+                    catch (e) {
+                        return `Error: ${e.message}`;
+                    }
+                },
+            }),
         },
         command: {
             hive: {

package/dist/services/taskService.d.ts

@@ -1,4 +1,4 @@
-import { TaskStatus, TasksSyncResult, TaskInfo } from '../types.js';
+import { TaskStatus, TaskStatusType, TasksSyncResult, TaskInfo, Subtask, SubtaskType } from '../types.js';
 export declare class TaskService {
     private projectRoot;
     constructor(projectRoot: string);
@@ -14,4 +14,16 @@ export declare class TaskService {
     private deleteTask;
     private getNextOrder;
     private parseTasksFromPlan;
+    createSubtask(featureName: string, taskFolder: string, name: string, type?: SubtaskType): Subtask;
+    updateSubtask(featureName: string, taskFolder: string, subtaskId: string, status: TaskStatusType): Subtask;
+    listSubtasks(featureName: string, taskFolder: string): Subtask[];
+    deleteSubtask(featureName: string, taskFolder: string, subtaskId: string): void;
+    getSubtask(featureName: string, taskFolder: string, subtaskId: string): Subtask | null;
+    writeSubtaskSpec(featureName: string, taskFolder: string, subtaskId: string, content: string): string;
+    writeSubtaskReport(featureName: string, taskFolder: string, subtaskId: string, content: string): string;
+    readSubtaskSpec(featureName: string, taskFolder: string, subtaskId: string): string | null;
+    readSubtaskReport(featureName: string, taskFolder: string, subtaskId: string): string | null;
+    private listSubtaskFolders;
+    private findSubtaskFolder;
+    private slugify;
 }

package/dist/services/taskService.js

@@ -1,5 +1,5 @@
 import * as fs from 'fs';
-import { getTasksPath, getTaskPath, getTaskStatusPath, getTaskReportPath, getTaskSpecPath, getPlanPath, ensureDir, readJson, writeJson, readText, writeText, fileExists, } from '../utils/paths.js';
+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) {
@@ -227,4 +227,156 @@ export class TaskService {
         }
         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.js

@@ -3,7 +3,7 @@ import * as fs from "fs";
 import { TaskService } from "./taskService";
 import { FeatureService } from "./featureService";
 import { PlanService } from "./planService";
-import { getTaskPath, getTaskStatusPath, getTaskReportPath } from "../utils/paths";
+import { getTaskPath, getTaskStatusPath, getTaskReportPath, getSubtaskPath, getSubtaskStatusPath, getSubtaskSpecPath } from "../utils/paths";
 const TEST_ROOT = "/tmp/hive-test-task";
 describe("TaskService", () => {
     let taskService;
@@ -156,4 +156,135 @@ Description
             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();
+            });
+        });
+    });
 });

package/dist/types.d.ts

@@ -10,6 +10,22 @@ export interface FeatureJson {
 }
 export type TaskStatusType = 'pending' | 'in_progress' | 'done' | 'cancelled';
 export type TaskOrigin = 'plan' | 'manual';
+export type SubtaskType = 'test' | 'implement' | 'review' | 'verify' | 'research' | 'debug' | 'custom';
+export interface Subtask {
+    id: string;
+    name: string;
+    folder: string;
+    status: TaskStatusType;
+    type?: SubtaskType;
+    createdAt?: string;
+    completedAt?: string;
+}
+export interface SubtaskStatus {
+    status: TaskStatusType;
+    type?: SubtaskType;
+    createdAt: string;
+    completedAt?: string;
+}
 export interface TaskStatus {
     status: TaskStatusType;
     origin: TaskOrigin;
@@ -17,6 +33,7 @@ export interface TaskStatus {
     startedAt?: string;
     completedAt?: string;
     baseCommit?: string;
+    subtasks?: Subtask[];
 }
 export interface PlanComment {
     id: string;

package/dist/utils/paths.d.ts

@@ -10,6 +10,11 @@ export declare function getTaskPath(projectRoot: string, featureName: string, ta
 export declare function getTaskStatusPath(projectRoot: string, featureName: string, taskFolder: string): string;
 export declare function getTaskReportPath(projectRoot: string, featureName: string, taskFolder: string): string;
 export declare function getTaskSpecPath(projectRoot: string, featureName: string, taskFolder: string): string;
+export declare function getSubtasksPath(projectRoot: string, featureName: string, taskFolder: string): string;
+export declare function getSubtaskPath(projectRoot: string, featureName: string, taskFolder: string, subtaskFolder: string): string;
+export declare function getSubtaskStatusPath(projectRoot: string, featureName: string, taskFolder: string, subtaskFolder: string): string;
+export declare function getSubtaskSpecPath(projectRoot: string, featureName: string, taskFolder: string, subtaskFolder: string): string;
+export declare function getSubtaskReportPath(projectRoot: string, featureName: string, taskFolder: string, subtaskFolder: string): string;
 export declare function ensureDir(dirPath: string): void;
 export declare function fileExists(filePath: string): boolean;
 export declare function readJson<T>(filePath: string): T | null;

package/dist/utils/paths.js

@@ -45,6 +45,24 @@ export function getTaskReportPath(projectRoot, featureName, taskFolder) {
 export function getTaskSpecPath(projectRoot, featureName, taskFolder) {
     return path.join(getTaskPath(projectRoot, featureName, taskFolder), 'spec.md');
 }
+// Subtask paths
+const SUBTASKS_DIR = 'subtasks';
+const SPEC_FILE = 'spec.md';
+export function getSubtasksPath(projectRoot, featureName, taskFolder) {
+    return path.join(getTaskPath(projectRoot, featureName, taskFolder), SUBTASKS_DIR);
+}
+export function getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder) {
+    return path.join(getSubtasksPath(projectRoot, featureName, taskFolder), subtaskFolder);
+}
+export function getSubtaskStatusPath(projectRoot, featureName, taskFolder, subtaskFolder) {
+    return path.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), STATUS_FILE);
+}
+export function getSubtaskSpecPath(projectRoot, featureName, taskFolder, subtaskFolder) {
+    return path.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), SPEC_FILE);
+}
+export function getSubtaskReportPath(projectRoot, featureName, taskFolder, subtaskFolder) {
+    return path.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
+}
 export function ensureDir(dirPath) {
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-hive",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",