@qelos/aidev 0.5.0 → 0.5.2

package/dist/commands/run.js

@@ -39,12 +39,18 @@ exports.getOpenStatus = getOpenStatus;
 exports.getInReviewStatus = getInReviewStatus;
 exports.getRunSkipReason = getRunSkipReason;
 exports.sortTasksByPriority = sortTasksByPriority;
+exports.writeTaskPlan = writeTaskPlan;
+exports.readTaskPlan = readTaskPlan;
+exports.formatSubtaskId = formatSubtaskId;
+exports.subtaskDepth = subtaskDepth;
+exports.formatSubtaskList = formatSubtaskList;
 exports.runCommand = runCommand;
 exports.hasHumanReply = hasHumanReply;
 exports.hasTriggerWord = hasTriggerWord;
 exports.checkNeedsClarification = checkNeedsClarification;
 exports.buildConflictResolutionPrompt = buildConflictResolutionPrompt;
 exports.buildImplementPrompt = buildImplementPrompt;
+exports.splitFailedSubtask = splitFailedSubtask;
 exports.buildPRBody = buildPRBody;
 exports.tryCreatePR = tryCreatePR;
 exports.buildPRUrl = buildPRUrl;
@@ -53,6 +59,9 @@ exports.buildNonCodePrompt = buildNonCodePrompt;
 exports.buildNonCodeCompletionComment = buildNonCodeCompletionComment;
 exports.hasAidevComment = hasAidevComment;
 exports.filterAutomatedComments = filterAutomatedComments;
+exports.parseReplyDirectives = parseReplyDirectives;
+exports.buildReviewPrompt = buildReviewPrompt;
+exports.buildReviewCompletionComment = buildReviewCompletionComment;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const logger_1 = require("../logger");
@@ -62,6 +71,7 @@ const github_1 = require("../github");
 const diagnostics_1 = require("../diagnostics");
 const lockfile_1 = require("../lockfile");
 const hooks_1 = require("../hooks");
+const sessions_1 = require("../sessions");
 const SKIP_STATUSES = new Set(['closed', 'done', 'cancelled', 'complete']);
 const NO_PRIORITY = Number.MAX_SAFE_INTEGER;
 const SLEEPING_MARKER = 'machine appears to be asleep';
@@ -146,17 +156,43 @@ function cleanupThinkingFiles(taskId) {
 function writeTaskPlan(plan) {
     fs.writeFileSync(taskPlanPath(plan.taskId), JSON.stringify(plan, null, 2), 'utf8');
 }
+function truncateError(msg) {
+    const MAX_LEN = 4096;
+    if (msg.length <= MAX_LEN)
+        return msg;
+    return msg.slice(0, MAX_LEN) + '\n... (truncated)';
+}
 function readTaskPlan(taskId) {
     const p = taskPlanPath(taskId);
     if (!fs.existsSync(p))
         return null;
     try {
-        return JSON.parse(fs.readFileSync(p, 'utf8'));
+        const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+        // Backward compat: older plans may be missing `attempts` / `lastError`.
+        raw.subtasks = (raw.subtasks || []).map((s) => ({
+            id: s.id,
+            title: s.title,
+            description: s.description,
+            status: s.status,
+            attempts: typeof s.attempts === 'number' ? s.attempts : 0,
+            lastError: s.lastError,
+        }));
+        return raw;
     }
     catch {
         return null;
     }
 }
+function formatSubtaskId(id) {
+    // Decimal string IDs like "3.1" already contain a dot; plain numeric IDs get
+    // a trailing dot so the list reads "1. Title", "2. Title", "3.1 Title".
+    return typeof id === 'string' ? id : `${id}.`;
+}
+function subtaskDepth(id) {
+    if (typeof id === 'number')
+        return 0;
+    return (id.match(/\./g) || []).length;
+}
 function formatSubtaskList(plan) {
     const icons = {
         pending: '⬜',
@@ -165,7 +201,7 @@ function formatSubtaskList(plan) {
         failed: '❌',
     };
     return plan.subtasks
-        .map((s) => `${icons[s.status]} **${s.id}.** ${s.title} — _${s.status}_`)
+        .map((s) => `${icons[s.status]} **${formatSubtaskId(s.id)}** ${s.title} — _${s.status}_`)
         .join('\n');
 }
 async function runCommand(filter, config, provider, runners, nonCodeProvider, hooks = {}, vm) {
@@ -210,6 +246,40 @@ async function runCommand(filter, config, provider, runners, nonCodeProvider, ho
                     skipped++;
             }
         }
+        // Review task phase: check tasks in review status for unresolved code review comments
+        if ((0, github_1.isGitHubRemote)(config.gitRemote) && (0, github_1.isGhInstalled)() && (0, github_1.isGhAuthenticated)() && config.githubRepo) {
+            const reviewStatus = getInReviewStatus(config);
+            logger_1.logger.info(`Fetching tasks in "${reviewStatus}" status for code review checks...`);
+            try {
+                const reviewTasks = await provider.fetchTasksByStatus([reviewStatus]);
+                const mainTag = (config.clickupTag || '').toLowerCase();
+                const reviewCandidates = mainTag
+                    ? reviewTasks.filter((t) => t.tags.some((tag) => tag.toLowerCase() === mainTag))
+                    : reviewTasks;
+                if (reviewCandidates.length > 0) {
+                    logger_1.logger.info(`Found ${reviewCandidates.length} task(s) in review — checking for unresolved code reviews`);
+                    for (const task of reviewCandidates) {
+                        if (!screenAvailable) {
+                            logger_1.logger.info(`[${task.id}] Skipping review check — screen not available`);
+                            break;
+                        }
+                        const result = await processReviewTask(task, config, provider, runners, screenAvailable, hooks, vm);
+                        if (result === 'processed')
+                            processed++;
+                    }
+                }
+            }
+            catch (err) {
+                logger_1.logger.warn(`Failed to fetch review tasks: ${err instanceof Error ? err.message : err}`);
+            }
+            // Checkout back to base branch after processing review tasks
+            git.fetchAndCheckout(config.gitRemote, config.githubBaseBranch);
+        }
+        else {
+            if (!(0, github_1.isGhInstalled)() || !(0, github_1.isGhAuthenticated)()) {
+                logger_1.logger.debug('gh CLI not available — skipping review task checks');
+            }
+        }
         // afterRun hook
         if (vm) {
             const afterCtx = {
@@ -565,10 +635,7 @@ async function implementTask(task, branchName, branchExists, config, provider, r
     let context = '';
     try {
         const comments = await provider.getComments(task.id);
-        const humanComments = filterAutomatedComments(comments, config.commentPrefix);
-        if (humanComments.length > 0) {
-            context = '\n\nConversation context:\n' + humanComments.map((c) => `${c.author}: ${c.text}`).join('\n');
-        }
+        context = await buildConversationContext(task.id, comments, config, runners);
     }
     catch {
         // ignore
@@ -728,6 +795,7 @@ Keep sub-tasks focused: 2-6 sub-tasks is ideal. Order them by dependency (founda
                 title: s.title,
                 description: s.description,
                 status: 'pending',
+                attempts: 0,
             })),
         };
         fs.writeFileSync(taskInstructionsPath(task.id), parsed.instructions || `# Implementation Plan: ${task.name}\n\nSee ${task.id}.aidev.task.json for sub-tasks.`, 'utf8');
@@ -739,7 +807,87 @@ Keep sub-tasks focused: 2-6 sub-tasks is ideal. Order them by dependency (founda
         return null;
     }
 }
-async function executeSubTask(subtask, task, plan, config, runners, reviewContext) {
+async function splitFailedSubtask(parentTask, plan, failedSubtask, runners) {
+    const runner = runners.find((r) => r.isAvailable());
+    if (!runner) {
+        logger_1.logger.error('No AI runner available for sub-task split');
+        return null;
+    }
+    const siblings = plan.subtasks
+        .filter((s) => s.id !== failedSubtask.id)
+        .map((s) => `  - [${s.status}] ${formatSubtaskId(s.id)} ${s.title}`)
+        .join('\n');
+    const diagnostics = failedSubtask.lastError && failedSubtask.lastError !== '__git__'
+        ? failedSubtask.lastError
+        : '(no diagnostics captured)';
+    const splitPrompt = `You are a senior software architect helping recover a stalled implementation step by splitting it into exactly two smaller, sequential sub-tasks.
+
+Overall task: ${parentTask.name}
+${parentTask.description ? `\nTask description:\n${parentTask.description}\n` : ''}
+## Surrounding plan
+${siblings || '(no sibling sub-tasks)'}
+
+## Failed sub-task
+ID: ${formatSubtaskId(failedSubtask.id)}
+Title: ${failedSubtask.title}
+Description: ${failedSubtask.description}
+
+## Previous failure diagnostics
+${diagnostics}
+
+Split the failed sub-task above into exactly two smaller, independently implementable sub-tasks that together achieve the original goal. Each new sub-task should be a coherent unit of work that can be committed separately, ordered by dependency (foundation first). Take the diagnostics into account so the split actually addresses what broke.
+
+Respond with valid JSON only — no markdown fences, no extra text:
+{
+  "subtasks": [
+    { "title": "Short title for the first new sub-task", "description": "Detailed description of what to implement in this step" },
+    { "title": "Short title for the second new sub-task", "description": "Detailed description of what to implement in this step" }
+  ]
+}
+
+Exactly two entries — no more, no fewer.`;
+    logger_1.logger.info(`Splitting failed sub-task ${formatSubtaskId(failedSubtask.id)} into two smaller steps...`);
+    const result = await runner.run(splitPrompt);
+    if (!result.success) {
+        logger_1.logger.error('Sub-task split failed');
+        return null;
+    }
+    try {
+        const jsonMatch = result.output.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            logger_1.logger.error('Could not parse split response — no JSON found');
+            return null;
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (!parsed.subtasks || parsed.subtasks.length !== 2) {
+            logger_1.logger.error(`Split response must contain exactly 2 sub-tasks (got ${parsed.subtasks?.length ?? 0})`);
+            return null;
+        }
+        const newSubtasks = [];
+        for (let i = 0; i < 2; i++) {
+            const entry = parsed.subtasks[i];
+            const title = (entry?.title || '').trim();
+            const description = (entry?.description || '').trim();
+            if (!title || !description) {
+                logger_1.logger.error(`Split response sub-task ${i + 1} has empty title or description`);
+                return null;
+            }
+            newSubtasks.push({
+                id: `${failedSubtask.id}.${i + 1}`,
+                title,
+                description,
+                status: 'pending',
+                attempts: 0,
+            });
+        }
+        return newSubtasks;
+    }
+    catch (err) {
+        logger_1.logger.error(`Failed to parse split response: ${err}`);
+        return null;
+    }
+}
+async function executeSubTask(subtask, task, plan, config, runners, reviewContext, previousError) {
     const instructionsPath = taskInstructionsPath(task.id);
     const instructions = fs.existsSync(instructionsPath)
         ? fs.readFileSync(instructionsPath, 'utf8')
@@ -748,6 +896,9 @@ async function executeSubTask(subtask, task, plan, config, runners, reviewContex
         .filter((s) => s.status === 'done')
         .map((s) => `  - [done] ${s.id}. ${s.title}`)
         .join('\n');
+    const retrySection = previousError && previousError !== '__git__'
+        ? `\n## Previous attempt failure diagnostics\nThis step failed on a previous attempt. Diagnostics below — please take them into account and avoid repeating the same failure.\n\n${previousError}\n`
+        : '';
     const prompt = `You are implementing step ${subtask.id} of a multi-step task.
 
 Overall task: ${task.name}
@@ -755,7 +906,7 @@ ${task.description ? `\nTask description:\n${task.description}` : ''}
 
 ## Full implementation instructions
 ${instructions}
-${reviewContext || ''}
+${reviewContext || ''}${retrySection}
 ## Progress
 ${completedSteps || '(no steps completed yet)'}
 
@@ -813,10 +964,7 @@ async function implementThinkingTask(task, branchName, branchExists, config, pro
     let context = '';
     try {
         const comments = await provider.getComments(task.id);
-        const humanComments = filterAutomatedComments(comments, config.commentPrefix);
-        if (humanComments.length > 0) {
-            context = '\n\nConversation context:\n' + humanComments.map((c) => `${c.author}: ${c.text}`).join('\n');
-        }
+        context = await buildConversationContext(task.id, comments, config, runners);
     }
     catch { /* ignore */ }
     if (branchExists) {
@@ -882,26 +1030,68 @@ async function implementThinkingTask(task, branchName, branchExists, config, pro
                 title: s.title,
                 description: s.description,
                 status: (prev?.status ?? s.status),
+                attempts: prev?.attempts ?? 0,
+                lastError: prev?.lastError,
             };
         });
         writeTaskPlan(plan);
     }
     let allSucceeded = true;
-    for (const subtask of plan.subtasks) {
+    for (let i = 0; i < plan.subtasks.length; i++) {
+        const subtask = plan.subtasks[i];
         if (subtask.status === 'done') {
             logger_1.logger.info(`  Step ${subtask.id} already done — skipping`);
             continue;
         }
+        // Failure recovery on resume: a sub-task that ended in 'failed' on a prior run
+        // gets a chance to be split into two smaller steps before we retry it.
+        if (subtask.status === 'failed') {
+            const isGitFailure = subtask.lastError === '__git__';
+            const depth = subtaskDepth(subtask.id);
+            const attempts = subtask.attempts ?? 0;
+            const shouldSplit = !isGitFailure && attempts >= 2 && depth < 2;
+            if (shouldSplit) {
+                const failedId = subtask.id;
+                const newSubtasks = await splitFailedSubtask(task, plan, subtask, runners);
+                if (newSubtasks) {
+                    plan.subtasks.splice(i, 1, ...newSubtasks);
+                    writeTaskPlan(plan);
+                    const newIds = newSubtasks.map((s) => s.id).join(', ');
+                    logger_1.logger.info(`  Step ${failedId} was split into ${newIds}`);
+                    try {
+                        await provider.postComment(task.id, `${config.commentPrefix} Step ${failedId} was split into ${newIds}:\n\n${formatSubtaskList(plan)}`);
+                    }
+                    catch { /* ignore */ }
+                    i--; // re-process this index — it now points at the first new sub-task
+                    continue;
+                }
+                logger_1.logger.warn(`  Could not split failed step ${failedId} — falling back to plain retry`);
+                try {
+                    await provider.postComment(task.id, `${config.commentPrefix} Failed to automatically split step ${failedId}. Retrying as-is.`);
+                }
+                catch { /* ignore */ }
+            }
+            else if (!isGitFailure && attempts >= 2 && depth >= 2) {
+                logger_1.logger.warn(`  Step ${subtask.id} has reached the split-depth cap — manual intervention may be needed`);
+                try {
+                    await provider.postComment(task.id, `${config.commentPrefix} Step ${subtask.id} has already been split twice and is still failing. Retrying as-is — please consider manual intervention.`);
+                }
+                catch { /* ignore */ }
+            }
+        }
+        const previousError = subtask.lastError;
         subtask.status = 'running';
+        subtask.attempts = (subtask.attempts ?? 0) + 1;
         writeTaskPlan(plan);
-        logger_1.logger.info(`  Starting step ${subtask.id}: ${subtask.title}`);
-        const success = await executeSubTask(subtask, task, plan, config, runners, reviewContext);
+        logger_1.logger.info(`  Starting step ${subtask.id}: ${subtask.title} (attempt ${subtask.attempts})`);
+        const success = await executeSubTask(subtask, task, plan, config, runners, reviewContext, previousError);
         if (!success) {
+            const diagnostics = (0, diagnostics_1.collectAndLogDiagnostics)();
             subtask.status = 'failed';
+            subtask.lastError = truncateError(diagnostics);
             writeTaskPlan(plan);
             allSucceeded = false;
             logger_1.logger.error(`  Step ${subtask.id} failed: ${subtask.title}`);
-            const diagnostics = (0, diagnostics_1.collectAndLogDiagnostics)();
             try {
                 await provider.postComment(task.id, `${config.commentPrefix} Step ${subtask.id} failed: ${subtask.title}\n\n${formatSubtaskList(plan)}\n\n${diagnostics}`);
             }
@@ -910,6 +1100,7 @@ async function implementThinkingTask(task, branchName, branchExists, config, pro
         }
         if (!git.addAll() || !git.commit(`${config.commentPrefix} Step ${subtask.id}: ${subtask.title}\n\nTask: ${task.url}`, branchName)) {
             subtask.status = 'failed';
+            subtask.lastError = '__git__';
             writeTaskPlan(plan);
             allSucceeded = false;
             logger_1.logger.error(`  Failed to commit step ${subtask.id}`);
@@ -917,6 +1108,7 @@ async function implementThinkingTask(task, branchName, branchExists, config, pro
         }
         if (!git.push(config.gitRemote, branchName)) {
             subtask.status = 'failed';
+            subtask.lastError = '__git__';
             writeTaskPlan(plan);
             allSucceeded = false;
             logger_1.logger.error(`  Failed to push step ${subtask.id}`);
@@ -1057,6 +1249,21 @@ function hasAidevComment(comments, commentPrefix = '[aidev]') {
 function filterAutomatedComments(comments, commentPrefix = '[aidev]') {
     return comments.filter((c) => !c.text.includes(commentPrefix));
 }
+async function buildConversationContext(taskId, comments, config, runners) {
+    const humanComments = filterAutomatedComments(comments, config.commentPrefix);
+    if (humanComments.length === 0)
+        return '';
+    const rawLength = '\n\nConversation context:\n'.length +
+        humanComments.reduce((n, c, i) => n + c.author.length + 2 + c.text.length + (i > 0 ? 1 : 0), 0);
+    const context = await (0, sessions_1.buildCompressedContext)(humanComments, taskId, runners, config);
+    if (config.autoCompress &&
+        humanComments.length > 1 &&
+        rawLength > config.compressThreshold &&
+        context.startsWith('\n\nSummary of earlier conversation')) {
+        logger_1.logger.info(`[${taskId}] Auto-compressed conversation context: ${rawLength} → ${context.length} chars`);
+    }
+    return context;
+}
 async function processNonCodeTask(task, filter, config, provider, runners, screenAvailable, hooks = {}, vm) {
     const pendingStatus = getPendingStatus(config);
     const openStatus = getOpenStatus(config);
@@ -1125,10 +1332,7 @@ async function implementNonCodeTask(task, config, provider, runners, hooks = {},
     let context = '';
     try {
         const comments = await provider.getComments(task.id);
-        const humanComments = filterAutomatedComments(comments, config.commentPrefix);
-        if (humanComments.length > 0) {
-            context = '\n\nConversation context:\n' + humanComments.map((c) => `${c.author}: ${c.text}`).join('\n');
-        }
+        context = await buildConversationContext(task.id, comments, config, runners);
     }
     catch {
         // ignore
@@ -1181,4 +1385,188 @@ async function implementNonCodeTask(task, config, provider, runners, hooks = {},
     }
     logger_1.logger.success(`Non-code task complete: ${task.name}`);
 }
+// ─── Review task processing ─────────────────────────────────────────────────
+const REPLY_REGEX = /<!-- AIDEV-REPLY ([\w=+/]+) -->([\s\S]*?)<!-- \/AIDEV-REPLY -->/g;
+function parseReplyDirectives(output) {
+    const replies = [];
+    let match;
+    while ((match = REPLY_REGEX.exec(output)) !== null) {
+        replies.push({ threadId: match[1], body: match[2].trim() });
+    }
+    return replies;
+}
+async function processReviewTask(task, config, provider, runners, screenAvailable, hooks = {}, vm) {
+    const branchName = `${task.id}/${git.slugify(task.name)}`;
+    logger_1.logger.task(`[${task.id}] "${task.name}" [review] — checking code reviews`);
+    if (!config.githubRepo) {
+        logger_1.logger.debug(`[${task.id}] No githubRepo configured — skipping review check`);
+        return 'skipped';
+    }
+    const prNumber = (0, github_1.getPrNumberForBranch)(branchName);
+    if (!prNumber) {
+        logger_1.logger.debug(`[${task.id}] No PR found for branch ${branchName} — skipping`);
+        return 'skipped';
+    }
+    const parts = config.githubRepo.split('/');
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        logger_1.logger.debug(`[${task.id}] Invalid githubRepo format — skipping`);
+        return 'skipped';
+    }
+    const allThreads = (0, github_1.fetchUnresolvedReviewThreads)(parts[0], parts[1], prNumber);
+    if (allThreads.length === 0) {
+        logger_1.logger.debug(`[${task.id}] No unresolved review threads — skipping`);
+        return 'skipped';
+    }
+    const actionableThreads = (0, github_1.filterUnresolvedByNonAidev)(allThreads, config.commentPrefix);
+    if (actionableThreads.length === 0) {
+        logger_1.logger.debug(`[${task.id}] All unresolved threads are from aidev — skipping`);
+        return 'skipped';
+    }
+    if (!screenAvailable) {
+        await notifySleeping(task, provider, config.commentPrefix);
+        return 'skipped';
+    }
+    logger_1.logger.info(`[${task.id}] Found ${actionableThreads.length} actionable review thread(s) — resolving`);
+    await implementReviewTask(task, branchName, config, provider, runners, actionableThreads, hooks, vm);
+    return 'processed';
+}
+async function implementReviewTask(task, branchName, config, provider, runners, threads, hooks = {}, vm) {
+    logger_1.logger.info(`Resolving review comments for: ${task.name}`);
+    if (!git.fetchAndCheckoutBranch(config.gitRemote, branchName)) {
+        logger_1.logger.error(`[${task.id}] Failed to checkout branch ${branchName}`);
+        return;
+    }
+    let reviewPrompt = buildReviewPrompt(task, threads);
+    // beforeReviewTask hook
+    if (vm) {
+        const reviewCtx = { task, config, branchName, threads, prompt: reviewPrompt };
+        const modified = await (0, hooks_1.executeHook)(hooks, 'beforeReviewTask', reviewCtx, vm);
+        reviewPrompt = modified.prompt;
+    }
+    let success = false;
+    let agentOutput = '';
+    let previousNotes = '';
+    for (const runner of runners) {
+        if (!runner.isAvailable())
+            continue;
+        logger_1.logger.info(`Running ${runner.name} to address review comments...`);
+        const result = await runner.run(reviewPrompt, previousNotes || undefined);
+        if (result.success) {
+            success = true;
+            agentOutput = result.output;
+            break;
+        }
+        logger_1.logger.warn(`${runner.name} failed — trying next runner`);
+        previousNotes = `Previous runner (${runner.name}) output:\n${result.output}\nErrors:\n${result.error}`;
+    }
+    if (!success) {
+        logger_1.logger.error(`[${task.id}] All AI runners failed to address review comments`);
+        const diagnostics = (0, diagnostics_1.collectAndLogDiagnostics)();
+        try {
+            await provider.postComment(task.id, `${config.commentPrefix} Failed to address code review comments automatically.\n\n${diagnostics}`);
+        }
+        catch { /* ignore */ }
+        // afterReviewTask hook — failure
+        if (vm) {
+            const afterCtx = {
+                task, config, branchName, threads, prompt: reviewPrompt, success: false, resolvedCount: 0,
+            };
+            await (0, hooks_1.executeHook)(hooks, 'afterReviewTask', afterCtx, vm);
+        }
+        return;
+    }
+    let resolvedCount = 0;
+    let repliedCount = 0;
+    // Handle code fixes: commit and push if agent made changes
+    if (git.hasChanges()) {
+        if (git.addAll() && git.commit(`${config.commentPrefix} Address code review comments\n\nTask: ${task.url}`, branchName)) {
+            if (git.push(config.gitRemote, branchName)) {
+                // Resolve threads that were addressed via code changes
+                resolveHandledThreads(threads);
+                resolvedCount = threads.length;
+                logger_1.logger.info(`Pushed code fixes and resolved ${resolvedCount} thread(s)`);
+            }
+            else {
+                logger_1.logger.error(`[${task.id}] Failed to push review fixes`);
+            }
+        }
+        else {
+            logger_1.logger.error(`[${task.id}] Failed to commit review fixes`);
+        }
+    }
+    // Handle reply directives from agent output
+    const replies = parseReplyDirectives(agentOutput);
+    for (const reply of replies) {
+        const prefixedBody = `${config.commentPrefix} ${reply.body}`;
+        if ((0, github_1.replyToReviewThread)(reply.threadId, prefixedBody)) {
+            repliedCount++;
+        }
+    }
+    if (repliedCount > 0) {
+        logger_1.logger.info(`Posted ${repliedCount} reply(ies) to review threads`);
+    }
+    // Post completion comment on task provider
+    if (resolvedCount > 0 || repliedCount > 0) {
+        try {
+            const comment = buildReviewCompletionComment(config, resolvedCount, repliedCount);
+            await provider.postComment(task.id, comment);
+        }
+        catch { /* ignore */ }
+    }
+    // afterReviewTask hook
+    if (vm) {
+        const afterCtx = {
+            task, config, branchName, threads, prompt: reviewPrompt, success: true, resolvedCount,
+        };
+        await (0, hooks_1.executeHook)(hooks, 'afterReviewTask', afterCtx, vm);
+    }
+    logger_1.logger.success(`Review comments addressed for: ${task.name}`);
+}
+function buildReviewPrompt(task, threads) {
+    let prompt = `You are addressing code review comments on a pull request for a software development task.
+
+Task: ${task.name}
+
+Description:
+${task.description || '(no description provided)'}
+
+## Unresolved Code Review Threads
+
+The following review threads need to be addressed. For each thread, either:
+- Fix the code as requested (make the changes directly in the files)
+- Or, if it's a discussion/question that doesn't require code changes, output a REPLY block:
+  <!-- AIDEV-REPLY thread_id -->Your reply here<!-- /AIDEV-REPLY -->
+
+Replace "thread_id" with the actual thread ID shown below.
+
+`;
+    for (const thread of threads) {
+        const location = thread.line
+            ? `\`${thread.path}\` (line ${thread.line})`
+            : `\`${thread.path}\``;
+        prompt += `### Thread ${thread.id} — ${location}\n`;
+        for (const comment of thread.comments) {
+            prompt += `> **${comment.author}**: ${comment.body}\n`;
+        }
+        prompt += '\n';
+    }
+    prompt += `## Instructions
+
+1. Read each review thread carefully
+2. For code change requests: make the fix directly in the relevant file(s)
+3. For questions or discussions: output a REPLY block with a clear, helpful response
+4. You may handle multiple threads — some with code fixes, others with replies
+5. Focus on correctness and follow the existing code style`;
+    return prompt;
+}
+function buildReviewCompletionComment(config, resolvedCount, repliedCount) {
+    const parts = [`${config.commentPrefix} Code review comments addressed!`];
+    if (resolvedCount > 0) {
+        parts.push(`Resolved ${resolvedCount} thread(s) with code fixes.`);
+    }
+    if (repliedCount > 0) {
+        parts.push(`Replied to ${repliedCount} thread(s).`);
+    }
+    return parts.join('\n');
+}
 //# sourceMappingURL=run.js.map