task-o-matic-core 0.1.0

package/dist/lib/storage/storage-callbacks.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemCallbacks = createFileSystemCallbacks;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const fs_1 = require("fs");
+/**
+ * Default file system callbacks (Node.js environment)
+ * Uses fs/promises to implement the storage interface
+ */
+function createFileSystemCallbacks(baseDir = process.cwd()) {
+    const resolvePath = (key) => (0, path_1.join)(baseDir, key);
+    const ensureDir = (filePath) => {
+        const dir = (0, path_1.dirname)(filePath);
+        if (!(0, fs_1.existsSync)(dir)) {
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        }
+    };
+    return {
+        read: async (key) => {
+            try {
+                const path = resolvePath(key);
+                if (!(0, fs_1.existsSync)(path))
+                    return null;
+                return await (0, promises_1.readFile)(path, "utf-8");
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return null;
+                throw error;
+            }
+        },
+        write: async (key, value) => {
+            const path = resolvePath(key);
+            ensureDir(path);
+            await (0, promises_1.writeFile)(path, value, "utf-8");
+        },
+        delete: async (key) => {
+            try {
+                const path = resolvePath(key);
+                if ((0, fs_1.existsSync)(path)) {
+                    await (0, promises_1.unlink)(path);
+                }
+            }
+            catch (error) {
+                // Ignore if already gone
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        },
+        list: async (prefix) => {
+            const searchPath = prefix ? resolvePath(prefix) : baseDir;
+            try {
+                // If it's a directory, recursively list all files in it
+                if ((0, fs_1.existsSync)(searchPath) && (await (0, promises_1.stat)(searchPath)).isDirectory()) {
+                    const files = [];
+                    const scan = async (dir, currentPrefix) => {
+                        const items = await (0, promises_1.readdir)(dir);
+                        for (const item of items) {
+                            const fullPath = (0, path_1.join)(dir, item);
+                            const itemPrefix = currentPrefix
+                                ? (0, path_1.join)(currentPrefix, item)
+                                : item;
+                            if ((await (0, promises_1.stat)(fullPath)).isDirectory()) {
+                                await scan(fullPath, itemPrefix);
+                            }
+                            else {
+                                files.push(itemPrefix);
+                            }
+                        }
+                    };
+                    await scan(searchPath, prefix || "");
+                    return files;
+                }
+                // If it's a file prefix (e.g. "tasks/task-")
+                const dir = (0, path_1.dirname)(searchPath);
+                if ((0, fs_1.existsSync)(dir)) {
+                    const files = await (0, promises_1.readdir)(dir);
+                    const namePrefix = prefix ? prefix.split("/").pop() || "" : "";
+                    return files
+                        .filter((f) => f.startsWith(namePrefix))
+                        .map((f) => (0, path_1.join)((0, path_1.dirname)(prefix || ""), f));
+                }
+                return [];
+            }
+            catch (error) {
+                return [];
+            }
+        },
+        exists: async (key) => {
+            return (0, fs_1.existsSync)(resolvePath(key));
+        },
+    };
+}

package/dist/lib/storage/types.d.ts

@@ -0,0 +1,43 @@
+import { Task, CreateTaskRequest, TaskAIMetadata } from "../../types";
+export interface TaskRepository {
+    getTasks(): Promise<Task[]>;
+    getTopLevelTasks(): Promise<Task[]>;
+    getTask(id: string): Promise<Task | null>;
+    createTask(task: CreateTaskRequest, aiMetadata?: TaskAIMetadata): Promise<Task>;
+    updateTask(id: string, updates: Partial<Task>): Promise<Task | null>;
+    deleteTask(id: string): Promise<boolean>;
+    getSubtasks(parentId: string): Promise<Task[]>;
+    getTaskContent(taskId: string): Promise<string | null>;
+    saveTaskContent(taskId: string, content: string): Promise<string>;
+    saveEnhancedTaskContent(taskId: string, content: string): Promise<string>;
+    deleteTaskContent(taskId: string): Promise<void>;
+    migrateTaskContent(): Promise<number>;
+    cleanupOrphanedContent(): Promise<number>;
+    getTaskAIMetadata(taskId: string): Promise<TaskAIMetadata | null>;
+    saveTaskAIMetadata(metadata: TaskAIMetadata): Promise<void>;
+    deleteTaskAIMetadata(taskId: string): Promise<void>;
+    getTaskDocumentation(taskId: string): Promise<string | null>;
+    saveTaskDocumentation(taskId: string, content: string): Promise<string>;
+    saveContext7Documentation(library: string, query: string, content: string): Promise<string>;
+    getDocumentationFile(fileName: string): Promise<string | null>;
+    listDocumentationFiles(): Promise<string[]>;
+    getPlan(taskId: string): Promise<{
+        plan: string;
+        createdAt: number;
+        updatedAt: number;
+    } | null>;
+    savePlan(taskId: string, plan: string): Promise<void>;
+    listPlans(): Promise<Array<{
+        taskId: string;
+        plan: string;
+        createdAt: number;
+        updatedAt: number;
+    }>>;
+    deletePlan(taskId: string): Promise<boolean>;
+    sanitizeForFilename(name: string): string;
+    validateStorageIntegrity(): Promise<{
+        isValid: boolean;
+        issues: string[];
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/storage/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/storage/types.ts"],"names":[],"mappings":"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"}

package/dist/lib/storage/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+import { TaskExecutionConfig, TaskExecutionResult } from "../types";
+/**
+ * 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
+ */
+export declare function executeTaskCore(taskId: string, config: TaskExecutionConfig): Promise<TaskExecutionResult>;
+//# sourceMappingURL=task-execution-core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"task-execution-core.d.ts","sourceRoot":"","sources":["../../src/lib/task-execution-core.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EAKpB,MAAM,UAAU,CAAC;AAiBlB;;;GAGG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CAyE9B"}

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

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTaskCore = executeTaskCore;
+const task_o_matic_error_1 = require("../utils/task-o-matic-error");
+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 logger_1 = require("./logger");
+/**
+ * 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, includePrd = false, dry = false, onPlanReview, } = config;
+    // Load task
+    const task = await tasks_1.taskService.getTask(taskId);
+    if (!task) {
+        throw (0, task_o_matic_error_1.formatTaskNotFoundError)(taskId);
+    }
+    // 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,
+            onPlanReview,
+        });
+        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, includeCompleted = false } = config;
+    logger_1.logger.info(`📋 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];
+        // Skip completed subtasks unless includeCompleted is set
+        if (!includeCompleted && subtask.status === "completed") {
+            logger_1.logger.info(`⏭️  Skipping completed subtask: ${subtask.title} (${subtask.id})`);
+            continue;
+        }
+        logger_1.logger.progress(`\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;
+                logger_1.logger.error(`❌ Failed to execute subtask ${subtask.id}: ${subtask.title}`);
+                break; // Stop on first failure
+            }
+        }
+        catch (error) {
+            allSuccess = false;
+            logger_1.logger.error(`❌ 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");
+            logger_1.logger.success(`✅ Main task ${task.title} completed after all subtasks`);
+        }
+        else {
+            await tasks_1.taskService.setTaskStatus(task.id, "todo");
+            logger_1.logger.error(`❌ 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;
+            }
+        }
+        logger_1.logger.info(`\n🎯 Attempt ${currentAttempt}/${maxRetries} for task: ${task.title} (${task.id})`);
+        if (currentModel) {
+            logger_1.logger.progress(`   Using executor: ${currentExecutor} with model: ${currentModel}`);
+        }
+        else {
+            logger_1.logger.progress(`   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}`;
+                    logger_1.logger.error(`❌ AI Review Rejected Changes: ${reviewResult.feedback}`);
+                    currentAttempt++;
+                    continue;
+                }
+                else {
+                    logger_1.logger.success(`✅ 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);
+            logger_1.logger.error(`❌ Task execution failed on attempt ${currentAttempt}: ${lastError}`);
+            if (!dry && currentAttempt < maxRetries) {
+                await tasks_1.taskService.setTaskStatus(task.id, "todo");
+                logger_1.logger.warn("⏸  Task status reset to todo for retry");
+            }
+            currentAttempt++;
+        }
+    }
+    // All retries exhausted
+    if (!dry) {
+        await tasks_1.taskService.setTaskStatus(task.id, "todo");
+        logger_1.logger.error("❌ 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, includePrd = false, dry = false, } = config;
+    const attemptStartTime = Date.now();
+    logger_1.logger.info(`🎯 ${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;
+        logger_1.logger.progress("📝 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,
+            prdContent: includePrd ? taskContext.prdContent : undefined,
+        });
+        if (!promptResult.success) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_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");
+        logger_1.logger.warn("⏳ 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) {
+            logger_1.logger.progress("🔄 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 formattedError = (0, validation_1.formatVerificationError)(failedVerification);
+            attempts.push({
+                attemptNumber,
+                success: false,
+                error: formattedError,
+                executor: tool,
+                model: executorConfig?.model,
+                verificationResults,
+                timestamp: Date.now() - attemptStartTime,
+            });
+            logger_1.logger.error(`❌ Task execution failed verification on attempt ${attemptNumber}`);
+            // Don't throw - return failure so retry loop can handle with session continuation
+            // This enables automatic error feedback to the AI
+            return {
+                success: false,
+                attempts,
+            };
+        }
+        // Extract commit info if enabled
+        let commitInfo;
+        if (enableAutoCommit && !dry) {
+            logger_1.logger.info("📝 Checking git state for auto-commit...");
+            // Check if agent already committed during execution
+            const agentCommitted = await (0, git_utils_1.hasNewCommitsSince)(gitStateBefore.beforeHead || "");
+            if (agentCommitted) {
+                logger_1.logger.info("📝 Agent already committed changes during execution, skipping auto-commit");
+            }
+            else {
+                const gitStateAfter = await (0, git_utils_1.captureGitState)();
+                if (gitStateAfter.hasUncommittedChanges) {
+                    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);
+                    logger_1.logger.success(`✅ Commit message: ${commitInfo.message}`);
+                    if (commitInfo.files.length > 0) {
+                        logger_1.logger.success(`📁 Changed files: ${commitInfo.files.join(", ")}`);
+                    }
+                    // Auto-commit the changes
+                    await (0, git_utils_1.autoCommit)(commitInfo);
+                }
+                else {
+                    logger_1.logger.info("📝 No uncommitted changes to commit");
+                }
+            }
+        }
+        // Update task status to completed
+        if (!dry) {
+            await tasks_1.taskService.setTaskStatus(task.id, "completed");
+            logger_1.logger.success("✅ 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");
+            logger_1.logger.error("❌ Task execution failed, status reset to todo");
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +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

@@ -0,0 +1 @@
+{"version":3,"file":"task-execution.d.ts","sourceRoot":"","sources":["../../src/lib/task-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAuB,MAAM,UAAU,CAAC;AAGnE;;;GAGG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmD5E"}

package/dist/lib/task-execution.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTask = executeTask;
+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 = [], maxRetries, tryModels, plan, planModel, reviewPlan, review, reviewModel, autoCommit, includePrd, } = options;
+    // Build unified task execution config
+    const config = {
+        tool,
+        executorConfig: {
+            model,
+            continueLastSession: continueSession,
+        },
+        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
+        includePrd,
+        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");
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { ExecuteLoopOptions, ExecuteLoopResult } from "../types";
+/**
+ * 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

@@ -0,0 +1 @@
+{"version":3,"file":"task-loop-execution.d.ts","sourceRoot":"","sources":["../../src/lib/task-loop-execution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAGlB,MAAM,UAAU,CAAC;AAMlB;;;GAGG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,iBAAiB,CAAC,CAoM5B"}