@qelos/aidev 0.9.0 → 0.11.0

package/dist/commands/run.js

@@ -38,6 +38,10 @@ exports.getPendingStatus = getPendingStatus;
 exports.getOpenStatus = getOpenStatus;
 exports.getInReviewStatus = getInReviewStatus;
 exports.getRunSkipReason = getRunSkipReason;
+exports.isThinkingTask = isThinkingTask;
+exports.isPlanningTask = isPlanningTask;
+exports.buildPlanningAnalysisPrompt = buildPlanningAnalysisPrompt;
+exports.parsePlanningResponse = parsePlanningResponse;
 exports.sortTasksByPriority = sortTasksByPriority;
 exports.cleanupStaleThinkingArtifacts = cleanupStaleThinkingArtifacts;
 exports.writeTaskPlan = writeTaskPlan;
@@ -55,6 +59,7 @@ exports.checkNeedsClarification = checkNeedsClarification;
 exports.buildConflictResolutionPrompt = buildConflictResolutionPrompt;
 exports.buildImplementPrompt = buildImplementPrompt;
 exports.splitFailedSubtask = splitFailedSubtask;
+exports.implementPlanningTask = implementPlanningTask;
 exports.buildPRBody = buildPRBody;
 exports.tryCreatePR = tryCreatePR;
 exports.buildPRUrl = buildPRUrl;
@@ -64,6 +69,9 @@ exports.buildNonCodeCompletionComment = buildNonCodeCompletionComment;
 exports.hasAidevComment = hasAidevComment;
 exports.filterAutomatedComments = filterAutomatedComments;
 exports.hasHumanComment = hasHumanComment;
+exports.buildNonCodeAnalysisPrompt = buildNonCodeAnalysisPrompt;
+exports.buildNonCodeSubtaskPrompt = buildNonCodeSubtaskPrompt;
+exports.buildNonCodeThinkingCompletionComment = buildNonCodeThinkingCompletionComment;
 exports.parseReplyDirectives = parseReplyDirectives;
 exports.buildReviewPrompt = buildReviewPrompt;
 exports.buildReviewCompletionComment = buildReviewCompletionComment;
@@ -77,6 +85,7 @@ const diagnostics_1 = require("../diagnostics");
 const lockfile_1 = require("../lockfile");
 const hooks_1 = require("../hooks");
 const sessions_1 = require("../sessions");
+const accepted_1 = require("./accepted");
 const SKIP_STATUSES = new Set(['closed', 'done', 'cancelled', 'complete']);
 const NO_PRIORITY = Number.MAX_SAFE_INTEGER;
 const SLEEPING_MARKER = 'machine appears to be asleep';
@@ -141,6 +150,92 @@ function isThinkingTask(task, config) {
     const tag = config.thinkingTag.toLowerCase();
     return task.tags.some((t) => t.toLowerCase() === tag);
 }
+function isPlanningTask(task, config) {
+    if (!config.planningTag)
+        return false;
+    const tag = config.planningTag.toLowerCase();
+    return task.tags.some((t) => t.toLowerCase() === tag);
+}
+function buildPlanningAnalysisPrompt(task, context) {
+    const tagsLine = task.tags.length > 0
+        ? `\nParent task tags: ${task.tags.join(', ')}`
+        : '';
+    return `You are a senior software architect operating in PLANNING MODE. Your job is to break a parent task into a list of fully self-contained sub-task tickets that will be pushed to the task management provider and worked on independently — each by a different agent, in isolation, with NO access to the parent task or to its sibling sub-tasks.
+
+Parent task name: ${task.name}
+
+Parent task description:
+${task.description || '(no description provided)'}${tagsLine}
+${context}
+
+Decide one of:
+  (a) If critical information is missing and you cannot produce useful self-contained sub-tasks without it, return a single clarification question.
+  (b) Otherwise, return a list of sub-task drafts.
+
+CRITICAL — each sub-task description MUST be fully isolated:
+  - Do NOT reference the parent task, sibling sub-tasks, or "the plan".
+  - Do NOT use phrases like "as discussed above", "see the parent ticket", "from step 1", or "after the previous sub-task". The agent executing this sub-task will not see any of that.
+  - Include every file path, function name, schema, constraint, reasoning, and reference the executing agent will need to complete the work standalone.
+  - Restate any shared context (architecture decisions, conventions, motivation) that is required to do the work correctly.
+  - Each description should read like its own complete ticket — title, what to change, why, where, and acceptance criteria.
+
+Sub-task priority is optional and uses an integer 1–4 (1 = urgent, 4 = low). Omit the field if you have no opinion.
+
+Respond with valid JSON only — no markdown fences, no extra text:
+{
+  "clarification": "question text, or null if no clarification is needed",
+  "subtasks": [
+    {
+      "title": "Short, specific title",
+      "description": "Fully self-contained ticket body (markdown ok). Include all paths, references, and reasoning needed to do this work without seeing the parent ticket.",
+      "priority": 2
+    }
+  ]
+}
+
+If you set "clarification" to a non-null question, "subtasks" must be an empty array. If you provide sub-tasks, "clarification" must be null.`;
+}
+function parsePlanningResponse(output) {
+    const jsonMatch = output.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonMatch[0]);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const obj = parsed;
+    let clarification;
+    if (typeof obj.clarification === 'string') {
+        const trimmed = obj.clarification.trim();
+        if (trimmed.length > 0 && trimmed.toLowerCase() !== 'null') {
+            clarification = trimmed;
+        }
+    }
+    const rawSubtasks = Array.isArray(obj.subtasks) ? obj.subtasks : [];
+    const subtasks = [];
+    for (const s of rawSubtasks) {
+        if (!s || typeof s !== 'object')
+            continue;
+        const entry = s;
+        const title = typeof entry.title === 'string' ? entry.title.trim() : '';
+        const description = typeof entry.description === 'string' ? entry.description.trim() : '';
+        if (!title || !description)
+            continue;
+        const draft = { title, description };
+        if (typeof entry.priority === 'number' && Number.isFinite(entry.priority)) {
+            draft.priority = entry.priority;
+        }
+        subtasks.push(draft);
+    }
+    if (!clarification && subtasks.length === 0)
+        return null;
+    return clarification ? { clarification, subtasks } : { subtasks };
+}
 function sortTasksByPriority(tasks) {
     return [...tasks].sort((a, b) => (a.priority ?? NO_PRIORITY) - (b.priority ?? NO_PRIORITY));
 }
@@ -447,7 +542,10 @@ async function processTask(task, filter, config, provider, runners, screenAvaila
             return 'skipped';
         }
     }
-    if (isThinkingTask(task, config)) {
+    if (isPlanningTask(task, config)) {
+        await implementPlanningTask(task, config, provider, runners, hooks, vm);
+    }
+    else if (isThinkingTask(task, config)) {
         await implementThinkingTask(task, branchName, branchExists, config, provider, runners, hooks, vm);
     }
     else {
@@ -883,6 +981,8 @@ ${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.
 
+CRITICAL: Every sub-task MUST result in actual file modifications (create, edit, or delete files) that can be committed to git. A sub-task that produces no file changes is treated as a failure. Do NOT create sub-tasks that are pure investigation, verification, or read-only steps — for example "check if this folder exists", "review the existing code", "decide on an approach", "verify the build passes", or "run the tests". Any necessary investigation must happen inside a sub-task that also produces concrete file changes (e.g. fold the discovery into the step that applies the resulting edits). Each sub-task's description must name specific files and functions to add, modify, or remove.
+
 Respond with valid JSON only — no markdown fences, no extra text:
 {
   "taskSummary": "2-5 short sentences: overall goal and constraints only — for reuse in each sub-task prompt (no step-by-step detail; that goes in instructions and subtasks)",
@@ -891,7 +991,7 @@ Respond with valid JSON only — no markdown fences, no extra text:
     {
       "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"
+      "description": "Detailed description of what to implement in this step, including specific files and functions to change. Must describe concrete file modifications."
     }
   ]
 }
@@ -971,11 +1071,13 @@ ${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.
 
+CRITICAL: Each new sub-task MUST result in actual file modifications (create, edit, or delete files) that can be committed to git. Do NOT produce sub-tasks that are pure investigation, verification, or read-only steps (e.g. "check if this folder exists", "review the existing code", "verify the build passes"). Each description must name specific files and functions to change.
+
 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" }
+    { "title": "Short title for the first new sub-task", "description": "Detailed description of what to implement in this step, including specific files to change" },
+    { "title": "Short title for the second new sub-task", "description": "Detailed description of what to implement in this step, including specific files to change" }
   ]
 }
 
@@ -1277,6 +1379,137 @@ async function implementThinkingTask(task, branchName, branchExists, config, pro
     }
     logger_1.logger.success(`Thinking task implemented: branch ${branchName} pushed`);
 }
+async function implementPlanningTask(task, config, provider, runners, _hooks = {}, _vm) {
+    logger_1.logger.info(`Implementing planning task: ${task.name}`);
+    try {
+        await provider.updateStatus(task.id, 'in progress');
+        await provider.postComment(task.id, `${config.commentPrefix} Starting planning mode — analyzing task and drafting sub-tickets`);
+    }
+    catch (err) {
+        logger_1.logger.warn(`Could not update task status: ${err}`);
+    }
+    let context = '';
+    try {
+        const comments = await provider.getComments(task.id);
+        context = await buildConversationContext(task.id, comments, config, runners);
+    }
+    catch {
+        // ignore
+    }
+    const prompt = buildPlanningAnalysisPrompt(task, context);
+    let parsed = null;
+    let previousNotes = '';
+    for (const runner of runners) {
+        if (!runner.isAvailable())
+            continue;
+        logger_1.logger.info(`Running ${runner.name} for planning analysis...`);
+        const result = await runner.run(prompt, previousNotes || undefined);
+        if (!result.success) {
+            logger_1.logger.warn(`${runner.name} planning analysis failed — trying next runner`);
+            previousNotes = `Previous runner (${runner.name}) output:\n${result.output}\nErrors:\n${result.error}`;
+            continue;
+        }
+        parsed = parsePlanningResponse(result.output);
+        if (parsed)
+            break;
+        logger_1.logger.warn(`${runner.name} planning analysis returned unparseable output — trying next runner`);
+        previousNotes = `Previous runner (${runner.name}) produced unparseable output:\n${result.output}`;
+    }
+    if (!parsed) {
+        logger_1.logger.error('Planning produced no sub-tasks');
+        try {
+            await provider.postComment(task.id, `${config.commentPrefix} Planning produced no sub-tasks`);
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    if (parsed.clarification) {
+        try {
+            await provider.postComment(task.id, `${config.commentPrefix} ${parsed.clarification}`);
+            await provider.updateStatus(task.id, getPendingStatus(config));
+            logger_1.logger.info(`Posted planning clarification, set status to ${getPendingStatus(config)}`);
+        }
+        catch (err) {
+            logger_1.logger.warn(`Failed to post clarification or set pending status: ${err instanceof Error ? err.message : err}`);
+        }
+        return;
+    }
+    if (parsed.subtasks.length === 0) {
+        logger_1.logger.error('Planning produced no sub-tasks');
+        try {
+            await provider.postComment(task.id, `${config.commentPrefix} Planning produced no sub-tasks`);
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    const planningTagLower = config.planningTag.toLowerCase();
+    const ticketTags = task.tags.filter((t) => t.toLowerCase() !== planningTagLower);
+    const created = [];
+    const failures = [];
+    for (const draft of parsed.subtasks) {
+        try {
+            const result = await provider.createTask({
+                title: draft.title,
+                description: draft.description,
+                tags: ticketTags,
+                priority: draft.priority,
+                listId: task.sourceListId,
+            });
+            created.push({ title: draft.title, url: result.url, id: result.id });
+            logger_1.logger.success(`  Created sub-ticket "${draft.title}" — ${result.url}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger_1.logger.warn(`  Failed to create sub-ticket "${draft.title}": ${message}`);
+            failures.push({ title: draft.title, error: message });
+        }
+    }
+    const summaryLines = [
+        `${config.commentPrefix} Planning complete — created ${created.length} ticket${created.length === 1 ? '' : 's'}` +
+            (failures.length > 0 ? ` (${failures.length} failed)` : '') +
+            ':',
+    ];
+    if (created.length > 0) {
+        summaryLines.push('');
+        for (const c of created) {
+            summaryLines.push(`- ${c.title} — ${c.url}`);
+        }
+    }
+    if (failures.length > 0) {
+        summaryLines.push('', 'Failed to create:');
+        for (const f of failures) {
+            summaryLines.push(`- ${f.title} — ${f.error}`);
+        }
+    }
+    try {
+        await provider.postComment(task.id, summaryLines.join('\n'));
+    }
+    catch (err) {
+        logger_1.logger.warn(`Failed to post planning summary: ${err instanceof Error ? err.message : err}`);
+    }
+    if (config.planningTag && provider.removeTag) {
+        try {
+            await provider.removeTag(task.id, config.planningTag);
+        }
+        catch (err) {
+            logger_1.logger.warn(`Could not remove planning tag: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    const doneStatus = await (0, accepted_1.resolveDoneStatus)(config, provider);
+    if (doneStatus) {
+        try {
+            await provider.updateStatus(task.id, doneStatus);
+            logger_1.logger.info(`Planning task transitioned to "${doneStatus}"`);
+        }
+        catch (err) {
+            logger_1.logger.warn(`Failed to transition planning task to "${doneStatus}": ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    else {
+        logger_1.logger.warn('No done status configured or detectable — leaving planning task in current status');
+    }
+    logger_1.logger.success(`Planning task complete: ${task.name}`);
+}
 /**
  * Attempts to create a PR via `gh` CLI. Falls back to a compare URL if gh is
  * unavailable or PR creation fails.
@@ -1444,7 +1677,15 @@ async function processNonCodeTask(task, filter, config, provider, runners, scree
             return 'skipped';
         }
     }
-    await implementNonCodeTask(task, config, provider, runners, hooks, vm);
+    if (isPlanningTask(task, config)) {
+        await implementPlanningTask(task, config, provider, runners, hooks, vm);
+    }
+    else if (isThinkingTask(task, config)) {
+        await implementNonCodeThinkingTask(task, config, provider, runners, hooks, vm);
+    }
+    else {
+        await implementNonCodeTask(task, config, provider, runners, hooks, vm);
+    }
     return 'processed';
 }
 async function implementNonCodeTask(task, config, provider, runners, hooks = {}, vm) {
@@ -1512,6 +1753,267 @@ async function implementNonCodeTask(task, config, provider, runners, hooks = {},
     }
     logger_1.logger.success(`Non-code task complete: ${task.name}`);
 }
+function buildNonCodeAnalysisPrompt(task, context) {
+    return `You are a senior analyst breaking down a non-code task (research, investigation, documentation, communication, planning, etc.) into smaller, sequential sub-tasks.
+
+Each sub-task will be executed in order. Each later sub-task will receive a short summary of every earlier sub-task's result, so subsequent steps can build on previous findings.
+
+Task name: ${task.name}
+
+Description:
+${task.description || '(no description provided)'}
+${context}
+
+Analyze this task and break it into 2-8 focused, sequential sub-tasks. Each sub-task should be a coherent unit of work that produces a textual outcome (analysis, summary, draft, list of findings, etc.) — no code changes are expected.
+
+Respond with valid JSON only — no markdown fences, no extra text:
+{
+  "taskSummary": "2-5 short sentences: overall goal and constraints only — reused as compact context for each sub-task",
+  "subtasks": [
+    {
+      "id": 1,
+      "title": "Short title for the sub-task",
+      "description": "Detailed description of what to investigate, produce, or decide in this step"
+    }
+  ]
+}
+
+Order sub-tasks by dependency (foundation first). Keep titles short — they will appear in ticket comments.`;
+}
+function buildNonCodeSubtaskPrompt(subtask, task, plan, previousResults, reviewContext) {
+    const completedSteps = plan.subtasks
+        .filter((s) => s.status === 'done')
+        .map((s) => `  - [done] ${formatSubtaskId(s.id)} ${s.title}`)
+        .join('\n');
+    const previousSection = previousResults.length > 0
+        ? `\n## Summaries from previous sub-tasks\nUse these findings as context — do not repeat work already done.\n\n${previousResults
+            .map((r) => `### ${formatSubtaskId(r.id)} ${r.title}\n${r.summary}`)
+            .join('\n\n')}\n`
+        : '';
+    const summary = plan.taskSummary?.trim();
+    const goalSection = summary
+        ? `\nGoal (concise):\n${summary}\n`
+        : task.description?.trim()
+            ? `\nTask description:\n${task.description.trim()}\n`
+            : '';
+    return `You are working on step ${formatSubtaskId(subtask.id)} of a multi-step non-code task. No code changes are expected — produce a clear textual response.
+
+Overall task: ${task.name}${goalSection}${previousSection}${reviewContext || ''}## Progress
+${completedSteps || '(no steps completed yet)'}
+
+## Current step: ${formatSubtaskId(subtask.id)} ${subtask.title}
+${subtask.description}
+
+Focus ONLY on this step. Write the response so it can be posted directly as a ticket comment — clear, self-contained, and addressed to the task's stakeholders. Do not include preambles like "Here's text you can paste"; output only the content itself.`;
+}
+function buildNonCodeThinkingCompletionComment(config) {
+    return [
+        `${config.commentPrefix} Non-code task complete!`,
+        ``,
+        `All sub-tasks finished. Individual summaries were posted above.`,
+        ``,
+        `Status set to: ${getInReviewStatus(config)}`,
+    ].join('\n');
+}
+async function analyzeAndPlanNonCode(task, context, runners) {
+    const runner = runners.find((r) => r.isAvailable());
+    if (!runner) {
+        logger_1.logger.error('No AI runner available for non-code task analysis');
+        return null;
+    }
+    const analysisPrompt = buildNonCodeAnalysisPrompt(task, context);
+    logger_1.logger.info('Analyzing non-code task and creating sub-task plan...');
+    const result = await runner.run(analysisPrompt);
+    if (!result.success) {
+        logger_1.logger.error('Non-code task analysis failed');
+        return null;
+    }
+    try {
+        const jsonMatch = result.output.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            logger_1.logger.error('Could not parse non-code analysis response — no JSON found');
+            return null;
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (!parsed.subtasks || parsed.subtasks.length === 0) {
+            logger_1.logger.error('Non-code analysis produced no sub-tasks');
+            return null;
+        }
+        const taskSummaryRaw = typeof parsed.taskSummary === 'string' ? parsed.taskSummary.trim() : '';
+        const plan = {
+            taskId: task.id,
+            taskName: task.name,
+            ...(taskSummaryRaw ? { taskSummary: taskSummaryRaw } : {}),
+            subtasks: parsed.subtasks.map((s, i) => ({
+                id: s.id ?? i + 1,
+                title: s.title,
+                description: s.description,
+                status: 'pending',
+                attempts: 0,
+            })),
+        };
+        return plan;
+    }
+    catch (err) {
+        logger_1.logger.error(`Failed to parse non-code analysis response: ${err}`);
+        return null;
+    }
+}
+async function implementNonCodeThinkingTask(task, config, provider, runners, hooks = {}, vm) {
+    logger_1.logger.info(`Implementing non-code thinking task: ${task.name}`);
+    try {
+        await provider.updateStatus(task.id, 'in progress');
+        await provider.postComment(task.id, `${config.commentPrefix} Starting non-code task execution (thinking mode — will analyze and break into sub-tasks)`);
+    }
+    catch (err) {
+        logger_1.logger.warn(`Could not update task status: ${err}`);
+    }
+    let context = '';
+    try {
+        const comments = await provider.getComments(task.id);
+        context = await buildConversationContext(task.id, comments, config, runners);
+    }
+    catch {
+        // ignore
+    }
+    const plan = await analyzeAndPlanNonCode(task, context, runners);
+    if (!plan) {
+        logger_1.logger.error('Failed to create non-code task plan');
+        await provider.postComment(task.id, `${config.commentPrefix} Failed to analyze and break down the non-code task. Manual intervention needed.`);
+        return;
+    }
+    logger_1.logger.info(`Non-code task broken into ${plan.subtasks.length} sub-tasks`);
+    try {
+        await provider.postComment(task.id, `${config.commentPrefix} Task analyzed and broken into ${plan.subtasks.length} sub-tasks:\n\n${formatSubtaskList(plan)}`);
+    }
+    catch (err) {
+        logger_1.logger.warn(`Failed to post non-code breakdown comment: ${err}`);
+    }
+    // beforeThinkingTask hook — may adjust subtask titles/descriptions before execution.
+    // branchName is empty because non-code tasks don't create a branch.
+    if (vm) {
+        const thinkCtx = {
+            task,
+            config,
+            branchName: '',
+            subtasks: plan.subtasks.map((s) => ({
+                id: s.id,
+                title: s.title,
+                description: s.description,
+                status: s.status,
+            })),
+        };
+        const modified = await (0, hooks_1.executeHook)(hooks, 'beforeThinkingTask', thinkCtx, vm);
+        const prevById = new Map(plan.subtasks.map((s) => [s.id, s]));
+        plan.subtasks = modified.subtasks.map((s) => {
+            const prev = prevById.get(s.id);
+            return {
+                id: s.id,
+                title: s.title,
+                description: s.description,
+                status: (prev?.status ?? s.status),
+                attempts: prev?.attempts ?? 0,
+                lastError: prev?.lastError,
+            };
+        });
+    }
+    const previousResults = [];
+    let allSucceeded = true;
+    for (const subtask of plan.subtasks) {
+        subtask.status = 'running';
+        subtask.attempts = (subtask.attempts ?? 0) + 1;
+        logger_1.logger.info(`  Starting non-code step ${formatSubtaskId(subtask.id)}: ${subtask.title}`);
+        const prompt = buildNonCodeSubtaskPrompt(subtask, task, plan, previousResults, undefined);
+        let summary = '';
+        let success = false;
+        let previousNotes = '';
+        for (const runner of runners) {
+            if (!runner.isAvailable())
+                continue;
+            logger_1.logger.info(`    Running ${runner.name} for step ${formatSubtaskId(subtask.id)}...`);
+            const result = await runner.run(prompt, previousNotes || undefined);
+            if (result.success && result.output.trim().length > 0) {
+                summary = result.output.trim();
+                success = true;
+                break;
+            }
+            if (!result.success) {
+                logger_1.logger.warn(`    ${runner.name} failed — trying next runner`);
+                previousNotes = `Previous runner (${runner.name}) output:\n${result.output}\nErrors:\n${result.error}`;
+            }
+            else {
+                logger_1.logger.warn(`    ${runner.name} produced empty output — trying next runner`);
+                previousNotes = `Previous runner (${runner.name}) produced empty output.`;
+            }
+        }
+        if (!success) {
+            subtask.status = 'failed';
+            subtask.lastError = previousNotes;
+            allSucceeded = false;
+            logger_1.logger.error(`  Non-code step ${formatSubtaskId(subtask.id)} failed: ${subtask.title}`);
+            try {
+                await provider.postComment(task.id, `${config.commentPrefix} Step ${formatSubtaskId(subtask.id)} failed: ${subtask.title}\n\n${formatSubtaskList(plan)}`);
+            }
+            catch { /* ignore */ }
+            break;
+        }
+        // Post the sub-task summary BEFORE marking it done — per the task spec, the
+        // comment is posted, then the sub-task is announced as complete.
+        try {
+            await provider.postComment(task.id, `${config.commentPrefix} Step ${formatSubtaskId(subtask.id)}: ${subtask.title}\n\n---\n\n${summary}`);
+        }
+        catch (err) {
+            logger_1.logger.warn(`Failed to post summary for step ${formatSubtaskId(subtask.id)}: ${err}`);
+        }
+        previousResults.push({ id: subtask.id, title: subtask.title, summary });
+        subtask.status = 'done';
+        logger_1.logger.success(`  Non-code step ${formatSubtaskId(subtask.id)} complete: ${subtask.title}`);
+        try {
+            await provider.postComment(task.id, `${config.commentPrefix} Step ${formatSubtaskId(subtask.id)} complete: ${subtask.title}\n\n${formatSubtaskList(plan)}`);
+        }
+        catch { /* ignore */ }
+    }
+    if (!allSucceeded) {
+        logger_1.logger.error('Non-code thinking task did not complete all sub-tasks');
+        try {
+            await provider.postComment(task.id, `${config.commentPrefix} Non-code thinking task did not complete all sub-tasks. Manual intervention needed.`);
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    try {
+        await provider.postComment(task.id, buildNonCodeThinkingCompletionComment(config));
+        await provider.updateStatus(task.id, getInReviewStatus(config));
+        if (config.thinkingTag && provider.removeTag) {
+            try {
+                await provider.removeTag(task.id, config.thinkingTag);
+            }
+            catch (err) {
+                logger_1.logger.warn(`Could not remove thinking tag: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+    }
+    catch (err) {
+        logger_1.logger.warn(`Non-code thinking task done but failed to update task: ${err instanceof Error ? err.message : err}`);
+    }
+    // afterThinkingTask hook
+    if (vm) {
+        const afterCtx = {
+            task,
+            config,
+            branchName: '',
+            subtasks: plan.subtasks.map((s) => ({
+                id: s.id,
+                title: s.title,
+                description: s.description,
+                status: s.status,
+            })),
+            success: true,
+        };
+        await (0, hooks_1.executeHook)(hooks, 'afterThinkingTask', afterCtx, vm);
+    }
+    logger_1.logger.success(`Non-code thinking task complete: ${task.name}`);
+}
 // ─── Review task processing ─────────────────────────────────────────────────
 const REPLY_REGEX = /<!-- AIDEV-REPLY ([\w=+/]+) -->([\s\S]*?)<!-- \/AIDEV-REPLY -->/g;
 function parseReplyDirectives(output) {