@qelos/aidev 0.5.1 → 0.5.3

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;
@@ -65,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';
@@ -149,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: '⬜',
@@ -168,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) {
@@ -370,16 +403,16 @@ async function checkNeedsClarification(task, config, provider, runners) {
         logger_1.logger.warn('No AI runner available — skipping clarification check');
         return null;
     }
-    const clarificationPrompt = `You are a senior software developer reviewing a task.
-Determine if the following task has enough information to implement without further clarification.
-
-Task name: ${task.name}
-Task description: ${task.description || '(no description)'}
-
-Respond with valid JSON only:
-{
-  "clear": true|false,
-  "question": "question to ask if not clear, or null"
+    const clarificationPrompt = `You are a senior software developer reviewing a task.
+Determine if the following task has enough information to implement without further clarification.
+
+Task name: ${task.name}
+Task description: ${task.description || '(no description)'}
+
+Respond with valid JSON only:
+{
+  "clear": true|false,
+  "question": "question to ask if not clear, or null"
 }`;
     for (const runner of availableRunners) {
         const result = await runner.run(clarificationPrompt);
@@ -407,30 +440,30 @@ Respond with valid JSON only:
     return null;
 }
 function buildConflictResolutionPrompt(task, conflictFiles, context) {
-    return `You are resolving merge conflicts in a software development task branch.
-
-The task branch has fallen behind the base branch and has merge conflicts that need to be resolved.
-
-## Task context (DO NOT break this — the task must still work after conflict resolution)
-
-Task: ${task.name}
-
-Description:
-${task.description || '(no description provided)'}
-${context}
-
-## Merge conflicts
-
-The following files have merge conflicts with conflict markers (<<<<<<< HEAD, =======, >>>>>>> ...):
-${conflictFiles.map((f) => `- ${f}`).join('\n')}
-
-## Instructions
-
-1. Open each conflicting file and resolve the conflict markers
-2. Keep BOTH the task's changes AND the base branch updates where possible
-3. If the base branch changed something the task also changed, prefer the task's intent but make sure it works with the new base branch code
-4. Remove all conflict markers (<<<<<<< HEAD, =======, >>>>>>> ...)
-5. Make sure the code compiles and is consistent after resolution
+    return `You are resolving merge conflicts in a software development task branch.
+
+The task branch has fallen behind the base branch and has merge conflicts that need to be resolved.
+
+## Task context (DO NOT break this — the task must still work after conflict resolution)
+
+Task: ${task.name}
+
+Description:
+${task.description || '(no description provided)'}
+${context}
+
+## Merge conflicts
+
+The following files have merge conflicts with conflict markers (<<<<<<< HEAD, =======, >>>>>>> ...):
+${conflictFiles.map((f) => `- ${f}`).join('\n')}
+
+## Instructions
+
+1. Open each conflicting file and resolve the conflict markers
+2. Keep BOTH the task's changes AND the base branch updates where possible
+3. If the base branch changed something the task also changed, prefer the task's intent but make sure it works with the new base branch code
+4. Remove all conflict markers (<<<<<<< HEAD, =======, >>>>>>> ...)
+5. Make sure the code compiles and is consistent after resolution
 6. Do NOT make any changes beyond what is needed to resolve the conflicts`;
 }
 async function resolveConflictsWithAI(task, config, provider, runners, context, hooks, vm, branchName) {
@@ -602,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
@@ -701,14 +731,14 @@ async function implementTask(task, branchName, branchExists, config, provider, r
     logger_1.logger.success(`Task implemented: branch ${branchName} pushed`);
 }
 function buildImplementPrompt(task, context) {
-    return `You are implementing a software development task. Make the necessary code changes to complete the task described below.
-
-Task: ${task.name}
-
-Description:
-${task.description || '(no description provided)'}
-${context}
-
+    return `You are implementing a software development task. Make the necessary code changes to complete the task described below.
+
+Task: ${task.name}
+
+Description:
+${task.description || '(no description provided)'}
+${context}
+
 Please implement the required changes. Focus on correctness and follow the existing code style in the project.`;
 }
 async function analyzeAndPlan(task, context, runners) {
@@ -717,28 +747,28 @@ async function analyzeAndPlan(task, context, runners) {
         logger_1.logger.error('No AI runner available for task analysis');
         return null;
     }
-    const analysisPrompt = `You are a senior software architect breaking down a development task into smaller, sequential implementation steps.
-
-Task name: ${task.name}
-
-Description:
-${task.description || '(no description provided)'}
-${context}
-
-Analyze this task and break it into smaller, independently implementable sub-tasks that should be executed sequentially. Each sub-task should be a coherent unit of work that can be committed separately.
-
-Respond with valid JSON only — no markdown fences, no extra text:
-{
-  "instructions": "Detailed implementation instructions in markdown covering the full task — architecture decisions, key files to modify, edge cases to handle, testing approach",
-  "subtasks": [
-    {
-      "id": 1,
-      "title": "Short title for the sub-task",
-      "description": "Detailed description of what to implement in this step, including specific files and functions to change"
-    }
-  ]
-}
-
+    const analysisPrompt = `You are a senior software architect breaking down a development task into smaller, sequential implementation steps.
+
+Task name: ${task.name}
+
+Description:
+${task.description || '(no description provided)'}
+${context}
+
+Analyze this task and break it into smaller, independently implementable sub-tasks that should be executed sequentially. Each sub-task should be a coherent unit of work that can be committed separately.
+
+Respond with valid JSON only — no markdown fences, no extra text:
+{
+  "instructions": "Detailed implementation instructions in markdown covering the full task — architecture decisions, key files to modify, edge cases to handle, testing approach",
+  "subtasks": [
+    {
+      "id": 1,
+      "title": "Short title for the sub-task",
+      "description": "Detailed description of what to implement in this step, including specific files and functions to change"
+    }
+  ]
+}
+
 Keep sub-tasks focused: 2-6 sub-tasks is ideal. Order them by dependency (foundation first).`;
     logger_1.logger.info('Analyzing task and creating implementation plan...');
     const result = await runner.run(analysisPrompt);
@@ -765,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');
@@ -776,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')
@@ -785,20 +896,23 @@ async function executeSubTask(subtask, task, plan, config, runners, reviewContex
         .filter((s) => s.status === 'done')
         .map((s) => `  - [done] ${s.id}. ${s.title}`)
         .join('\n');
-    const prompt = `You are implementing step ${subtask.id} of a multi-step task.
-
-Overall task: ${task.name}
-${task.description ? `\nTask description:\n${task.description}` : ''}
-
-## Full implementation instructions
-${instructions}
-${reviewContext || ''}
-## Progress
-${completedSteps || '(no steps completed yet)'}
-
-## Current step: ${subtask.id}. ${subtask.title}
-${subtask.description}
-
+    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}
+${task.description ? `\nTask description:\n${task.description}` : ''}
+
+## Full implementation instructions
+${instructions}
+${reviewContext || ''}${retrySection}
+## Progress
+${completedSteps || '(no steps completed yet)'}
+
+## Current step: ${subtask.id}. ${subtask.title}
+${subtask.description}
+
 Implement ONLY this step. Focus on correctness and follow the existing code style.`;
     let implemented = false;
     let previousNotes = '';
@@ -850,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) {
@@ -919,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}`);
             }
@@ -947,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}`);
@@ -954,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}`);
@@ -1036,29 +1191,29 @@ function buildCompletionComment(branch, prUrl, config) {
 function buildNonCodePrompt(task, context) {
     const hasComments = context.trim().length > 0;
     if (hasComments) {
-        return `Task: ${task.name}
-
-Original description:
-${task.description || '(no description provided)'}
-${context}
-
-⚠️ CRITICAL: This is a FOLLOW-UP request. The conversation above contains new comments from the user.
-YOUR PRIMARY TASK is to address the LATEST comment at the bottom of the conversation - this is the user's current request.
-The latest comment may:
-- Ask for something completely different from the original task
-- Request modifications to what was already done
-- Add new requirements
-
-DO NOT repeat what was already done. DO NOT re-execute the original task unless explicitly asked.
-Focus ENTIRELY on addressing the latest comment as your main instruction.
-
+        return `Task: ${task.name}
+
+Original description:
+${task.description || '(no description provided)'}
+${context}
+
+⚠️ CRITICAL: This is a FOLLOW-UP request. The conversation above contains new comments from the user.
+YOUR PRIMARY TASK is to address the LATEST comment at the bottom of the conversation - this is the user's current request.
+The latest comment may:
+- Ask for something completely different from the original task
+- Request modifications to what was already done
+- Add new requirements
+
+DO NOT repeat what was already done. DO NOT re-execute the original task unless explicitly asked.
+Focus ENTIRELY on addressing the latest comment as your main instruction.
+
 Please provide a clear, detailed response to the LATEST comment. Your response will be posted as a comment on the task ticket, so write it as a direct answer or explanation addressed to the person who wrote the latest comment.`;
     }
-    return `Task: ${task.name}
-
-Description:
-${task.description || '(no description provided)'}
-
+    return `Task: ${task.name}
+
+Description:
+${task.description || '(no description provided)'}
+
 Please provide a clear, detailed response to this task. Your response will be posted as a comment on the task ticket, so write it as a direct answer or explanation addressed to the person who created the task.`;
 }
 function buildNonCodeCompletionComment(config, agentResponse) {
@@ -1094,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);
@@ -1162,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
@@ -1356,22 +1523,22 @@ async function implementReviewTask(task, branchName, config, provider, runners,
     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.
-
+    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
@@ -1383,12 +1550,12 @@ Replace "thread_id" with the actual thread ID shown below.
         }
         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
+    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;
 }