opencode-hive 0.5.2 → 0.8.0

package/dist/index.js

@@ -12,14 +12,16 @@ const HIVE_SYSTEM_PROMPT = `
 
 Plan-first development: Write plan → User reviews → Approve → Execute tasks
 
-### Tools (16 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 |
 | Session | hive_session_open, hive_session_list |
 
@@ -30,7 +32,26 @@ Plan-first development: Write plan → User reviews → Approve → Execute task
 3. User adds comments in VSCode → \`hive_plan_read\` to see them
 4. Revise plan → User approves
 5. \`hive_tasks_sync()\` - Generate tasks from plan
-6. \`hive_exec_start(task)\` → work → \`hive_exec_complete(task, summary)\`
+6. \`hive_exec_start(task)\` → work in worktree → \`hive_exec_complete(task, summary)\`
+7. \`hive_merge(task)\` - Merge task branch into main (when ready)
+
+**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
 
@@ -299,7 +320,7 @@ const plugin = async (ctx) => {
                 },
             }),
             hive_exec_complete: tool({
-                description: 'Complete task: apply changes, write report',
+                description: 'Complete task: commit changes to branch, write report (does NOT merge or cleanup)',
                 args: {
                     task: tool.schema.string().describe('Task folder name'),
                     summary: tool.schema.string().describe('Summary of what was done'),
@@ -314,22 +335,15 @@ const plugin = async (ctx) => {
                         return `Error: Task "${task}" not found`;
                     if (taskInfo.status !== 'in_progress')
                         return "Error: Task not in progress";
+                    const commitResult = await worktreeService.commitChanges(feature, task, `hive(${task}): ${summary.slice(0, 50)}`);
                     const diff = await worktreeService.getDiff(feature, task);
-                    let changesApplied = false;
-                    let applyError = "";
-                    if (diff?.hasDiff) {
-                        const result = await worktreeService.applyDiff(feature, task);
-                        changesApplied = result.success;
-                        if (!result.success) {
-                            applyError = result.error || "Unknown apply error";
-                        }
-                    }
                     const reportLines = [
                         `# Task Report: ${task}`,
                         '',
                         `**Feature:** ${feature}`,
                         `**Completed:** ${new Date().toISOString()}`,
-                        `**Status:** ${applyError ? 'completed with errors' : 'success'}`,
+                        `**Status:** success`,
+                        `**Commit:** ${commitResult.sha || 'none'}`,
                         '',
                         '---',
                         '',
@@ -353,11 +367,8 @@ const plugin = async (ctx) => {
                     }
                     taskService.writeReport(feature, task, reportLines.join('\n'));
                     taskService.update(feature, task, { status: 'done', summary });
-                    await worktreeService.remove(feature, task);
-                    if (applyError) {
-                        return `Task "${task}" completed but changes failed to apply: ${applyError}`;
-                    }
-                    return `Task "${task}" completed.${changesApplied ? " Changes applied." : ""}`;
+                    const worktree = await worktreeService.get(feature, task);
+                    return `Task "${task}" completed. Changes committed to branch ${worktree?.branch || 'unknown'}.\nUse hive_merge to integrate changes. Worktree preserved at ${worktree?.path || 'unknown'}.`;
                 },
             }),
             hive_exec_abort: tool({
@@ -375,6 +386,52 @@ const plugin = async (ctx) => {
                     return `Task "${task}" aborted. Status reset to pending.`;
                 },
             }),
+            hive_merge: tool({
+                description: 'Merge completed task branch into current branch (explicit integration)',
+                args: {
+                    task: tool.schema.string().describe('Task folder name to merge'),
+                    strategy: tool.schema.enum(['merge', 'squash', 'rebase']).optional().describe('Merge strategy (default: merge)'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ task, strategy = 'merge', feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    const taskInfo = taskService.get(feature, task);
+                    if (!taskInfo)
+                        return `Error: Task "${task}" not found`;
+                    if (taskInfo.status !== 'done')
+                        return "Error: Task must be completed before merging. Use hive_exec_complete first.";
+                    const result = await worktreeService.merge(feature, task, strategy);
+                    if (!result.success) {
+                        if (result.conflicts && result.conflicts.length > 0) {
+                            return `Merge failed with conflicts in:\n${result.conflicts.map(f => `- ${f}`).join('\n')}\n\nResolve conflicts manually or try a different strategy.`;
+                        }
+                        return `Merge failed: ${result.error}`;
+                    }
+                    return `Task "${task}" merged successfully using ${strategy} strategy.\nCommit: ${result.sha}\nFiles changed: ${result.filesChanged?.length || 0}`;
+                },
+            }),
+            hive_worktree_list: tool({
+                description: 'List all worktrees for current feature',
+                args: {
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    const worktrees = await worktreeService.list(feature);
+                    if (worktrees.length === 0)
+                        return "No worktrees found for this feature.";
+                    const lines = ['| Task | Branch | Has Changes |', '|------|--------|-------------|'];
+                    for (const wt of worktrees) {
+                        const hasChanges = await worktreeService.hasUncommittedChanges(wt.feature, wt.step);
+                        lines.push(`| ${wt.step} | ${wt.branch} | ${hasChanges ? 'Yes' : 'No'} |`);
+                    }
+                    return lines.join('\n');
+                },
+            }),
             // Context Tools
             hive_context_write: tool({
                 description: 'Write a context file for the feature. Context files store persistent notes, decisions, and reference material.',
@@ -488,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/services/worktreeService.d.ts

@@ -17,6 +17,19 @@ export interface ApplyResult {
     error?: string;
     filesAffected: string[];
 }
+export interface CommitResult {
+    committed: boolean;
+    sha: string;
+    message?: string;
+}
+export interface MergeResult {
+    success: boolean;
+    merged: boolean;
+    sha?: string;
+    filesChanged?: string[];
+    conflicts?: string[];
+    error?: string;
+}
 export interface WorktreeConfig {
     baseDir: string;
     hiveDir: string;
@@ -45,5 +58,9 @@ export declare class WorktreeService {
     }>;
     checkConflicts(feature: string, step: string, baseBranch?: string): Promise<string[]>;
     checkConflictsFromSavedDiff(diffPath: string, reverse?: boolean): Promise<string[]>;
+    commitChanges(feature: string, step: string, message?: string): Promise<CommitResult>;
+    merge(feature: string, step: string, strategy?: 'merge' | 'squash' | 'rebase'): Promise<MergeResult>;
+    hasUncommittedChanges(feature: string, step: string): Promise<boolean>;
+    private parseConflictsFromError;
 }
 export declare function createWorktreeService(projectDir: string): WorktreeService;

package/dist/services/worktreeService.js

@@ -97,8 +97,18 @@ export class WorktreeService {
         const worktreeGit = this.getGit(worktreePath);
         try {
             await worktreeGit.raw(["add", "-A"]);
-            const diffContent = await worktreeGit.diff([`${base}...HEAD`]);
-            const stat = await worktreeGit.diff([`${base}...HEAD`, "--stat"]);
+            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)
@@ -347,6 +357,138 @@ export class WorktreeService {
             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({

package/dist/services/worktreeService.test.js

@@ -87,7 +87,7 @@ describe("WorktreeService", () => {
             expect(diff.diffContent).toBe("");
             expect(diff.filesChanged).toEqual([]);
         });
-        it("returns diff when files changed", async () => {
+        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");
@@ -97,6 +97,74 @@ describe("WorktreeService", () => {
             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 () => {

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.5.2",
+  "version": "0.8.0",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",