maistro 1.0.390

package/dist/orchestrator.js

@@ -0,0 +1,821 @@
+import { DEFAULT_CONFIG, createProjectState } from './types.js';
+import { loadState, saveState, getNextTask, updateTaskStatus, allTasksCompleted, getTaskSummary, resetInProgressTasks, } from './taskQueue.js';
+import { decompose, validateTaskDependencies, sortTasksByDependency } from './planner.js';
+import { buildContext } from './contextBuilder.js';
+import { executeTask, executeTaskWithFeedback, isClaudeCodeAvailable, runClaudeInit } from './executor.js';
+import { validate } from './validator.js';
+import { commitAll, hasChanges, isGitRepo, initRepo, ensureMaistroInGitignore, stageAll, unstageAll } from './git.js';
+import { extractImagePlaceholders } from './imageManager.js';
+import { join } from 'node:path';
+import { Logger } from './logger.js';
+/**
+ * Extract a brief failure reason from a full error message
+ * Looks for common patterns like test failures, build errors, etc.
+ */
+function extractFailureReason(error, failureType) {
+    if (!error) {
+        return failureType === 'execution' ? 'Execution failed' : 'Validation failed';
+    }
+    const errorLower = error.toLowerCase();
+    // API errors - check these first as they're from Claude Code/API issues
+    // These should be prioritized over other patterns
+    if (errorLower.includes('api error')) {
+        // Extract specific API error details
+        const apiMatch = error.match(/API Error:\s*(\d+)\s*(?:due to\s*)?([^\n.]+)?/i);
+        if (apiMatch) {
+            const code = apiMatch[1];
+            const reason = apiMatch[2]?.trim();
+            if (reason) {
+                return `API error ${code}: ${reason.slice(0, 30)}${reason.length > 30 ? '...' : ''}`;
+            }
+            return `API error ${code}`;
+        }
+        return 'API error';
+    }
+    // Rate limiting
+    if (errorLower.includes('rate limit') || errorLower.includes('too many requests') || errorLower.includes('concurrency')) {
+        return 'Rate limited';
+    }
+    // Authentication errors
+    if (errorLower.includes('unauthorized') || errorLower.includes('authentication') || errorLower.includes('auth error')) {
+        return 'Authentication error';
+    }
+    // Test failure patterns
+    if (errorLower.includes('test') && (errorLower.includes('fail') || errorLower.includes('error'))) {
+        // Try to extract test count
+        const testMatch = error.match(/(\d+)\s*(test|spec)s?\s*(fail|error)/i);
+        if (testMatch) {
+            return `${testMatch[1]} test${parseInt(testMatch[1]) > 1 ? 's' : ''} failed`;
+        }
+        return 'Test failures';
+    }
+    // Build/compile errors
+    if (errorLower.includes('build') && errorLower.includes('fail')) {
+        return 'Build failed';
+    }
+    if (errorLower.includes('compile') || errorLower.includes('compilation')) {
+        return 'Compilation error';
+    }
+    // TypeScript errors - be more specific to avoid matching prompt content
+    // Look for actual TypeScript compiler error patterns, not just the word "typescript"
+    const tsErrorPatterns = [
+        /ts\d{4,5}:/i, // TS error codes like TS2304:
+        /error ts\d+/i, // "error TS2304"
+        /\.tsx?:\d+:\d+.*error/i, // file.ts:10:5 - error
+        /type '.*' is not assignable/i, // common TS error message
+        /property '.*' does not exist/i, // common TS error message
+        /cannot find (?:module|name)/i, // common TS error message
+        /typescript.*error/i, // "TypeScript error" but as actual error
+        /tsc.*error/i, // tsc compiler error
+    ];
+    if (tsErrorPatterns.some(pattern => pattern.test(error))) {
+        return 'TypeScript error';
+    }
+    // Syntax errors
+    if (errorLower.includes('syntax error') || errorLower.includes('syntaxerror')) {
+        return 'Syntax error';
+    }
+    // Timeout
+    if (errorLower.includes('timeout') || errorLower.includes('timed out')) {
+        return 'Execution timeout';
+    }
+    // Exit code
+    const exitMatch = error.match(/exit(?:ed)?\s*(?:with)?\s*(?:code)?\s*(\d+)/i);
+    if (exitMatch && exitMatch[1] !== '0') {
+        return `Exit code ${exitMatch[1]}`;
+    }
+    // Crash
+    if (error.startsWith('Crash:')) {
+        return 'Process crashed';
+    }
+    // Default based on failure type
+    if (failureType === 'acceptance') {
+        return 'Failed validation';
+    }
+    // Truncate first line if nothing else matches
+    const firstLine = error.split('\n')[0].trim();
+    if (firstLine.length > 50) {
+        return firstLine.slice(0, 47) + '...';
+    }
+    return firstLine || 'Unknown error';
+}
+/**
+ * Add a retry attempt to the task's retry history
+ */
+function addRetryAttempt(task, failureType, error, durationMs) {
+    const history = task.retryHistory || [];
+    const attempt = {
+        attempt: task.retryCount + 1,
+        timestamp: new Date().toISOString(),
+        failureType,
+        reason: extractFailureReason(error, failureType),
+        fullError: error,
+        durationMs,
+    };
+    return [...history, attempt];
+}
+/**
+ * Main orchestrator class
+ */
+export class Orchestrator {
+    state = null;
+    config;
+    options;
+    logger;
+    constructor(options) {
+        this.options = options;
+        this.config = { ...DEFAULT_CONFIG, ...options.config };
+        this.logger = new Logger(options.projectPath);
+    }
+    log(message) {
+        this.options.onLog?.(message);
+    }
+    get statePath() {
+        return join(this.options.projectPath, this.config.statePath);
+    }
+    /**
+     * Decompose a goal into tasks (first phase of init)
+     * @param goal The project goal
+     * @param projectContext Optional context from discovery phase to inform decomposition
+     */
+    async decompose(goal, projectContext = '') {
+        // Check if Claude Code is available
+        const claudeAvailable = await isClaudeCodeAvailable();
+        if (!claudeAvailable) {
+            return { success: false, tasks: [], error: 'Claude Code CLI not found. Please install it first.' };
+        }
+        // Ensure git is initialized
+        const isRepo = await isGitRepo(this.options.projectPath);
+        if (!isRepo) {
+            this.log('Initializing git repository...');
+            const initResult = await initRepo(this.options.projectPath);
+            if (!initResult.success) {
+                return { success: false, tasks: [], error: `Failed to init git: ${initResult.error}` };
+            }
+        }
+        // Ensure .maistro is in .gitignore
+        this.log('Configuring .gitignore...');
+        const gitignoreResult = await ensureMaistroInGitignore(this.options.projectPath);
+        if (!gitignoreResult.success) {
+            // Log warning but don't fail - this is not critical
+            this.log(`Warning: Could not update .gitignore: ${gitignoreResult.error}`);
+        }
+        // Run Claude's /init command to create CLAUDE.md
+        this.log('Creating project context (CLAUDE.md)...');
+        const claudeInitResult = await runClaudeInit({ cwd: this.options.projectPath });
+        if (!claudeInitResult.success) {
+            // Log note but don't fail - decomposition can proceed without CLAUDE.md
+            this.log(`Note: Could not create CLAUDE.md: ${claudeInitResult.error}`);
+        }
+        // Decompose goal into tasks
+        this.log('Decomposing goal into tasks...');
+        const decomposeResult = await decompose(goal, projectContext, {
+            cwd: this.options.projectPath,
+        });
+        if (!decomposeResult.success) {
+            return { success: false, tasks: [], error: `Failed to decompose goal: ${decomposeResult.error}` };
+        }
+        return { success: true, tasks: decomposeResult.tasks };
+    }
+    /**
+     * Finalize project initialization with approved tasks
+     */
+    async finalize(goal, projectName, tasks) {
+        // Validate dependencies
+        const depValidation = validateTaskDependencies(tasks);
+        if (!depValidation.valid) {
+            return { success: false, error: `Invalid task dependencies: ${depValidation.error}` };
+        }
+        // Sort tasks by dependency
+        const sortedTasks = sortTasksByDependency(tasks);
+        // Create project state
+        this.state = createProjectState(goal, projectName, this.options.projectPath);
+        this.state.tasks = sortedTasks;
+        this.state.status = 'ready';
+        // Save state
+        await saveState(this.statePath, this.state);
+        this.log(`Created ${sortedTasks.length} tasks`);
+        return { success: true };
+    }
+    /**
+     * Initialize a new project with a goal (legacy method for backward compatibility)
+     */
+    async init(goal, projectName) {
+        this.log(`Initializing project: ${projectName}`);
+        const decomposeResult = await this.decompose(goal);
+        if (!decomposeResult.success) {
+            return { success: false, error: decomposeResult.error };
+        }
+        return this.finalize(goal, projectName, decomposeResult.tasks);
+    }
+    /**
+     * Update the task list for an existing project
+     */
+    async updatePlan(tasks) {
+        if (!this.state) {
+            const loadResult = await this.load();
+            if (!loadResult.success) {
+                return { success: false, error: loadResult.error };
+            }
+        }
+        const state = this.state;
+        // Validate dependencies
+        const depValidation = validateTaskDependencies(tasks);
+        if (!depValidation.valid) {
+            return { success: false, error: `Invalid task dependencies: ${depValidation.error}` };
+        }
+        // Sort tasks by dependency
+        const sortedTasks = sortTasksByDependency(tasks);
+        // Update state
+        state.tasks = sortedTasks;
+        state.status = 'ready';
+        state.updatedAt = new Date().toISOString();
+        // Save state
+        await saveState(this.statePath, state);
+        this.log(`Updated plan with ${sortedTasks.length} tasks`);
+        return { success: true };
+    }
+    /**
+     * Get the current goal
+     */
+    async getGoal() {
+        if (!this.state) {
+            await this.load();
+        }
+        return this.state?.goal ?? null;
+    }
+    /**
+     * Load existing project state
+     */
+    async load() {
+        this.state = await loadState(this.statePath);
+        if (!this.state) {
+            return { success: false, error: 'No project found. Run init first.' };
+        }
+        return { success: true };
+    }
+    /**
+     * Sleep helper for retry delays
+     */
+    async sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Check if a task should block execution based on its ifFailed setting
+     */
+    shouldBlockExecution(task) {
+        // Only block if task failed, exceeded retries, and has 'stop' ifFailed setting
+        return task.status === 'failed' &&
+            task.retryCount >= task.maxRetries &&
+            task.ifFailed === 'stop';
+    }
+    /**
+     * Run the orchestration loop
+     */
+    async run() {
+        this.logger.session('start');
+        this.logger.info('Starting orchestration run', { projectPath: this.options.projectPath });
+        if (!this.state) {
+            const loadResult = await this.load();
+            if (!loadResult.success) {
+                this.logger.error('Failed to load project state', { error: loadResult.error });
+                return {
+                    success: false,
+                    completedTasks: 0,
+                    totalTasks: 0,
+                    error: loadResult.error,
+                };
+            }
+        }
+        const state = this.state;
+        const totalTasks = state.tasks.length;
+        this.logger.info('Project loaded', { goal: state.goal, totalTasks });
+        // Reset any in_progress tasks to pending (from interrupted sessions)
+        const inProgressCount = state.tasks.filter(t => t.status === 'in_progress').length;
+        if (inProgressCount > 0) {
+            this.log(`Resetting ${inProgressCount} interrupted task(s) to pending`);
+            this.logger.info('Resetting interrupted tasks', { count: inProgressCount });
+            state.tasks = resetInProgressTasks(state.tasks);
+            await saveState(this.statePath, state);
+        }
+        // Check for tasks that should block execution (failed with ifFailed='stop')
+        const blockingTask = state.tasks.find(t => this.shouldBlockExecution(t));
+        if (blockingTask) {
+            return {
+                success: false,
+                completedTasks: getTaskSummary(state.tasks).completed,
+                totalTasks,
+                error: `Task "${blockingTask.title}" has failed and is marked as critical (ifFailed=stop)`,
+                blockedTask: blockingTask,
+            };
+        }
+        // Check if already complete
+        if (allTasksCompleted(state.tasks)) {
+            return {
+                success: true,
+                completedTasks: totalTasks,
+                totalTasks,
+            };
+        }
+        state.status = 'executing';
+        await saveState(this.statePath, state);
+        // Main execution loop
+        let task;
+        const firstTask = getNextTask(state.tasks);
+        this.logger.debug('Orchestrator.run() first task check', {
+            firstTaskId: firstTask?.id,
+            firstTaskTitle: firstTask?.title,
+            taskStatuses: state.tasks.map(t => ({ id: t.id, status: t.status, deps: t.dependencies })),
+        });
+        while ((task = getNextTask(state.tasks)) !== null) {
+            // Check if user requested stop (e.g., pressed Escape)
+            if (this.options.shouldStop?.()) {
+                this.log('Execution paused by user');
+                state.status = 'paused';
+                await saveState(this.statePath, state);
+                return {
+                    success: false,
+                    completedTasks: getTaskSummary(state.tasks).completed,
+                    totalTasks,
+                    error: 'Execution paused by user',
+                };
+            }
+            const result = await this.executeOneTask(task);
+            if (!result.success) {
+                // Check if this was a user-requested abort
+                if (result.error === 'Execution aborted by user') {
+                    this.log('Execution paused by user');
+                    state.status = 'paused';
+                    await saveState(this.statePath, state);
+                    return {
+                        success: false,
+                        completedTasks: getTaskSummary(state.tasks).completed,
+                        totalTasks,
+                        error: 'Execution paused by user',
+                    };
+                }
+                // Get the updated task from state
+                const updatedTask = state.tasks.find(t => t.id === task.id);
+                if (!updatedTask)
+                    continue;
+                // Handle based on ifFailed setting and retry count
+                if (updatedTask.retryCount >= updatedTask.maxRetries) {
+                    // Exhausted all retries
+                    switch (updatedTask.ifFailed) {
+                        case 'stop':
+                            // Critical task - stop execution
+                            this.log(`Critical task "${task.title}" failed after ${updatedTask.retryCount} retries - stopping execution`);
+                            state.status = 'paused';
+                            await saveState(this.statePath, state);
+                            return {
+                                success: false,
+                                completedTasks: getTaskSummary(state.tasks).completed,
+                                totalTasks,
+                                error: `Critical task "${task.title}" failed after ${updatedTask.retryCount} retries`,
+                                blockedTask: updatedTask,
+                            };
+                        case 'skip':
+                            // Non-critical task - skip and continue (preserve failure info)
+                            this.log(`Task "${task.title}" failed after ${updatedTask.retryCount} retries - skipping (ifFailed=skip)`);
+                            state.tasks = updateTaskStatus(state.tasks, task.id, 'skipped', updatedTask.error);
+                            // Preserve failure reason and retry history when skipping
+                            state.tasks = state.tasks.map(t => t.id === task.id ? {
+                                ...t,
+                                failureReason: updatedTask.failureReason,
+                                failureType: updatedTask.failureType,
+                                retryHistory: updatedTask.retryHistory,
+                            } : t);
+                            await saveState(this.statePath, state);
+                            break;
+                        case 'retry':
+                            // Keep retrying indefinitely (reset retry count)
+                            this.log(`Task "${task.title}" failed - will keep retrying (ifFailed=retry)`);
+                            state.tasks = state.tasks.map(t => t.id === task.id
+                                ? { ...t, status: 'pending', retryCount: 0 }
+                                : t);
+                            await saveState(this.statePath, state);
+                            break;
+                    }
+                }
+                else {
+                    // Still have retries left - schedule retry with delay
+                    const retryDelayMs = this.config.retryDelayMs;
+                    const nextAttempt = updatedTask.retryCount + 1;
+                    this.log(`Task "${task.title}" failed (attempt ${updatedTask.retryCount}/${updatedTask.maxRetries}) - retrying in ${retryDelayMs / 1000}s`);
+                    this.options.onRetry?.(updatedTask, nextAttempt, updatedTask.maxRetries, retryDelayMs);
+                    // Reset task to pending for retry, preserving error and failureType for feedback in next attempt
+                    state.tasks = state.tasks.map(t => t.id === task.id
+                        ? { ...t, status: 'pending', error: updatedTask.error, failureType: updatedTask.failureType }
+                        : t);
+                    await saveState(this.statePath, state);
+                    // Wait before retry
+                    await this.sleep(retryDelayMs);
+                }
+            }
+            // Report progress
+            const summary = getTaskSummary(state.tasks);
+            this.options.onProgress?.(summary.completed, totalTasks);
+        }
+        // Check if all tasks actually completed
+        const finalSummary = getTaskSummary(state.tasks);
+        this.logger.debug('Orchestrator.run() after main loop', {
+            completed: finalSummary.completed,
+            failed: finalSummary.failed,
+            pending: finalSummary.pending,
+            taskStatuses: state.tasks.map(t => ({ id: t.id, status: t.status })),
+        });
+        if (allTasksCompleted(state.tasks)) {
+            state.status = 'completed';
+            await saveState(this.statePath, state);
+            return {
+                success: true,
+                completedTasks: finalSummary.completed,
+                totalTasks,
+            };
+        }
+        // Some tasks failed - find if any are blocking (ifFailed=stop)
+        const stoppedTask = state.tasks.find(t => this.shouldBlockExecution(t));
+        if (stoppedTask) {
+            state.status = 'paused';
+            await saveState(this.statePath, state);
+            return {
+                success: false,
+                completedTasks: finalSummary.completed,
+                totalTasks,
+                error: `Critical task "${stoppedTask.title}" failed: ${stoppedTask.error || 'Unknown error'}`,
+                blockedTask: stoppedTask,
+            };
+        }
+        // No blocking tasks - consider it complete (skipped tasks are OK)
+        state.status = 'completed';
+        await saveState(this.statePath, state);
+        return {
+            success: true,
+            completedTasks: finalSummary.completed,
+            totalTasks,
+        };
+    }
+    /**
+     * Build project context for task execution
+     */
+    buildProjectContext(task) {
+        const state = this.state;
+        const taskIndex = state.tasks.findIndex(t => t.id === task.id);
+        const completedTasks = state.tasks
+            .filter(t => t.status === 'completed')
+            .map(t => ({ title: t.title, description: t.description }));
+        const pendingTasks = state.tasks
+            .filter(t => t.status === 'pending' && t.id !== task.id)
+            .map(t => ({ title: t.title, description: t.description }));
+        return {
+            goal: state.goal,
+            projectName: state.projectName,
+            completedTasks,
+            pendingTasks,
+            currentTaskIndex: taskIndex,
+            totalTasks: state.tasks.length,
+        };
+    }
+    /**
+     * Execute a single task with robust error handling
+     */
+    async executeOneTask(task) {
+        const state = this.state;
+        const taskIndex = state.tasks.findIndex(t => t.id === task.id);
+        const totalTasks = state.tasks.length;
+        this.log(`Starting task: ${task.title} (attempt ${task.retryCount + 1}/${task.maxRetries})`);
+        this.logger.taskStart(task.id, task.title, taskIndex, totalTasks);
+        this.logger.taskPhase(task.id, 'executing');
+        this.options.onTaskStart?.(task);
+        const taskStartTime = Date.now();
+        // Wrap onOutput to also log to task-specific log
+        const wrappedOnOutput = (line) => {
+            this.logger.taskOutput(task.id, line);
+            this.options.onOutput?.(line);
+        };
+        // Extract image references from task description
+        const imageRefs = extractImagePlaceholders(task.description);
+        if (imageRefs.length > 0) {
+            // Update task with extracted image references
+            task.imageRefs = imageRefs;
+            state.tasks = state.tasks.map(t => t.id === task.id ? { ...t, imageRefs } : t);
+            this.logger.info('Extracted image references', { taskId: task.id, imageRefs });
+        }
+        // Mark task as in progress
+        state.tasks = updateTaskStatus(state.tasks, task.id, 'in_progress');
+        await saveState(this.statePath, state);
+        // Use per-task timeout, falling back to config default
+        const taskTimeout = task.timeout || this.config.executionTimeout;
+        // Capture result summary for successful tasks (set inside try block)
+        let resultSummary;
+        try {
+            // Build context (file paths only - Claude Code reads content itself)
+            const context = await buildContext(task, this.options.projectPath);
+            this.log(`Context: ${context.fileCount} files`);
+            this.logger.info('Context built', { taskId: task.id, fileCount: context.fileCount });
+            // Build project context for full awareness
+            const projectContext = this.buildProjectContext(task);
+            // Execute task with per-task timeout
+            let execResult;
+            // Get image metadata for this task
+            const imageMetadata = state.images;
+            if (task.retryCount > 0 && task.error) {
+                // Retry with feedback about previous error
+                execResult = await executeTaskWithFeedback(task, context, task.error, {
+                    cwd: this.options.projectPath,
+                    timeout: taskTimeout,
+                    onOutput: wrappedOnOutput,
+                    shouldAbort: this.options.shouldStop,
+                }, projectContext, imageMetadata);
+            }
+            else {
+                execResult = await executeTask(task, context, {
+                    cwd: this.options.projectPath,
+                    timeout: taskTimeout,
+                    onOutput: wrappedOnOutput,
+                    shouldAbort: this.options.shouldStop,
+                }, projectContext, imageMetadata);
+            }
+            if (!execResult.success) {
+                // Check if this was a user-requested abort (exitCode -2)
+                if (execResult.exitCode === -2) {
+                    this.log(`Task execution aborted by user`);
+                    this.logger.info('Task execution aborted by user', { taskId: task.id });
+                    // Reset task to pending so it can be resumed later
+                    state.tasks = updateTaskStatus(state.tasks, task.id, 'pending');
+                    await saveState(this.statePath, state);
+                    // Return special error to indicate abort (not a real failure)
+                    return { success: false, error: 'Execution aborted by user' };
+                }
+                this.log(`Task execution failed: ${execResult.error}`);
+                this.logger.error('Task execution failed', { taskId: task.id, error: execResult.error, exitCode: execResult.exitCode });
+                state.tasks = updateTaskStatus(state.tasks, task.id, 'failed', execResult.error);
+                // Save duration, failure type, reason, and retry history
+                const taskDuration = Date.now() - taskStartTime;
+                const failureType = 'execution';
+                const failureReason = extractFailureReason(execResult.error, failureType);
+                const currentTask = state.tasks.find(t => t.id === task.id);
+                const retryHistory = addRetryAttempt(currentTask, failureType, execResult.error, taskDuration);
+                state.tasks = state.tasks.map(t => t.id === task.id ? {
+                    ...t,
+                    durationMs: taskDuration,
+                    failureType,
+                    failureReason,
+                    retryHistory,
+                } : t);
+                await saveState(this.statePath, state);
+                this.logger.taskComplete(task.id, task.title, false, taskDuration, execResult.error);
+                this.options.onTaskComplete?.(task, false);
+                return { success: false, error: execResult.error };
+            }
+            this.logger.info('Task execution succeeded', { taskId: task.id, exitCode: execResult.exitCode });
+            // Stage all changes so git diff includes new files
+            const stageResult = await stageAll(this.options.projectPath);
+            if (!stageResult.success) {
+                this.logger.warn('Failed to stage changes', { taskId: task.id, error: stageResult.error });
+            }
+            // Validate using staged diff (includes new files)
+            this.log('Validating changes...');
+            this.logger.taskPhase(task.id, 'validating');
+            const validationResult = await validate(task, {
+                cwd: this.options.projectPath,
+                useAIReview: this.config.useAIReview,
+                useStagedDiff: true,
+            });
+            this.logger.validation(task.id, validationResult.passed, validationResult.details);
+            // Store acceptance criteria results regardless of pass/fail (for visibility)
+            if (validationResult.acceptanceCriteriaResults) {
+                state.tasks = state.tasks.map(t => t.id === task.id ? {
+                    ...t,
+                    acceptanceCriteriaResults: validationResult.acceptanceCriteriaResults,
+                } : t);
+                // Log each criterion result to task log
+                for (const result of validationResult.acceptanceCriteriaResults) {
+                    this.logger.taskAcceptanceCriteria(task.id, result.criterion, result.passed, result.explanation);
+                }
+                // Log which criteria failed for debugging
+                const failedCriteria = validationResult.acceptanceCriteriaResults.filter(r => !r.passed);
+                if (failedCriteria.length > 0) {
+                    this.logger.info('Acceptance criteria failures', {
+                        taskId: task.id,
+                        failedCount: failedCriteria.length,
+                        totalCount: validationResult.acceptanceCriteriaResults.length,
+                        failed: failedCriteria.map(r => r.criterion),
+                    });
+                }
+            }
+            if (!validationResult.passed) {
+                // Unstage changes so Claude Code can retry with clean state
+                await unstageAll(this.options.projectPath);
+                this.log(`Validation failed: ${validationResult.details}`);
+                state.tasks = updateTaskStatus(state.tasks, task.id, 'failed', validationResult.details);
+                // Save duration, failure type, reason, and retry history
+                const taskDuration = Date.now() - taskStartTime;
+                const failureType = 'acceptance';
+                const failureReason = extractFailureReason(validationResult.details, failureType);
+                const currentTask = state.tasks.find(t => t.id === task.id);
+                const retryHistory = addRetryAttempt(currentTask, failureType, validationResult.details, taskDuration);
+                state.tasks = state.tasks.map(t => t.id === task.id ? {
+                    ...t,
+                    durationMs: taskDuration,
+                    failureType,
+                    failureReason,
+                    retryHistory,
+                } : t);
+                await saveState(this.statePath, state);
+                this.logger.taskComplete(task.id, task.title, false, taskDuration, validationResult.details);
+                this.options.onTaskComplete?.(task, false);
+                return { success: false, error: validationResult.details };
+            }
+            // Capture result summary for use after try/catch
+            resultSummary = validationResult.resultSummary;
+        }
+        catch (error) {
+            // Catch any unexpected errors (crashes, exceptions) to prevent maistro from crashing
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.log(`Task crashed with error: ${errorMessage}`);
+            this.logger.error('Task crashed with exception', { taskId: task.id, error: errorMessage });
+            const crashError = `Crash: ${errorMessage}`;
+            state.tasks = updateTaskStatus(state.tasks, task.id, 'failed', crashError);
+            const taskDuration = Date.now() - taskStartTime;
+            const failureType = 'execution';
+            const failureReason = 'Process crashed';
+            const currentTask = state.tasks.find(t => t.id === task.id);
+            const retryHistory = addRetryAttempt(currentTask, failureType, crashError, taskDuration);
+            state.tasks = state.tasks.map(t => t.id === task.id ? {
+                ...t,
+                durationMs: taskDuration,
+                failureType,
+                failureReason,
+                retryHistory,
+            } : t);
+            await saveState(this.statePath, state);
+            this.logger.taskComplete(task.id, task.title, false, taskDuration, crashError);
+            this.options.onTaskComplete?.(task, false);
+            return { success: false, error: crashError };
+        }
+        // Commit changes
+        this.logger.taskPhase(task.id, 'committing');
+        if (await hasChanges(this.options.projectPath)) {
+            const commitResult = await commitAll(this.options.projectPath, `[maistro] ${task.title}`);
+            this.logger.git('commit', commitResult.success, commitResult.error);
+            if (!commitResult.success) {
+                this.log(`Git commit failed: ${commitResult.error}`);
+                // Don't fail the task for git errors
+            }
+            else {
+                this.log('Changes committed');
+            }
+        }
+        // Mark complete with duration
+        // Preserve retryHistory and retryCount so users can see if there was friction
+        const taskDuration = Date.now() - taskStartTime;
+        const currentTask = state.tasks.find(t => t.id === task.id);
+        state.tasks = updateTaskStatus(state.tasks, task.id, 'completed');
+        state.tasks = state.tasks.map(t => t.id === task.id ? {
+            ...t,
+            durationMs: taskDuration,
+            // Store result summary from validation
+            resultSummary,
+            // Preserve retry info to show friction history
+            retryHistory: currentTask.retryHistory,
+            retryCount: currentTask.retryCount,
+            // Clear transient error fields since task succeeded
+            error: undefined,
+            failureType: undefined,
+            failureReason: undefined,
+        } : t);
+        await saveState(this.statePath, state);
+        this.log(`Task completed: ${task.title}`);
+        this.logger.taskComplete(task.id, task.title, true, taskDuration);
+        this.options.onTaskComplete?.(task, true);
+        return { success: true };
+    }
+    /**
+     * Get current project status
+     */
+    async getStatus() {
+        if (!this.state) {
+            const loadResult = await this.load();
+            if (!loadResult.success) {
+                return null;
+            }
+        }
+        const state = this.state;
+        const summary = getTaskSummary(state.tasks);
+        const currentTask = state.tasks.find(t => t.status === 'in_progress');
+        return {
+            status: state.status,
+            goal: state.goal,
+            tasks: {
+                total: state.tasks.length,
+                completed: summary.completed,
+                pending: summary.pending,
+                failed: summary.failed,
+                inProgress: summary.in_progress,
+                skipped: summary.skipped,
+            },
+            currentTask,
+        };
+    }
+    /**
+     * Get all tasks
+     */
+    async getTasks() {
+        if (!this.state) {
+            await this.load();
+        }
+        return this.state?.tasks ?? [];
+    }
+    /**
+     * Skip a failed task
+     */
+    async skipTask(taskId) {
+        if (!this.state) {
+            const loadResult = await this.load();
+            if (!loadResult.success) {
+                return { success: false, error: loadResult.error };
+            }
+        }
+        const state = this.state;
+        const task = state.tasks.find(t => t.id === taskId);
+        if (!task) {
+            return { success: false, error: `Task ${taskId} not found` };
+        }
+        if (task.status !== 'failed') {
+            return { success: false, error: `Task ${taskId} is not failed` };
+        }
+        state.tasks = updateTaskStatus(state.tasks, taskId, 'skipped');
+        await saveState(this.statePath, state);
+        this.log(`Skipped task: ${task.title}`);
+        return { success: true };
+    }
+    /**
+     * Retry a failed task
+     */
+    async retryTask(taskId) {
+        if (!this.state) {
+            const loadResult = await this.load();
+            if (!loadResult.success) {
+                return { success: false, error: loadResult.error };
+            }
+        }
+        const state = this.state;
+        const task = state.tasks.find(t => t.id === taskId);
+        if (!task) {
+            return { success: false, error: `Task ${taskId} not found` };
+        }
+        // Reset task for retry
+        state.tasks = state.tasks.map(t => {
+            if (t.id !== taskId)
+                return t;
+            return {
+                ...t,
+                status: 'pending',
+                retryCount: 0,
+                error: undefined,
+                updatedAt: new Date().toISOString(),
+            };
+        });
+        await saveState(this.statePath, state);
+        this.log(`Reset task for retry: ${task.title}`);
+        return { success: true };
+    }
+    /**
+     * Clear the current plan (goal and all tasks) while preserving logs
+     * Resets the project to a clean state ready for a new goal
+     */
+    async clearPlan() {
+        if (!this.state) {
+            const loadResult = await this.load();
+            if (!loadResult.success) {
+                return { success: false, error: loadResult.error };
+            }
+        }
+        const state = this.state;
+        // Log the clear action
+        this.logger.info('Clearing plan', {
+            previousGoal: state.goal,
+            taskCount: state.tasks.length,
+        });
+        // Reset state while preserving project path and timestamps
+        state.goal = '';
+        state.projectName = '';
+        state.tasks = [];
+        state.currentTaskIndex = 0;
+        state.status = 'idle';
+        state.updatedAt = new Date().toISOString();
+        // Keep images - user may want to reuse them
+        // Keep inputHistory - preserves user's command history
+        await saveState(this.statePath, state);
+        this.log('Plan cleared');
+        return { success: true };
+    }
+}
+/**
+ * Create and initialize an orchestrator
+ */
+export async function createOrchestrator(options) {
+    return new Orchestrator(options);
+}
+//# sourceMappingURL=orchestrator.js.map