task-o-matic 0.0.11 → 0.0.13

package/dist/lib/task-execution-core.js

@@ -0,0 +1,360 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTaskCore = executeTaskCore;
+const tasks_1 = require("../services/tasks");
+const executor_factory_1 = require("./executors/executor-factory");
+const validation_1 = require("./validation");
+const ai_service_factory_1 = require("../utils/ai-service-factory");
+const hooks_1 = require("./hooks");
+const prompt_builder_1 = require("./prompt-builder");
+const task_planning_1 = require("./task-planning");
+const task_review_1 = require("./task-review");
+const git_utils_1 = require("./git-utils");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Execute a single task with all features (retry, planning, review, etc.)
+ * This is the core unified execution logic used by both execute and execute-loop commands
+ */
+async function executeTaskCore(taskId, config) {
+    const { tool, executorConfig, customMessage, verificationCommands = [], enableRetry = false, maxRetries = 3, tryModels, enablePlanPhase = false, planModel, reviewPlan = false, enableReviewPhase = false, reviewModel, autoCommit: enableAutoCommit = false, executeSubtasks = true, dry = false, } = config;
+    // Load task
+    const task = await tasks_1.taskService.getTask(taskId);
+    if (!task) {
+        throw new Error(`Task with ID ${taskId} not found`);
+    }
+    // Check if task has subtasks and should execute them recursively
+    if (executeSubtasks && !customMessage) {
+        const subtasks = await tasks_1.taskService.getSubtasks(taskId);
+        if (subtasks.length > 0) {
+            return await executeTaskWithSubtasks(task, subtasks, config);
+        }
+    }
+    // ----------------------------------------------------------------------
+    // PLANNING PHASE
+    // ----------------------------------------------------------------------
+    let planContent;
+    if (enablePlanPhase) {
+        const planningResult = await (0, task_planning_1.executePlanningPhase)(task, tool, {
+            planModel,
+            reviewPlan,
+            autoCommit: enableAutoCommit,
+            dry,
+        });
+        if (planningResult.success && planningResult.planContent) {
+            planContent = planningResult.planContent;
+        }
+    }
+    // ----------------------------------------------------------------------
+    // EXECUTION PHASE (with optional retry logic)
+    // ----------------------------------------------------------------------
+    const attempts = [];
+    if (enableRetry) {
+        // Execute with retry logic
+        return await executeTaskWithRetry(task, config, attempts, planContent);
+    }
+    else {
+        // Execute once without retry (simpler path for execute command)
+        return await executeSingleAttempt(task, config, attempts, planContent, 1, maxRetries);
+    }
+}
+/**
+ * Execute task with subtasks recursively
+ */
+async function executeTaskWithSubtasks(task, subtasks, config) {
+    const { dry } = config;
+    console.log(chalk_1.default.blue(`📋 Task has ${subtasks.length} subtasks, executing recursively...`));
+    const subtaskResults = [];
+    let allSuccess = true;
+    // Execute subtasks one by one
+    for (let i = 0; i < subtasks.length; i++) {
+        const subtask = subtasks[i];
+        console.log(chalk_1.default.cyan(`\n[${i + 1}/${subtasks.length}] Executing subtask: ${subtask.title} (${subtask.id})`));
+        try {
+            const result = await executeTaskCore(subtask.id, config);
+            subtaskResults.push(result);
+            if (!result.success) {
+                allSuccess = false;
+                console.error(chalk_1.default.red(`❌ Failed to execute subtask ${subtask.id}: ${subtask.title}`));
+                break; // Stop on first failure
+            }
+        }
+        catch (error) {
+            allSuccess = false;
+            console.error(chalk_1.default.red(`❌ Failed to execute subtask ${subtask.id}: ${error instanceof Error ? error.message : "Unknown error"}`));
+            break;
+        }
+    }
+    // After all subtasks are done (or on failure), update the main task status
+    if (!dry) {
+        if (allSuccess) {
+            await tasks_1.taskService.setTaskStatus(task.id, "completed");
+            console.log(chalk_1.default.green(`✅ Main task ${task.title} completed after all subtasks`));
+        }
+        else {
+            await tasks_1.taskService.setTaskStatus(task.id, "todo");
+            console.log(chalk_1.default.red(`❌ Main task ${task.title} failed due to subtask failure, status reset to todo`));
+        }
+    }
+    return {
+        success: allSuccess,
+        attempts: [], // Parent task doesn't have its own attempts
+        subtaskResults,
+    };
+}
+/**
+ * Execute task with retry logic
+ */
+async function executeTaskWithRetry(task, config, attempts, planContent) {
+    const { tool, maxRetries = 3, tryModels, verificationCommands = [], enableReviewPhase = false, reviewModel, autoCommit: enableAutoCommit = false, dry = false, } = config;
+    let currentAttempt = 1;
+    let lastError;
+    while (currentAttempt <= maxRetries) {
+        // Determine which executor and model to use for this attempt
+        let currentExecutor = tool;
+        let currentModel;
+        if (tryModels && tryModels.length > 0) {
+            const modelConfigIndex = Math.min(currentAttempt - 1, tryModels.length - 1);
+            const modelConfig = tryModels[modelConfigIndex];
+            if (modelConfig.executor) {
+                currentExecutor = modelConfig.executor;
+            }
+            if (modelConfig.model) {
+                currentModel = modelConfig.model;
+            }
+        }
+        console.log(chalk_1.default.blue(`\n🎯 Attempt ${currentAttempt}/${maxRetries} for task: ${task.title} (${task.id})`));
+        if (currentModel) {
+            console.log(chalk_1.default.cyan(`   Using executor: ${currentExecutor} with model: ${currentModel}`));
+        }
+        else {
+            console.log(chalk_1.default.cyan(`   Using executor: ${currentExecutor}`));
+        }
+        // Build retry context if this is a retry attempt
+        let retryContext = "";
+        if (currentAttempt > 1 && lastError) {
+            const retryParts = [];
+            retryParts.push(`# RETRY ATTEMPT ${currentAttempt}/${maxRetries}\n\n`);
+            if (currentModel) {
+                retryParts.push(`**Note**: You are ${currentExecutor} using the ${currentModel} model. This is a more capable model than the previous attempt.\n\n`);
+            }
+            retryParts.push(`## Previous Attempt Failed With Error:\n\n${lastError}\n\n`);
+            retryParts.push(`Please analyze the error carefully and fix it. The error might be due to:\n`);
+            retryParts.push(`- Syntax errors\n`);
+            retryParts.push(`- Logic errors\n`);
+            retryParts.push(`- Missing dependencies or imports\n`);
+            retryParts.push(`- Incorrect configuration\n`);
+            retryParts.push(`- Build or test failures\n\n`);
+            retryParts.push(`Please fix the error above and complete the task successfully.\n\n`);
+            retryContext = retryParts.join("");
+        }
+        // Update executor config for this attempt
+        const attemptConfig = {
+            ...config,
+            tool: currentExecutor,
+            executorConfig: {
+                ...config.executorConfig,
+                model: currentModel,
+                continueLastSession: currentAttempt > 1, // Resume session on retries
+            },
+        };
+        try {
+            const result = await executeSingleAttempt(task, attemptConfig, attempts, planContent, currentAttempt, maxRetries, retryContext);
+            // Check if all verifications passed
+            const allVerificationsPassed = result.attempts[result.attempts.length - 1]
+                ?.verificationResults?.every((r) => r.success) ?? true;
+            if (!allVerificationsPassed) {
+                const failedVerification = result.attempts[result.attempts.length - 1]
+                    ?.verificationResults?.find((r) => !r.success);
+                lastError = `Verification command "${failedVerification?.command}" failed:\n${failedVerification?.error}`;
+                currentAttempt++;
+                continue;
+            }
+            // ----------------------------------------------------------------------
+            // AI REVIEW PHASE
+            // ----------------------------------------------------------------------
+            if (enableReviewPhase && !dry) {
+                const reviewResult = await (0, task_review_1.executeReviewPhase)(task, {
+                    reviewModel,
+                    planContent,
+                    dry,
+                });
+                if (!reviewResult.approved) {
+                    lastError = `AI Review Failed:\n${reviewResult.feedback}`;
+                    console.log(chalk_1.default.red(`❌ AI Review Rejected Changes: ${reviewResult.feedback}`));
+                    currentAttempt++;
+                    continue;
+                }
+                else {
+                    console.log(chalk_1.default.green(`✅ AI Review Approved: ${reviewResult.feedback}`));
+                    result.reviewFeedback = reviewResult.feedback;
+                }
+            }
+            // Success! Return the result
+            return result;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+            console.log(chalk_1.default.red(`❌ Task execution failed on attempt ${currentAttempt}: ${lastError}`));
+            if (!dry && currentAttempt < maxRetries) {
+                await tasks_1.taskService.setTaskStatus(task.id, "todo");
+                console.log(chalk_1.default.yellow("⏸  Task status reset to todo for retry"));
+            }
+            currentAttempt++;
+        }
+    }
+    // All retries exhausted
+    if (!dry) {
+        await tasks_1.taskService.setTaskStatus(task.id, "todo");
+        console.log(chalk_1.default.red("❌ All retry attempts exhausted, task status reset to todo"));
+    }
+    return {
+        success: false,
+        attempts,
+    };
+}
+/**
+ * Execute a single attempt of the task
+ */
+async function executeSingleAttempt(task, config, attempts, planContent, attemptNumber, maxRetries, retryContext) {
+    const { tool, executorConfig, customMessage, verificationCommands = [], autoCommit: enableAutoCommit = false, dry = false, } = config;
+    const attemptStartTime = Date.now();
+    console.log(chalk_1.default.blue(`🎯 ${dry ? "DRY RUN" : "Executing"} task: ${task.title} (${task.id})`));
+    // Capture git state before execution
+    const gitStateBefore = await (0, git_utils_1.captureGitState)();
+    // Build execution message
+    let executionMessage;
+    if (customMessage) {
+        // Use custom message override
+        executionMessage = customMessage;
+        console.log(chalk_1.default.cyan("📝 Using custom execution message"));
+    }
+    else {
+        // Build comprehensive execution message with full context
+        const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
+        const taskContext = await contextBuilder.buildContext(task.id);
+        // Get task plan if available
+        const storedPlanData = await tasks_1.taskService.getTaskPlan(task.id);
+        let finalPlan;
+        if (planContent) {
+            finalPlan = `${planContent}\n\nPlease follow this plan to implement the task.`;
+        }
+        else if (storedPlanData) {
+            finalPlan = storedPlanData.plan;
+        }
+        // Build execution prompt using PromptBuilder
+        const promptResult = prompt_builder_1.PromptBuilder.buildExecutionPrompt({
+            taskTitle: task.title,
+            taskDescription: task.description,
+            taskPlan: finalPlan,
+            stack: taskContext.stack,
+            documentation: taskContext.documentation,
+            retryContext,
+        });
+        if (!promptResult.success) {
+            throw new Error(`Failed to build execution prompt: ${promptResult.error}`);
+        }
+        executionMessage = promptResult.prompt;
+    }
+    // Update task status to in-progress
+    if (!dry) {
+        await tasks_1.taskService.setTaskStatus(task.id, "in-progress");
+        console.log(chalk_1.default.yellow("⏳ Task status updated to in-progress"));
+    }
+    // Emit execution:start event
+    await hooks_1.hooks.emit("execution:start", { taskId: task.id, tool });
+    try {
+        // Create executor and run
+        const executor = executor_factory_1.ExecutorFactory.create(tool, executorConfig);
+        // Log session resumption if applicable
+        if (executorConfig?.continueLastSession && attemptNumber > 1) {
+            console.log(chalk_1.default.cyan("🔄 Resuming previous session to provide error feedback to AI"));
+        }
+        await executor.execute(executionMessage, dry, executorConfig);
+        // Run verification commands
+        const verificationResults = await (0, validation_1.runValidations)(verificationCommands, dry);
+        const allVerificationsPassed = verificationResults.every((r) => r.success);
+        if (!allVerificationsPassed) {
+            const failedVerification = verificationResults.find((r) => !r.success);
+            const error = `Verification command "${failedVerification?.command}" failed:\n${failedVerification?.error}`;
+            attempts.push({
+                attemptNumber,
+                success: false,
+                error,
+                executor: tool,
+                model: executorConfig?.model,
+                verificationResults,
+                timestamp: Date.now() - attemptStartTime,
+            });
+            console.log(chalk_1.default.red(`❌ Task execution failed verification on attempt ${attemptNumber}`));
+            throw new Error(error);
+        }
+        // Extract commit info if enabled
+        let commitInfo;
+        if (enableAutoCommit && !dry) {
+            console.log(chalk_1.default.blue("📝 Extracting commit information..."));
+            const gitStateAfter = await (0, git_utils_1.captureGitState)();
+            const gitState = {
+                beforeHead: gitStateBefore.beforeHead || "",
+                afterHead: gitStateAfter.afterHead || "",
+                hasUncommittedChanges: gitStateAfter.hasUncommittedChanges || false,
+            };
+            commitInfo = await (0, git_utils_1.extractCommitInfo)(task.id, task.title, executionMessage, gitState);
+            console.log(chalk_1.default.green(`✅ Commit message: ${commitInfo.message}`));
+            if (commitInfo.files.length > 0) {
+                console.log(chalk_1.default.green(`📁 Changed files: ${commitInfo.files.join(", ")}`));
+            }
+            // Auto-commit the changes
+            await (0, git_utils_1.autoCommit)(commitInfo);
+        }
+        // Update task status to completed
+        if (!dry) {
+            await tasks_1.taskService.setTaskStatus(task.id, "completed");
+            console.log(chalk_1.default.green("✅ Task execution completed successfully"));
+        }
+        // Record successful attempt
+        attempts.push({
+            attemptNumber,
+            success: true,
+            executor: tool,
+            model: executorConfig?.model,
+            verificationResults,
+            commitInfo,
+            timestamp: Date.now() - attemptStartTime,
+        });
+        // Emit execution:end event
+        await hooks_1.hooks.emit("execution:end", { taskId: task.id, success: true });
+        return {
+            success: true,
+            attempts,
+            commitInfo,
+            planContent,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Record failed attempt if not already recorded
+        if (attempts.length === 0 || attempts[attempts.length - 1].attemptNumber !== attemptNumber) {
+            attempts.push({
+                attemptNumber,
+                success: false,
+                error: errorMessage,
+                executor: tool,
+                model: executorConfig?.model,
+                timestamp: Date.now() - attemptStartTime,
+            });
+        }
+        // Emit execution:error event
+        await hooks_1.hooks.emit("execution:error", {
+            taskId: task.id,
+            error: error instanceof Error ? error : new Error(String(error)),
+        });
+        if (!dry) {
+            await tasks_1.taskService.setTaskStatus(task.id, "todo");
+            console.log(chalk_1.default.red("❌ Task execution failed, status reset to todo"));
+        }
+        throw error;
+    }
+}

package/dist/lib/task-execution.d.ts

@@ -1,3 +1,7 @@
 import { ExecuteTaskOptions } from "../types";
+/**
+ * Execute a task using an external coding assistant
+ * This is the simplified entry point that delegates to the unified core
+ */
 export declare function executeTask(options: ExecuteTaskOptions): Promise<void>;
 //# sourceMappingURL=task-execution.d.ts.map

package/dist/lib/task-execution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-execution.d.ts","sourceRoot":"","sources":["../../src/lib/task-execution.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAgC,MAAM,UAAU,CAAC;AAgM5E,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgF5E"}
+{"version":3,"file":"task-execution.d.ts","sourceRoot":"","sources":["../../src/lib/task-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAEnB,MAAM,UAAU,CAAC;AAGlB;;;GAGG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiD5E"}

package/dist/lib/task-execution.js

@@ -1,186 +1,39 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeTask = executeTask;
-const tasks_1 = require("../services/tasks");
-const executor_factory_1 = require("./executors/executor-factory");
-const validation_1 = require("./validation");
-const ai_service_factory_1 = require("../utils/ai-service-factory");
-const hooks_1 = require("./hooks");
-const chalk_1 = __importDefault(require("chalk"));
-async function executeSingleTask(taskId, tool, dry, executorConfig) {
-    // Load task
-    const task = await tasks_1.taskService.getTask(taskId);
-    if (!task) {
-        throw new Error(`Task with ID ${taskId} not found`);
-    }
-    console.log(chalk_1.default.blue(`🎯 ${dry ? "DRY RUN" : "Executing"} task: ${task.title} (${taskId})`));
-    // Build comprehensive execution message with full context
-    const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
-    const taskContext = await contextBuilder.buildContext(taskId);
-    // Build execution message with ALL context
-    const messageParts = [];
-    // Add task plan if available
-    const planData = await tasks_1.taskService.getTaskPlan(taskId);
-    if (planData) {
-        messageParts.push(`# Task Plan\n\n${planData.plan}\n`);
-    }
-    else {
-        messageParts.push(`# Task: ${task.title}\n\n${task.description || "No description"}\n`);
-    }
-    // Add PRD context if available
-    if (taskContext.prdContent) {
-        messageParts.push(`\n# Product Requirements Document\n\n${taskContext.prdContent}\n`);
-    }
-    // Add stack/technology context
-    if (taskContext.stack) {
-        messageParts.push(`\n# Technology Stack\n\n`);
-        messageParts.push(`- **Project**: ${taskContext.stack.projectName}\n`);
-        messageParts.push(`- **Frontend**: ${taskContext.stack.frontend}\n`);
-        messageParts.push(`- **Backend**: ${taskContext.stack.backend}\n`);
-        if (taskContext.stack.database !== "none") {
-            messageParts.push(`- **Database**: ${taskContext.stack.database}\n`);
-        }
-        if (taskContext.stack.orm !== "none") {
-            messageParts.push(`- **ORM**: ${taskContext.stack.orm}\n`);
-        }
-        messageParts.push(`- **Auth**: ${taskContext.stack.auth}\n`);
-        if (taskContext.stack.addons.length > 0) {
-            messageParts.push(`- **Addons**: ${taskContext.stack.addons.join(", ")}\n`);
-        }
-        messageParts.push(`- **Package Manager**: ${taskContext.stack.packageManager}\n`);
-    }
-    // Add documentation context if available
-    if (taskContext.documentation) {
-        messageParts.push(`\n# Documentation Context\n\n`);
-        messageParts.push(`${taskContext.documentation.recap}\n`);
-        if (taskContext.documentation.files.length > 0) {
-            messageParts.push(`\n**Relevant Documentation Files**:\n`);
-            taskContext.documentation.files.forEach((file) => {
-                messageParts.push(`- ${file.path}\n`);
-            });
-        }
-    }
-    const executionMessage = messageParts.join("");
-    if (!dry) {
-        // Update task status to in-progress
-        await tasks_1.taskService.setTaskStatus(taskId, "in-progress");
-        console.log(chalk_1.default.yellow("⏳ Task status updated to in-progress"));
-    }
-    // Emit execution:start event
-    await hooks_1.hooks.emit("execution:start", { taskId, tool });
-    try {
-        // Create executor and run
-        const executor = executor_factory_1.ExecutorFactory.create(tool, executorConfig);
-        await executor.execute(executionMessage, dry, executorConfig);
-        if (!dry) {
-            // Update task status to completed
-            await tasks_1.taskService.setTaskStatus(taskId, "completed");
-            console.log(chalk_1.default.green("✅ Task execution completed successfully"));
-        }
-        // Emit execution:end event
-        await hooks_1.hooks.emit("execution:end", { taskId, success: true });
-    }
-    catch (error) {
-        // Emit execution:error event
-        await hooks_1.hooks.emit("execution:error", {
-            taskId,
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-        if (!dry) {
-            // Update task status back to todo on failure
-            await tasks_1.taskService.setTaskStatus(taskId, "todo");
-            console.log(chalk_1.default.red("❌ Task execution failed, status reset to todo"));
-        }
-        throw error;
-    }
-}
-async function executeTaskWithSubtasks(taskId, tool, dry, executorConfig) {
-    const task = await tasks_1.taskService.getTask(taskId);
-    if (!task) {
-        throw new Error(`Task with ID ${taskId} not found`);
-    }
-    // Get subtasks
-    const subtasks = await tasks_1.taskService.getSubtasks(taskId);
-    if (subtasks.length === 0) {
-        // No subtasks, execute this task directly
-        await executeSingleTask(taskId, tool, dry);
-        return;
-    }
-    // Has subtasks - execute them one by one
-    console.log(chalk_1.default.blue(`📋 Task has ${subtasks.length} subtasks, executing recursively...`));
-    for (let i = 0; i < subtasks.length; i++) {
-        const subtask = subtasks[i];
-        console.log(chalk_1.default.cyan(`\n[${i + 1}/${subtasks.length}] Executing subtask: ${subtask.title} (${subtask.id})`));
-        try {
-            await executeTaskWithSubtasks(subtask.id, tool, dry, executorConfig);
-        }
-        catch (error) {
-            console.error(chalk_1.default.red(`❌ Failed to execute subtask ${subtask.id}: ${error instanceof Error ? error.message : "Unknown error"}`));
-            throw error;
-        }
-    }
-    // After all subtasks are done, mark the main task as completed
-    if (!dry) {
-        await tasks_1.taskService.setTaskStatus(taskId, "completed");
-        console.log(chalk_1.default.green(`✅ Main task ${task.title} completed after all subtasks`));
-    }
-    else {
-        console.log(chalk_1.default.cyan(`🔍 DRY RUN - Main task ${task.title} would be completed after all subtasks`));
-    }
-}
+const task_execution_core_1 = require("./task-execution-core");
+/**
+ * Execute a task using an external coding assistant
+ * This is the simplified entry point that delegates to the unified core
+ */
 async function executeTask(options) {
-    const { taskId, tool = "opencode", message, model, continueSession, dry = false, validate = [], } = options;
-    // Build executor config from options
-    const executorConfig = model || continueSession
-        ? {
+    const { taskId, tool = "opencode", message, model, continueSession, dry = false, validate = [], maxRetries, tryModels, plan, planModel, reviewPlan, review, reviewModel, autoCommit, } = options;
+    // Build unified task execution config
+    const config = {
+        tool,
+        executorConfig: {
             model,
             continueLastSession: continueSession,
-        }
-        : undefined;
-    // If custom message is provided, execute just this task (ignore subtasks)
-    if (message) {
-        const task = await tasks_1.taskService.getTask(taskId);
-        if (!task) {
-            throw new Error(`Task with ID ${taskId} not found`);
-        }
-        console.log(chalk_1.default.blue(`🎯 ${dry ? "DRY RUN - Would execute" : "Executing"} task with custom message: ${task.title} (${taskId})`));
-        if (!dry) {
-            await tasks_1.taskService.setTaskStatus(taskId, "in-progress");
-            console.log(chalk_1.default.yellow("⏳ Task status updated to in-progress"));
-        }
-        // Emit execution:start event
-        await hooks_1.hooks.emit("execution:start", { taskId, tool });
-        try {
-            const executor = executor_factory_1.ExecutorFactory.create(tool, executorConfig);
-            await executor.execute(message, dry, executorConfig);
-            if (!dry) {
-                await tasks_1.taskService.setTaskStatus(taskId, "completed");
-                console.log(chalk_1.default.green("✅ Task execution completed successfully"));
-            }
-            // Emit execution:end event
-            await hooks_1.hooks.emit("execution:end", { taskId, success: true });
-            // Run validations after task completion
-            await (0, validation_1.runValidations)(validate, dry);
-        }
-        catch (error) {
-            if (!dry) {
-                await tasks_1.taskService.setTaskStatus(taskId, "todo");
-                console.log(chalk_1.default.red("❌ Task execution failed, status reset to todo"));
-            }
-            // Emit execution:error event
-            await hooks_1.hooks.emit("execution:error", {
-                taskId,
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-            throw error;
-        }
-        return;
+        },
+        customMessage: message,
+        verificationCommands: validate,
+        enableRetry: maxRetries !== undefined && maxRetries > 0, // Opt-in retry
+        maxRetries: maxRetries || 3,
+        tryModels,
+        enablePlanPhase: plan,
+        planModel,
+        reviewPlan,
+        enableReviewPhase: review,
+        reviewModel,
+        autoCommit,
+        executeSubtasks: true, // Always execute subtasks in execute command
+        dry,
+    };
+    // Delegate to unified core execution
+    const result = await (0, task_execution_core_1.executeTaskCore)(taskId, config);
+    // Throw error if execution failed (maintains backward compatibility)
+    if (!result.success) {
+        const lastAttempt = result.attempts[result.attempts.length - 1];
+        throw new Error(lastAttempt?.error || "Task execution failed");
     }
-    // No custom message - execute recursively with subtasks
-    await executeTaskWithSubtasks(taskId, tool, dry, executorConfig);
-    // Run validations after all subtasks complete
-    await (0, validation_1.runValidations)(validate, dry);
 }

package/dist/lib/task-loop-execution.d.ts

@@ -1,25 +1,7 @@
 import { ExecuteLoopOptions, ExecuteLoopResult } from "../types";
-/**
- * Extract commit message and file list from AI conversation/output
- * This function analyzes the executor's work and generates appropriate commit info
- */
-/**
- * Extract commit message and file list from git state
- * This function analyzes the actual git state to generate appropriate commit info
- */
-export declare function extractCommitInfo(taskId: string, taskTitle: string, executionMessage: string, gitState: {
-    beforeHead: string;
-    afterHead: string;
-    hasUncommittedChanges: boolean;
-}, execFn?: (command: string) => Promise<{
-    stdout: string;
-    stderr: string;
-}>, aiOps?: any): Promise<{
-    message: string;
-    files: string[];
-}>;
 /**
  * Execute multiple tasks in a loop with retry and verification
+ * This delegates to the unified executeTaskCore for each task
  */
 export declare function executeTaskLoop(options: ExecuteLoopOptions): Promise<ExecuteLoopResult>;
 //# sourceMappingURL=task-loop-execution.d.ts.map

package/dist/lib/task-loop-execution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-loop-execution.d.ts","sourceRoot":"","sources":["../../src/lib/task-loop-execution.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EAMlB,MAAM,UAAU,CAAC;AAelB;;;GAGG;AACH;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE;IACR,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB,EAAE,OAAO,CAAC;CAChC,EACD,MAAM,GAAE,CACN,OAAO,EAAE,MAAM,KACZ,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAa,EAC5D,KAAK,GAAE,GAAuB,GAC7B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA+G/C;AA4pBD;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,iBAAiB,CAAC,CAmK5B"}
+{"version":3,"file":"task-loop-execution.d.ts","sourceRoot":"","sources":["../../src/lib/task-loop-execution.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EAIlB,MAAM,UAAU,CAAC;AAIlB;;;GAGG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,iBAAiB,CAAC,CAgL5B"}