vibeman 0.0.3 → 0.0.5

package/dist/runtime/api/tasks/task-file-parser.d.ts

@@ -6,6 +6,7 @@ export declare class TaskFileParser {
     parseDirectory(dirPath?: string): Promise<Task[]>;
     parseContent(content: string, filePath?: string): Promise<Task | null>;
     private getFileStats;
+    private normalizeStatus;
     writeTask(task: Task): Promise<void>;
     deleteTask(taskId: string): Promise<void>;
     generateFilePath(task: Task): string;

package/dist/runtime/api/tasks/task-file-parser.js

@@ -41,6 +41,10 @@ export class TaskFileParser {
         try {
             const parsed = matter(content);
             const metadata = parsed.data;
+            const normalizedStatus = this.normalizeStatus(metadata.status);
+            if (normalizedStatus !== null) {
+                metadata.status = normalizedStatus;
+            }
             // Validate required fields
             if (!metadata.id || !metadata.title || !metadata.type || !metadata.status) {
                 log.error(`Invalid task metadata in ${filePath}`, { metadata, filePath }, 'task-file-parser:parseContent');
@@ -56,7 +60,7 @@ export class TaskFileParser {
             }
             if (!validStatuses.includes(metadata.status)) {
                 log.error(`Invalid task status '${metadata.status}' in ${filePath}`, { status: metadata.status, filePath, validStatuses }, 'task-file-parser:parseContent');
-                return null;
+                metadata.status = 'backlog';
             }
             if (metadata.priority && !validPriorities.includes(metadata.priority)) {
                 log.error(`Invalid task priority '${metadata.priority}' in ${filePath}`, { priority: metadata.priority, filePath, validPriorities }, 'task-file-parser:parseContent');
@@ -108,6 +112,21 @@ export class TaskFileParser {
             return null;
         }
     }
+    normalizeStatus(status) {
+        if (typeof status !== 'string') {
+            return null;
+        }
+        const normalized = status
+            .trim()
+            .toLowerCase()
+            .replace(/[_\s]+/g, '-')
+            .replace(/-+/g, '-');
+        const validStatuses = ['backlog', 'in-progress', 'review', 'done'];
+        if (validStatuses.includes(normalized)) {
+            return normalized;
+        }
+        return null;
+    }
     async writeTask(task) {
         const filePath = this.generateFilePath(task);
         const frontMatter = {

package/dist/runtime/api/tasks/task-updater.d.ts

@@ -0,0 +1,62 @@
+export interface TaskUpdateContext {
+    filesModified?: string[];
+    keyChanges?: string[];
+    testsAdded?: boolean;
+    testsPassed?: boolean;
+    buildPassed?: boolean;
+    qualityChecksPassed?: boolean;
+    aiReviewScore?: number;
+    workflowId?: string;
+    phase?: string;
+}
+export interface TaskUpdateSummary {
+    filesChanged: string[];
+    keyLogic: string[];
+    testsInfo: string;
+    qualityNotes: string;
+    remainingRisks: string[];
+}
+/**
+ * Updates task markdown files when workflows reach review readiness.
+ * Handles status updates, todo marking, and implementation summary generation.
+ */
+export declare class TaskUpdater {
+    private tasksDir;
+    constructor(vibeDir?: string);
+    /**
+     * Main entry point: Update task for review readiness
+     */
+    updateTaskForReviewReadiness(taskId: string, context?: TaskUpdateContext): Promise<void>;
+    /**
+     * Update YAML front-matter to set status to 'review'
+     */
+    private updateStatusToReview;
+    /**
+     * Process markdown content: mark todos and add/update implementation summary
+     */
+    private processMarkdownContent;
+    /**
+     * Mark implementation-related todos as completed
+     */
+    private markImplementationTodos;
+    /**
+     * Check if a section is eligible for todo marking
+     */
+    private isEligibleTodoSection;
+    /**
+     * Add or update the implementation summary section
+     */
+    private upsertImplementationSummary;
+    /**
+     * Generate implementation summary from context
+     */
+    private generateImplementationSummary;
+    /**
+     * Build the implementation summary markdown section
+     */
+    private buildImplementationSummarySection;
+    /**
+     * Write task file atomically using temporary file
+     */
+    private writeTaskFileAtomically;
+}

package/dist/runtime/api/tasks/task-updater.js

@@ -0,0 +1,260 @@
+import fs from 'fs/promises';
+import path from 'path';
+import matter from 'gray-matter';
+import { log } from '../lib/logger.js';
+import { getVibeDir } from '../lib/server/project-root.js';
+/**
+ * Updates task markdown files when workflows reach review readiness.
+ * Handles status updates, todo marking, and implementation summary generation.
+ */
+export class TaskUpdater {
+    constructor(vibeDir) {
+        this.tasksDir = path.join(vibeDir || getVibeDir(), 'tasks');
+    }
+    /**
+     * Main entry point: Update task for review readiness
+     */
+    async updateTaskForReviewReadiness(taskId, context = {}) {
+        try {
+            const taskFilePath = path.join(this.tasksDir, `${taskId}.md`);
+            // Check if task file exists
+            try {
+                await fs.access(taskFilePath);
+            }
+            catch (error) {
+                log.error('Task file not found', { taskId, taskFilePath }, 'task-updater');
+                throw new Error(`Task file not found: ${taskId}`);
+            }
+            // Read and parse the task file
+            const fileContent = await fs.readFile(taskFilePath, 'utf-8');
+            const parsed = matter(fileContent);
+            // Update YAML front-matter status
+            const updatedFrontMatter = this.updateStatusToReview(parsed.data);
+            // Process markdown content
+            const updatedContent = this.processMarkdownContent(parsed.content, context);
+            // Write back atomically
+            await this.writeTaskFileAtomically(taskFilePath, updatedFrontMatter, updatedContent);
+            log.info('Task updated for review readiness', { taskId }, 'task-updater');
+        }
+        catch (error) {
+            log.error('Failed to update task for review readiness', error, 'task-updater');
+            throw error;
+        }
+    }
+    /**
+     * Update YAML front-matter to set status to 'review'
+     */
+    updateStatusToReview(frontMatter) {
+        const updated = { ...frontMatter };
+        // Only update if not already 'done' (preserve completed tasks) - case insensitive
+        if (updated.status?.toLowerCase() !== 'done') {
+            updated.status = 'Review';
+        }
+        return updated;
+    }
+    /**
+     * Process markdown content: mark todos and add/update implementation summary
+     */
+    processMarkdownContent(content, context) {
+        let processedContent = content;
+        // Step 1: Mark implementation todos as completed
+        processedContent = this.markImplementationTodos(processedContent);
+        // Step 2: Add or update implementation summary
+        processedContent = this.upsertImplementationSummary(processedContent, context);
+        return processedContent;
+    }
+    /**
+     * Mark implementation-related todos as completed
+     */
+    markImplementationTodos(content) {
+        const lines = content.split('\n');
+        let inEligibleSection = false;
+        let currentSection = '';
+        const processedLines = lines.map((line) => {
+            // Track current section
+            const headerMatch = line.match(/^##\s+(.+)$/i);
+            if (headerMatch) {
+                currentSection = headerMatch[1].toLowerCase().trim();
+                inEligibleSection = this.isEligibleTodoSection(currentSection);
+                return line;
+            }
+            // Reset section tracking on other headers
+            if (line.match(/^#\s+/)) {
+                inEligibleSection = false;
+                currentSection = '';
+                return line;
+            }
+            // Mark todos in eligible sections
+            if (inEligibleSection && line.match(/^[\s]*-\s+\[\s*\]\s+/)) {
+                return line.replace(/^([\s]*-\s+)\[\s*\](\s+.*)$/, '$1[x]$2');
+            }
+            return line;
+        });
+        return processedLines.join('\n');
+    }
+    /**
+     * Check if a section is eligible for todo marking
+     */
+    isEligibleTodoSection(sectionName) {
+        const eligibleSections = [
+            'implementation',
+            'implementation tasks',
+            'tasks',
+            'todo',
+            'implementation notes',
+        ];
+        // Check for exact matches or partial matches
+        return eligibleSections.some((eligible) => sectionName.includes(eligible) || eligible.includes(sectionName));
+    }
+    /**
+     * Add or update the implementation summary section
+     */
+    upsertImplementationSummary(content, context) {
+        const summary = this.generateImplementationSummary(context);
+        const summarySection = this.buildImplementationSummarySection(summary);
+        // Check if implementation summary already exists
+        const startMarker = '<!-- IMPLEMENTATION_SUMMARY_START -->';
+        const endMarker = '<!-- IMPLEMENTATION_SUMMARY_END -->';
+        const startIndex = content.indexOf(startMarker);
+        const endIndex = content.indexOf(endMarker);
+        if (startIndex !== -1 && endIndex !== -1) {
+            // Replace existing summary
+            const before = content.substring(0, startIndex);
+            const after = content.substring(endIndex + endMarker.length);
+            return before + summarySection + after;
+        }
+        else {
+            // Add new summary at the beginning of content (after first header if any)
+            const lines = content.split('\n');
+            let insertIndex = 0;
+            // Find insertion point after description or first header
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].match(/^##\s+/)) {
+                    insertIndex = i;
+                    break;
+                }
+            }
+            const before = lines.slice(0, insertIndex).join('\n');
+            const after = lines.slice(insertIndex).join('\n');
+            const separator = insertIndex > 0 && before.trim() ? '\n\n' : '';
+            return before + separator + summarySection + '\n\n' + after;
+        }
+    }
+    /**
+     * Generate implementation summary from context
+     */
+    generateImplementationSummary(context) {
+        const filesChanged = context.filesModified || [];
+        const keyLogic = context.keyChanges || [];
+        // Generate tests info
+        let testsInfo = 'No test information available';
+        if (context.testsAdded) {
+            testsInfo = context.testsPassed
+                ? 'New tests added and passing'
+                : 'New tests added (status unknown)';
+        }
+        else if (context.testsPassed !== undefined) {
+            testsInfo = context.testsPassed ? 'Existing tests passing' : 'Test failures detected';
+        }
+        // Generate quality notes
+        let qualityNotes = 'Quality checks not run';
+        if (context.qualityChecksPassed !== undefined) {
+            qualityNotes = context.qualityChecksPassed
+                ? 'All quality checks passed'
+                : 'Quality check failures';
+        }
+        if (context.buildPassed !== undefined) {
+            qualityNotes += context.buildPassed ? ', build successful' : ', build failures detected';
+        }
+        if (context.aiReviewScore !== undefined) {
+            qualityNotes += `, AI review score: ${context.aiReviewScore}`;
+        }
+        // Identify remaining risks (only for actual failures, not missing data)
+        const remainingRisks = [];
+        if (context.testsPassed === false)
+            remainingRisks.push('Test failures need investigation');
+        if (context.qualityChecksPassed === false)
+            remainingRisks.push('Quality check issues need resolution');
+        if (context.buildPassed === false)
+            remainingRisks.push('Build issues need fixing');
+        if (context.aiReviewScore !== undefined && context.aiReviewScore < 70) {
+            remainingRisks.push('AI review score below threshold');
+        }
+        return {
+            filesChanged: filesChanged.slice(0, 10), // Limit to 10 files for readability
+            keyLogic,
+            testsInfo,
+            qualityNotes,
+            remainingRisks,
+        };
+    }
+    /**
+     * Build the implementation summary markdown section
+     */
+    buildImplementationSummarySection(summary) {
+        const sections = [];
+        sections.push('<!-- IMPLEMENTATION_SUMMARY_START -->');
+        sections.push('## Implementation Summary');
+        sections.push('');
+        // Files changed
+        if (summary.filesChanged.length > 0) {
+            sections.push(`- **Files Modified:** ${summary.filesChanged.length} files updated`);
+            sections.push('- **Key Files:**');
+            summary.filesChanged.forEach((file) => {
+                sections.push(`  - \`${file}\``);
+            });
+        }
+        else {
+            sections.push('- **Files Modified:** No file changes tracked');
+        }
+        // Key logic changes
+        if (summary.keyLogic.length > 0) {
+            sections.push('- **Key Changes:**');
+            summary.keyLogic.forEach((change) => {
+                sections.push(`  - ${change}`);
+            });
+        }
+        // Tests and quality
+        sections.push(`- **Tests:** ${summary.testsInfo}`);
+        sections.push(`- **Quality Checks:** ${summary.qualityNotes}`);
+        // Remaining risks
+        if (summary.remainingRisks.length > 0) {
+            sections.push('- **Review Notes:** Issues requiring attention:');
+            summary.remainingRisks.forEach((risk) => {
+                sections.push(`  - ⚠️ ${risk}`);
+            });
+        }
+        else {
+            sections.push('- **Review Notes:** Ready for manual review and approval');
+        }
+        sections.push('');
+        sections.push('<!-- IMPLEMENTATION_SUMMARY_END -->');
+        return sections.join('\n');
+    }
+    /**
+     * Write task file atomically using temporary file
+     */
+    async writeTaskFileAtomically(filePath, frontMatter, content) {
+        const tempPath = filePath + '.tmp';
+        try {
+            // Normalize content to ensure clean formatting
+            const normalizedContent = content.replace(/^[\r\n]+/, '').replace(/[\r\n]*$/, '\n');
+            // Build complete file content
+            const fileContent = matter.stringify(normalizedContent, frontMatter);
+            // Write to temporary file first
+            await fs.writeFile(tempPath, fileContent, 'utf-8');
+            // Atomic rename
+            await fs.rename(tempPath, filePath);
+        }
+        catch (error) {
+            // Clean up temp file if it exists
+            try {
+                await fs.unlink(tempPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            throw error;
+        }
+    }
+}

package/dist/runtime/api/tasks/task-updater.test.d.ts

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

package/dist/runtime/api/tasks/task-updater.test.js

@@ -0,0 +1,303 @@
+import { describe, beforeEach, afterEach, test, expect, vi } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import { TaskUpdater } from './task-updater.js';
+// Mock fs and path
+vi.mock('fs/promises');
+vi.mock('../lib/logger.js', () => ({
+    log: {
+        info: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+vi.mock('../lib/server/project-root.js', () => ({
+    getVibeDir: vi.fn(() => '/test/vibe'),
+}));
+const mockFs = fs;
+describe('TaskUpdater', () => {
+    let taskUpdater;
+    const testTasksDir = '/test/vibe/tasks';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        taskUpdater = new TaskUpdater('/test/vibe');
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('updateTaskForReviewReadiness', () => {
+        const sampleTaskContent = `---
+id: TEST-TASK-123
+title: Test Task
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Description
+This is a test task.
+
+## Implementation Tasks
+- [ ] Implement feature A
+- [ ] Add tests for feature A
+- [x] Already completed task
+
+## Acceptance Criteria
+- [ ] Feature works correctly
+- [ ] Tests pass
+`;
+        beforeEach(() => {
+            mockFs.access = vi.fn().mockResolvedValue(undefined);
+            mockFs.readFile = vi.fn().mockResolvedValue(sampleTaskContent);
+            mockFs.writeFile = vi.fn().mockResolvedValue(undefined);
+            mockFs.rename = vi.fn().mockResolvedValue(undefined);
+            mockFs.unlink = vi.fn().mockResolvedValue(undefined);
+        });
+        test('should update task status to review', async () => {
+            const context = {
+                filesModified: ['src/feature.ts', 'tests/feature.test.ts'],
+                keyChanges: ['Added new feature A', 'Implemented core logic'],
+                testsPassed: true,
+                qualityChecksPassed: true,
+            };
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', context);
+            expect(mockFs.access).toHaveBeenCalledWith(path.join(testTasksDir, 'TEST-TASK-123.md'));
+            expect(mockFs.readFile).toHaveBeenCalledWith(path.join(testTasksDir, 'TEST-TASK-123.md'), 'utf-8');
+            expect(mockFs.writeFile).toHaveBeenCalled();
+            expect(mockFs.rename).toHaveBeenCalled();
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Verify status changed to Review
+            expect(writtenContent).toContain('status: Review');
+            // Verify todos are marked as completed
+            expect(writtenContent).toContain('- [x] Implement feature A');
+            expect(writtenContent).toContain('- [x] Add tests for feature A');
+            // Verify acceptance criteria unchanged
+            expect(writtenContent).toContain('- [ ] Feature works correctly');
+            expect(writtenContent).toContain('- [ ] Tests pass');
+            // Verify implementation summary added
+            expect(writtenContent).toContain('## Implementation Summary');
+            expect(writtenContent).toContain('IMPLEMENTATION_SUMMARY_START');
+            expect(writtenContent).toContain('IMPLEMENTATION_SUMMARY_END');
+        });
+        test('should not change status if already done', async () => {
+            const doneTaskContent = sampleTaskContent.replace('status: in-progress', 'status: done');
+            mockFs.readFile = vi.fn().mockResolvedValue(doneTaskContent);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            expect(writtenContent).toContain('status: done');
+            expect(writtenContent).not.toContain('status: Review');
+        });
+        test('should not change status if already Done (case insensitive)', async () => {
+            const doneTaskContent = sampleTaskContent.replace('status: in-progress', 'status: Done');
+            mockFs.readFile = vi.fn().mockResolvedValue(doneTaskContent);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            expect(writtenContent).toContain('status: Done');
+            expect(writtenContent).not.toContain('status: Review');
+        });
+        test('should handle missing task file', async () => {
+            mockFs.access = vi.fn().mockRejectedValue(new Error('File not found'));
+            await expect(taskUpdater.updateTaskForReviewReadiness('NONEXISTENT-TASK', {})).rejects.toThrow('Task file not found: NONEXISTENT-TASK');
+        });
+        test('should mark only implementation todos, not acceptance criteria', async () => {
+            const taskWithMixedTodos = `---
+id: TEST-TASK-456
+title: Mixed Todos Task
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Implementation
+- [ ] Task 1
+- [ ] Task 2
+
+## Implementation Tasks
+- [ ] Task 3
+- [ ] Task 4
+
+## Acceptance Criteria
+- [ ] AC 1
+- [ ] AC 2
+
+## Random Section
+- [ ] Should not be marked
+`;
+            mockFs.readFile = vi.fn().mockResolvedValue(taskWithMixedTodos);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-456', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Implementation todos should be marked
+            expect(writtenContent).toContain('- [x] Task 1');
+            expect(writtenContent).toContain('- [x] Task 2');
+            expect(writtenContent).toContain('- [x] Task 3');
+            expect(writtenContent).toContain('- [x] Task 4');
+            // Acceptance criteria should remain unchanged
+            expect(writtenContent).toContain('- [ ] AC 1');
+            expect(writtenContent).toContain('- [ ] AC 2');
+            // Random section should remain unchanged
+            expect(writtenContent).toContain('- [ ] Should not be marked');
+        });
+        test('should update existing implementation summary', async () => {
+            const taskWithExistingSummary = `---
+id: TEST-TASK-789
+title: Task with Existing Summary
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Description
+Task description
+
+<!-- IMPLEMENTATION_SUMMARY_START -->
+## Implementation Summary
+Old summary content
+<!-- IMPLEMENTATION_SUMMARY_END -->
+
+## Implementation
+- [ ] Task 1
+`;
+            mockFs.readFile = vi.fn().mockResolvedValue(taskWithExistingSummary);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-789', {
+                filesModified: ['newfile.ts'],
+                keyChanges: ['New implementation'],
+            });
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Should have new summary, not old
+            expect(writtenContent).not.toContain('Old summary content');
+            expect(writtenContent).toContain('**Files Modified:** 1 files updated');
+            expect(writtenContent).toContain('newfile.ts');
+            expect(writtenContent).toContain('New implementation');
+        });
+        test('should handle atomic write failure by cleaning up temp file', async () => {
+            mockFs.writeFile = vi.fn().mockRejectedValue(new Error('Write failed'));
+            mockFs.unlink = vi.fn().mockResolvedValue(undefined);
+            await expect(taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', {})).rejects.toThrow('Write failed');
+            expect(mockFs.unlink).toHaveBeenCalledWith(path.join(testTasksDir, 'TEST-TASK-123.md.tmp'));
+        });
+        test('should generate comprehensive implementation summary', async () => {
+            const context = {
+                filesModified: ['src/feature.ts', 'tests/feature.test.ts', 'docs/feature.md'],
+                keyChanges: ['Added feature A', 'Improved performance', 'Fixed edge case'],
+                testsAdded: true,
+                testsPassed: true,
+                buildPassed: true,
+                qualityChecksPassed: true,
+                aiReviewScore: 85,
+                workflowId: 'workflow-123',
+            };
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', context);
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Verify summary content
+            expect(writtenContent).toContain('**Files Modified:** 3 files updated');
+            expect(writtenContent).toContain('src/feature.ts');
+            expect(writtenContent).toContain('tests/feature.test.ts');
+            expect(writtenContent).toContain('docs/feature.md');
+            expect(writtenContent).toContain('**Key Changes:**');
+            expect(writtenContent).toContain('Added feature A');
+            expect(writtenContent).toContain('Improved performance');
+            expect(writtenContent).toContain('Fixed edge case');
+            expect(writtenContent).toContain('**Tests:** New tests added and passing');
+            expect(writtenContent).toContain('**Quality Checks:** All quality checks passed');
+            expect(writtenContent).toContain('AI review score: 85');
+            expect(writtenContent).toContain('Ready for manual review and approval');
+        });
+        test('should identify review risks when quality checks fail', async () => {
+            const context = {
+                filesModified: ['src/feature.ts'],
+                testsPassed: false,
+                buildPassed: false,
+                qualityChecksPassed: false,
+                aiReviewScore: 45,
+            };
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', context);
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            expect(writtenContent).toContain('**Review Notes:** Issues requiring attention:');
+            expect(writtenContent).toContain('⚠️ Test failures need investigation');
+            expect(writtenContent).toContain('⚠️ Quality check issues need resolution');
+            expect(writtenContent).toContain('⚠️ Build issues need fixing');
+            expect(writtenContent).toContain('⚠️ AI review score below threshold');
+        });
+        test('should identify AI review score of 0 as risk', async () => {
+            const context = {
+                filesModified: ['src/feature.ts'],
+                testsPassed: true,
+                buildPassed: true,
+                qualityChecksPassed: true,
+                aiReviewScore: 0,
+            };
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-123', context);
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            expect(writtenContent).toContain('**Review Notes:** Issues requiring attention:');
+            expect(writtenContent).toContain('⚠️ AI review score below threshold');
+        });
+        test('should handle edge case with no eligible todo sections', async () => {
+            const taskWithoutTodos = `---
+id: TEST-TASK-NO-TODOS
+title: Task Without Implementation Todos
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Description
+This task has no implementation todos.
+
+## Acceptance Criteria
+- [ ] Should work
+- [ ] Should be tested
+`;
+            mockFs.readFile = vi.fn().mockResolvedValue(taskWithoutTodos);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-TASK-NO-TODOS', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // Status should still be updated
+            expect(writtenContent).toContain('status: Review');
+            // Implementation summary should still be added
+            expect(writtenContent).toContain('## Implementation Summary');
+            // Acceptance criteria should remain unchanged
+            expect(writtenContent).toContain('- [ ] Should work');
+            expect(writtenContent).toContain('- [ ] Should be tested');
+        });
+        test('should handle nested todo lists in implementation sections', async () => {
+            const taskWithNestedTodos = `---
+id: TEST-NESTED
+title: Task with Nested Todos
+type: feature
+status: in-progress
+tags: ''
+priority: medium
+---
+
+## Implementation Tasks
+- [ ] Main task 1
+  - [ ] Subtask 1.1
+  - [ ] Subtask 1.2
+- [ ] Main task 2
+    - [ ] Subtask 2.1
+`;
+            mockFs.readFile = vi.fn().mockResolvedValue(taskWithNestedTodos);
+            await taskUpdater.updateTaskForReviewReadiness('TEST-NESTED', {});
+            const writeCall = mockFs.writeFile.mock.calls[0];
+            const writtenContent = writeCall[1];
+            // All todos should be marked, preserving indentation
+            expect(writtenContent).toContain('- [x] Main task 1');
+            expect(writtenContent).toContain('  - [x] Subtask 1.1');
+            expect(writtenContent).toContain('  - [x] Subtask 1.2');
+            expect(writtenContent).toContain('- [x] Main task 2');
+            expect(writtenContent).toContain('    - [x] Subtask 2.1');
+        });
+    });
+});

package/dist/runtime/api/types/index.d.ts

@@ -183,4 +183,4 @@ export interface VibingConfig {
         timestamp?: string;
     };
 }
-export type { VibingStage, VibingStatus, LegacyVibingPhase, VibingWorkflowV2, StageToStatusMapping, } from '@vibeman/types';
+export type { VibingStage, VibingStatus, VibingWorkflowV2, StageToStatusMapping, } from '@vibeman/types';