@mcoda/core 0.1.4

package/dist/services/execution/QaTasksService.js

@@ -0,0 +1,1117 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { WorkspaceRepository } from '@mcoda/db';
+import { PathHelper } from '@mcoda/shared';
+import { JobService } from '../jobs/JobService.js';
+import { TaskSelectionService } from './TaskSelectionService.js';
+import { TaskStateService } from './TaskStateService.js';
+import { QaProfileService } from './QaProfileService.js';
+import { QaFollowupService } from './QaFollowupService.js';
+import { CliQaAdapter } from '@mcoda/integrations/qa/CliQaAdapter.js';
+import { ChromiumQaAdapter } from '@mcoda/integrations/qa/ChromiumQaAdapter.js';
+import { MaestroQaAdapter } from '@mcoda/integrations/qa/MaestroQaAdapter.js';
+import { VcsClient } from '@mcoda/integrations';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { AgentService } from '@mcoda/agents';
+import { GlobalRepository } from '@mcoda/db';
+import { DocdexClient } from '@mcoda/integrations';
+import { RoutingService } from '../agents/RoutingService.js';
+const DEFAULT_QA_PROMPT = [
+    'You are the QA agent. Before testing, query docdex with the task key and feature keywords (MCP `docdex_search` limit 4–8 or CLI `docdexd query --repo <repo> --query \"<term>\" --limit 6 --snippets=false`). If results look stale, reindex (`docdex_index` or `docdexd index --repo <repo>`) then re-run. Fetch snippets via `docdex_open` or `/snippet/:doc_id?text_only=true` only for specific hits.',
+    'Use docdex snippets to derive acceptance criteria, data contracts, edge cases, and non-functional requirements (performance, accessibility, offline/online assumptions). Note if docdex is unavailable and fall back to local docs.',
+].join('\n');
+const DEFAULT_JOB_PROMPT = 'You are an mcoda agent that follows workspace runbooks and responds with actionable, concise output.';
+const DEFAULT_CHARACTER_PROMPT = 'Write clearly, avoid hallucinations, cite assumptions, and prioritize risk mitigation for the user.';
+const MCODA_GITIGNORE_ENTRY = '.mcoda/\n';
+export class QaTasksService {
+    constructor(workspace, deps) {
+        this.workspace = workspace;
+        this.deps = deps;
+        this.dryRunGuard = false;
+        this.selectionService = deps.selectionService ?? new TaskSelectionService(workspace, deps.workspaceRepo);
+        this.stateService = deps.stateService ?? new TaskStateService(deps.workspaceRepo);
+        this.profileService = deps.profileService ?? new QaProfileService(workspace.workspaceRoot);
+        this.followupService = deps.followupService ?? new QaFollowupService(deps.workspaceRepo, workspace.workspaceRoot);
+        this.jobService = deps.jobService;
+        this.vcs = deps.vcsClient ?? new VcsClient();
+        this.agentService = deps.agentService;
+        this.docdex = deps.docdex;
+        this.repo = deps.repo;
+        this.routingService = deps.routingService;
+    }
+    static async create(workspace, options = {}) {
+        const repo = await GlobalRepository.create();
+        const agentService = new AgentService(repo);
+        const docdex = new DocdexClient({
+            workspaceRoot: workspace.workspaceRoot,
+            baseUrl: workspace.config?.docdexUrl ?? process.env.MCODA_DOCDEX_URL,
+        });
+        const routingService = await RoutingService.create();
+        const workspaceRepo = await WorkspaceRepository.create(workspace.workspaceRoot);
+        const jobService = new JobService(workspace, workspaceRepo, {
+            noTelemetry: options.noTelemetry ?? false,
+        });
+        const selectionService = new TaskSelectionService(workspace, workspaceRepo);
+        const stateService = new TaskStateService(workspaceRepo);
+        const profileService = new QaProfileService(workspace.workspaceRoot);
+        const followupService = new QaFollowupService(workspaceRepo, workspace.workspaceRoot);
+        const vcsClient = new VcsClient();
+        return new QaTasksService(workspace, {
+            workspaceRepo,
+            jobService,
+            selectionService,
+            stateService,
+            profileService,
+            followupService,
+            vcsClient,
+            agentService,
+            docdex,
+            repo,
+            routingService,
+        });
+    }
+    async close() {
+        const maybeClose = async (target) => {
+            try {
+                if (target?.close)
+                    await target.close();
+            }
+            catch {
+                /* ignore */
+            }
+        };
+        await maybeClose(this.deps.selectionService);
+        await maybeClose(this.deps.stateService);
+        await maybeClose(this.deps.jobService);
+        await maybeClose(this.deps.workspaceRepo);
+        await maybeClose(this.agentService);
+        await maybeClose(this.repo);
+        await maybeClose(this.docdex);
+        await maybeClose(this.deps.routingService);
+    }
+    async readPromptFiles(paths) {
+        const contents = [];
+        const seen = new Set();
+        for (const promptPath of paths) {
+            try {
+                const content = await fs.readFile(promptPath, 'utf8');
+                const trimmed = content.trim();
+                if (trimmed && !seen.has(trimmed)) {
+                    contents.push(trimmed);
+                    seen.add(trimmed);
+                }
+            }
+            catch {
+                /* optional prompt */
+            }
+        }
+        return contents;
+    }
+    async loadPrompts(agentId) {
+        const mcodaPromptPath = path.join(this.workspace.workspaceRoot, '.mcoda', 'prompts', 'qa-agent.md');
+        const workspacePromptPath = path.join(this.workspace.workspaceRoot, 'prompts', 'qa-agent.md');
+        try {
+            await fs.mkdir(path.dirname(mcodaPromptPath), { recursive: true });
+            await fs.access(mcodaPromptPath);
+            console.info(`[qa-tasks] using existing QA prompt at ${mcodaPromptPath}`);
+        }
+        catch {
+            try {
+                await fs.access(workspacePromptPath);
+                await fs.copyFile(workspacePromptPath, mcodaPromptPath);
+                console.info(`[qa-tasks] copied QA prompt to ${mcodaPromptPath}`);
+            }
+            catch {
+                console.info(`[qa-tasks] no QA prompt found at ${workspacePromptPath}; writing default prompt to ${mcodaPromptPath}`);
+                await fs.writeFile(mcodaPromptPath, DEFAULT_QA_PROMPT, 'utf8');
+            }
+        }
+        const commandPromptFiles = await this.readPromptFiles([mcodaPromptPath, workspacePromptPath]);
+        const agentPrompts = this.agentService && 'getPrompts' in this.agentService ? await this.agentService.getPrompts(agentId) : undefined;
+        const mergedCommandPrompt = (() => {
+            const parts = [...commandPromptFiles];
+            if (agentPrompts?.commandPrompts?.['qa-tasks']) {
+                parts.push(agentPrompts.commandPrompts['qa-tasks']);
+            }
+            if (!parts.length)
+                parts.push(DEFAULT_QA_PROMPT);
+            return parts.filter(Boolean).join('\n\n');
+        })();
+        return {
+            jobPrompt: agentPrompts?.jobPrompt ?? DEFAULT_JOB_PROMPT,
+            characterPrompt: agentPrompts?.characterPrompt ?? DEFAULT_CHARACTER_PROMPT,
+            commandPrompt: mergedCommandPrompt || undefined,
+        };
+    }
+    async checkpoint(jobId, stage, details) {
+        await this.jobService.writeCheckpoint(jobId, {
+            stage,
+            timestamp: new Date().toISOString(),
+            details,
+        });
+    }
+    async ensureTaskBranch(task, taskRunId) {
+        try {
+            await this.vcs.ensureRepo(this.workspace.workspaceRoot);
+            await this.vcs.ensureClean(this.workspace.workspaceRoot, true);
+            if (task.task.vcsBranch) {
+                const exists = await this.vcs.branchExists(this.workspace.workspaceRoot, task.task.vcsBranch);
+                if (!exists) {
+                    return { ok: false, message: `Task branch ${task.task.vcsBranch} not found` };
+                }
+                await this.vcs.checkoutBranch(this.workspace.workspaceRoot, task.task.vcsBranch);
+            }
+            else {
+                const base = this.workspace.config?.branch ?? 'mcoda-dev';
+                await this.vcs.ensureBaseBranch(this.workspace.workspaceRoot, base);
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            await this.logTask(taskRunId, `VCS check failed: ${error?.message ?? error}`, 'vcs');
+            return { ok: false, message: error?.message ?? String(error) };
+        }
+    }
+    async ensureMcoda() {
+        await PathHelper.ensureDir(this.workspace.mcodaDir);
+        const gitignorePath = `${this.workspace.workspaceRoot}/.gitignore`;
+        try {
+            const content = await fs.readFile(gitignorePath, 'utf8');
+            if (!content.includes('.mcoda/')) {
+                await fs.writeFile(gitignorePath, `${content.trimEnd()}\n${MCODA_GITIGNORE_ENTRY}`, 'utf8');
+            }
+        }
+        catch {
+            await fs.writeFile(gitignorePath, MCODA_GITIGNORE_ENTRY, 'utf8');
+        }
+    }
+    adapterForProfile(profile) {
+        const runner = profile?.runner ?? 'cli';
+        if (runner === 'cli')
+            return new CliQaAdapter();
+        if (runner === 'chromium')
+            return new ChromiumQaAdapter();
+        if (runner === 'maestro')
+            return new MaestroQaAdapter();
+        return new CliQaAdapter();
+    }
+    mapOutcome(result) {
+        if (result.outcome === 'pass')
+            return 'pass';
+        if (result.outcome === 'infra_issue')
+            return 'infra_issue';
+        return 'fix_required';
+    }
+    combineOutcome(result, recommendation) {
+        const base = this.mapOutcome(result);
+        if (!recommendation)
+            return base;
+        if (base === 'infra_issue' || recommendation === 'infra_issue')
+            return 'infra_issue';
+        if (base === 'fix_required')
+            return 'fix_required';
+        if (recommendation === 'fix_required')
+            return 'fix_required';
+        if (recommendation === 'unclear')
+            return 'unclear';
+        return 'pass';
+    }
+    async gatherDocContext(task, taskRunId) {
+        if (!this.docdex)
+            return '';
+        try {
+            const querySeeds = [task.key, task.title, ...(task.acceptanceCriteria ?? [])]
+                .filter(Boolean)
+                .join(' ')
+                .slice(0, 200);
+            const docs = await this.docdex.search({
+                projectKey: task.projectId,
+                profile: 'qa',
+                query: querySeeds,
+            });
+            const snippets = [];
+            for (const doc of docs.slice(0, 5)) {
+                const segments = (doc.segments ?? []).slice(0, 2);
+                const body = segments.length
+                    ? segments
+                        .map((seg, idx) => `  (${idx + 1}) ${seg.heading ? `${seg.heading}: ` : ''}${seg.content.slice(0, 400)}`)
+                        .join('\n')
+                    : doc.content
+                        ? doc.content.slice(0, 600)
+                        : '';
+                snippets.push(`- [${doc.docType}] ${doc.title ?? doc.path ?? doc.id}\n${body}`.trim());
+            }
+            return snippets.join('\n\n');
+        }
+        catch (error) {
+            if (taskRunId) {
+                await this.logTask(taskRunId, `Docdex search failed: ${error?.message ?? error}`, 'docdex');
+            }
+            return '';
+        }
+    }
+    async resolveAgent(agentName) {
+        if (!this.routingService || !this.agentService) {
+            throw new Error('RoutingService not available for QA routing');
+        }
+        const resolved = await this.routingService.resolveAgentForCommand({
+            workspace: this.workspace,
+            commandName: 'qa-tasks',
+            overrideAgentSlug: agentName,
+        });
+        return resolved.agent;
+    }
+    estimateTokens(text) {
+        return Math.max(1, Math.ceil((text?.length ?? 0) / 4));
+    }
+    extractJsonCandidate(raw) {
+        const fenced = raw.match(/```json([\s\S]*?)```/i);
+        const candidate = fenced ? fenced[1] : raw;
+        const start = candidate.indexOf('{');
+        const end = candidate.lastIndexOf('}');
+        if (start === -1 || end === -1 || end <= start)
+            return undefined;
+        try {
+            return JSON.parse(candidate.slice(start, end + 1));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    normalizeAgentOutput(parsed) {
+        if (!parsed || typeof parsed !== 'object')
+            return undefined;
+        const recommendation = parsed.recommendation;
+        if (!recommendation || !['pass', 'fix_required', 'infra_issue', 'unclear'].includes(recommendation))
+            return undefined;
+        const followUps = Array.isArray(parsed.follow_up_tasks)
+            ? parsed.follow_up_tasks
+            : Array.isArray(parsed.follow_ups)
+                ? parsed.follow_ups
+                : undefined;
+        const failures = Array.isArray(parsed.failures)
+            ? parsed.failures.map((f) => ({ kind: f.kind, message: f.message ?? String(f), evidence: f.evidence }))
+            : undefined;
+        return {
+            recommendation,
+            testedScope: parsed.tested_scope ?? parsed.scope,
+            coverageSummary: parsed.coverage_summary ?? parsed.coverage,
+            failures,
+            followUps,
+        };
+    }
+    async interpretResult(task, profile, result, agentName, stream, jobId, commandRunId, taskRunId) {
+        if (!this.agentService) {
+            return { recommendation: this.mapOutcome(result) };
+        }
+        try {
+            const agent = await this.resolveAgent(agentName);
+            const prompts = await this.loadPrompts(agent.id);
+            const systemPrompt = [prompts.jobPrompt, prompts.characterPrompt, prompts.commandPrompt].filter(Boolean).join('\n\n');
+            const docCtx = await this.gatherDocContext(task.task, taskRunId);
+            const acceptance = (task.task.acceptanceCriteria ?? []).map((line) => `- ${line}`).join('\n');
+            const prompt = [
+                systemPrompt,
+                'You are the mcoda QA agent. Interpret the QA execution results and return structured JSON.',
+                `Task: ${task.task.key} ${task.task.title}`,
+                `Task type: ${task.task.type ?? 'n/a'}, status: ${task.task.status}`,
+                task.task.description ? `Task description:\n${task.task.description}` : '',
+                `Epic/Story: ${task.task.epicKey ?? task.task.epicId} / ${task.task.storyKey ?? task.task.userStoryId}`,
+                acceptance ? `Acceptance criteria:\n${acceptance}` : 'Acceptance criteria: (not provided)',
+                `QA profile: ${profile.name} (${profile.runner ?? 'cli'})`,
+                `Test command / runner outcome: exit=${result.exitCode} outcome=${result.outcome}`,
+                result.stdout ? `Stdout (truncated):\n${result.stdout.slice(0, 3000)}` : '',
+                result.stderr ? `Stderr (truncated):\n${result.stderr.slice(0, 3000)}` : '',
+                result.artifacts?.length ? `Artifacts:\n${result.artifacts.join('\n')}` : '',
+                docCtx ? `Relevant docs (SDS/RFP/OpenAPI):\n${docCtx}` : '',
+                [
+                    'Return strict JSON with keys:',
+                    '{',
+                    '  "tested_scope": string,',
+                    '  "coverage_summary": string,',
+                    '  "failures": [{ "kind": "functional|contract|perf|security|infra", "message": string, "evidence": string }],',
+                    '  "recommendation": "pass|fix_required|infra_issue|unclear",',
+                    '  "follow_up_tasks": [{ "title": string, "description": string, "type": "bug|qa_followup|chore", "priority": number, "story_points": number, "tags": string[], "related_task_key": string, "epic_key": string, "story_key": string, "doc_links": string[], "evidence_url": string, "artifacts": string[] }]',
+                    '}',
+                    'Do not include prose outside the JSON.',
+                ].join('\n'),
+            ]
+                .filter(Boolean)
+                .join('\n\n');
+            const separator = "============================================================";
+            console.info(separator);
+            console.info("[qa-tasks] START OF TASK");
+            console.info(`[qa-tasks] Task key: ${task.task.key}`);
+            console.info(`[qa-tasks] Title: ${task.task.title ?? '(none)'}`);
+            console.info(`[qa-tasks] Description: ${task.task.description ?? '(none)'}`);
+            console.info(`[qa-tasks] Story points: ${typeof task.task.storyPoints === 'number' ? task.task.storyPoints : '(none)'}`);
+            console.info(`[qa-tasks] Dependencies: ${task.dependencies.keys.length ? task.dependencies.keys.join(', ') : '(none available)'}`);
+            if (acceptance)
+                console.info(`[qa-tasks] Acceptance criteria:\n${acceptance}`);
+            console.info(`[qa-tasks] System prompt used:\n${systemPrompt || '(none)'}`);
+            console.info(`[qa-tasks] Task prompt used:\n${prompt}`);
+            console.info(separator);
+            let output = '';
+            let chunkCount = 0;
+            if (stream && this.agentService.invokeStream) {
+                const gen = await this.agentService.invokeStream(agent.id, { input: prompt, metadata: { command: 'qa-tasks' } });
+                for await (const chunk of gen) {
+                    output += chunk.output ?? '';
+                    chunkCount += 1;
+                }
+            }
+            else {
+                const res = await this.agentService.invoke(agent.id, { input: prompt, metadata: { command: 'qa-tasks' } });
+                output = res.output ?? '';
+            }
+            const tokensPrompt = this.estimateTokens(prompt);
+            const tokensCompletion = this.estimateTokens(output);
+            if (!this.dryRunGuard) {
+                await this.jobService.recordTokenUsage({
+                    workspaceId: this.workspace.workspaceId,
+                    agentId: agent.id,
+                    modelName: agent.defaultModel,
+                    jobId,
+                    taskId: task.task.id,
+                    commandRunId,
+                    taskRunId,
+                    tokensPrompt,
+                    tokensCompletion,
+                    tokensTotal: tokensPrompt + tokensCompletion,
+                    timestamp: new Date().toISOString(),
+                    metadata: {
+                        commandName: 'qa-tasks',
+                        action: 'qa-interpret-results',
+                        taskKey: task.task.key,
+                        streaming: stream,
+                        streamChunks: chunkCount || undefined,
+                    },
+                });
+            }
+            const parsed = this.extractJsonCandidate(output);
+            const normalized = this.normalizeAgentOutput(parsed);
+            if (normalized) {
+                return {
+                    ...normalized,
+                    rawOutput: output,
+                    tokensPrompt,
+                    tokensCompletion,
+                    agentId: agent.id,
+                    modelName: agent.defaultModel,
+                };
+            }
+            return { recommendation: this.mapOutcome(result), rawOutput: output, tokensPrompt, tokensCompletion, agentId: agent.id, modelName: agent.defaultModel };
+        }
+        catch (error) {
+            if (taskRunId) {
+                await this.logTask(taskRunId, `QA agent failed: ${error?.message ?? error}`, 'qa-agent');
+            }
+            return { recommendation: this.mapOutcome(result) };
+        }
+    }
+    async createTaskRun(task, jobId, commandRunId) {
+        const startedAt = new Date().toISOString();
+        return this.deps.workspaceRepo.createTaskRun({
+            taskId: task.id,
+            command: 'qa-tasks',
+            jobId,
+            commandRunId,
+            status: 'running',
+            startedAt,
+            storyPointsAtRun: task.storyPoints ?? null,
+            gitBranch: task.vcsBranch ?? null,
+            gitBaseBranch: task.vcsBaseBranch ?? null,
+            gitCommitSha: task.vcsLastCommitSha ?? null,
+        });
+    }
+    async finishTaskRun(taskRun, status, extra) {
+        await this.deps.workspaceRepo.updateTaskRun(taskRun.id, {
+            status,
+            finishedAt: new Date().toISOString(),
+            gitBranch: extra?.gitBranch ?? taskRun.gitBranch,
+            gitBaseBranch: extra?.gitBaseBranch ?? taskRun.gitBaseBranch,
+            gitCommitSha: extra?.gitCommitSha ?? taskRun.gitCommitSha,
+            spPerHourEffective: extra?.spPerHourEffective ?? null,
+        });
+    }
+    async logTask(taskRunId, message, source, details) {
+        await this.deps.workspaceRepo.insertTaskLog({
+            taskRunId,
+            sequence: Math.floor(Math.random() * 1000000),
+            timestamp: new Date().toISOString(),
+            source: source ?? 'qa-tasks',
+            message,
+            details: details ?? undefined,
+        });
+    }
+    async applyStateTransition(task, outcome) {
+        const timestamp = { last_qa: new Date().toISOString() };
+        if (outcome === 'pass') {
+            await this.stateService.markCompleted(task, timestamp);
+        }
+        else if (outcome === 'fix_required') {
+            await this.stateService.returnToInProgress(task, timestamp);
+        }
+        else if (outcome === 'infra_issue') {
+            await this.stateService.markBlocked(task, 'qa_infra_issue');
+        }
+    }
+    buildFollowupSuggestion(task, result, notes) {
+        const summary = notes || result.stderr || result.stdout || 'QA failure detected';
+        const components = Array.isArray(task.metadata?.components) ? task.metadata.components : [];
+        const docLinks = Array.isArray(task.metadata?.doc_links) ? task.metadata.doc_links : [];
+        const tests = Array.isArray(task.metadata?.tests) ? task.metadata.tests : [];
+        return {
+            title: `QA follow-up for ${task.key}`,
+            description: `Follow-up created from QA run on ${task.key}.\n\nDetails:\n${summary}`.slice(0, 2000),
+            type: 'bug',
+            storyPoints: 1,
+            priority: 90,
+            tags: ['qa', 'qa-followup', ...components],
+            components,
+            docLinks,
+            testName: tests[0],
+        };
+    }
+    toFollowupSuggestion(task, agentFollow, artifacts) {
+        const taskComponents = Array.isArray(task.metadata?.components) ? task.metadata.components : [];
+        const taskDocLinks = Array.isArray(task.metadata?.doc_links) ? task.metadata.doc_links : [];
+        return {
+            title: agentFollow.title ?? `QA follow-up for ${task.key}`,
+            description: agentFollow.description,
+            type: agentFollow.type ?? 'bug',
+            priority: agentFollow.priority ?? 90,
+            storyPoints: agentFollow.story_points ?? 1,
+            tags: agentFollow.tags,
+            relatedTaskKey: agentFollow.related_task_key,
+            epicKeyHint: agentFollow.epic_key,
+            storyKeyHint: agentFollow.story_key,
+            components: agentFollow.components ?? taskComponents,
+            docLinks: agentFollow.doc_links ?? taskDocLinks,
+            evidenceUrl: agentFollow.evidence_url,
+            artifacts: agentFollow.artifacts ?? artifacts,
+        };
+    }
+    async suggestFollowupsFromAgent(task, notes, evidenceUrl, mode, jobId, commandRunId, taskRunId, agentStream = true) {
+        if (!this.agentService)
+            return [];
+        const agent = await this.resolveAgent(undefined);
+        const prompts = await this.loadPrompts(agent.id);
+        const systemPrompt = [prompts.jobPrompt, prompts.characterPrompt, prompts.commandPrompt].filter(Boolean).join('\n\n');
+        const docCtx = await this.gatherDocContext(task.task, taskRunId);
+        const prompt = [
+            systemPrompt,
+            'You are the mcoda QA agent. Given QA notes/evidence, propose structured follow-up tasks as JSON.',
+            `Task: ${task.task.key} ${task.task.title}`,
+            task.task.description ? `Task description:\n${task.task.description}` : '',
+            notes ? `QA notes:\n${notes}` : '',
+            evidenceUrl ? `Evidence URL: ${evidenceUrl}` : '',
+            docCtx ? `Relevant docs:\n${docCtx}` : '',
+            [
+                'Return JSON: { "follow_up_tasks": [ { "title": "...", "description": "...", "type": "bug|qa_followup|chore", "priority": number, "story_points": number, "tags": [], "related_task_key": string, "epic_key": string, "story_key": string, "doc_links": [], "evidence_url": string } ] }',
+                'No prose outside JSON.',
+            ].join('\n'),
+        ]
+            .filter(Boolean)
+            .join('\n\n');
+        let output = '';
+        let chunkCount = 0;
+        const useStream = agentStream && Boolean(this.agentService?.invokeStream);
+        try {
+            if (useStream && this.agentService.invokeStream) {
+                const gen = await this.agentService.invokeStream(agent.id, { input: prompt, metadata: { command: 'qa-tasks' } });
+                for await (const chunk of gen) {
+                    output += chunk.output ?? '';
+                    chunkCount += 1;
+                }
+            }
+            else {
+                const res = await this.agentService.invoke(agent.id, { input: prompt, metadata: { command: 'qa-tasks' } });
+                output = res.output ?? '';
+            }
+        }
+        catch {
+            return [];
+        }
+        const tokensPrompt = this.estimateTokens(prompt);
+        const tokensCompletion = this.estimateTokens(output);
+        if (!this.dryRunGuard) {
+            await this.jobService.recordTokenUsage({
+                workspaceId: this.workspace.workspaceId,
+                agentId: agent.id,
+                modelName: agent.defaultModel,
+                jobId,
+                taskId: task.task.id,
+                commandRunId,
+                taskRunId,
+                tokensPrompt,
+                tokensCompletion,
+                tokensTotal: tokensPrompt + tokensCompletion,
+                timestamp: new Date().toISOString(),
+                metadata: {
+                    commandName: 'qa-tasks',
+                    action: 'qa-manual-followups',
+                    taskKey: task.task.key,
+                    streaming: useStream || undefined,
+                    streamChunks: chunkCount || undefined,
+                },
+            });
+        }
+        const parsed = this.extractJsonCandidate(output);
+        const followUps = Array.isArray(parsed?.follow_up_tasks)
+            ? parsed.follow_up_tasks
+            : Array.isArray(parsed?.followUps)
+                ? parsed.followUps
+                : [];
+        return followUps.map((f) => this.toFollowupSuggestion(task.task, f, []));
+    }
+    async runAuto(task, ctx) {
+        const taskRun = await this.createTaskRun(task.task, ctx.jobId, ctx.commandRunId);
+        await this.logTask(taskRun.id, 'Starting QA', 'qa-start');
+        const allowedStatuses = new Set(ctx.request.statusFilter ?? ['ready_to_qa']);
+        if (task.task.status && !allowedStatuses.has(task.task.status)) {
+            const message = `Task status ${task.task.status} not allowed for QA`;
+            await this.logTask(taskRun.id, message, 'status-gate');
+            await this.finishTaskRun(taskRun, 'failed');
+            if (!this.dryRunGuard) {
+                await this.deps.workspaceRepo.createTaskQaRun({
+                    taskId: task.task.id,
+                    taskRunId: taskRun.id,
+                    jobId: ctx.jobId,
+                    commandRunId: ctx.commandRunId,
+                    source: 'auto',
+                    mode: 'auto',
+                    rawOutcome: 'infra_issue',
+                    recommendation: 'infra_issue',
+                    profileName: undefined,
+                    runner: undefined,
+                    metadata: { reason: 'status_gating' },
+                });
+            }
+            return { taskKey: task.task.key, outcome: 'infra_issue', notes: 'status_gating' };
+        }
+        const branchCheck = await this.ensureTaskBranch(task, taskRun.id);
+        if (!branchCheck.ok) {
+            if (!this.dryRunGuard) {
+                await this.applyStateTransition(task.task, 'infra_issue');
+                await this.finishTaskRun(taskRun, 'failed');
+                await this.deps.workspaceRepo.createTaskQaRun({
+                    taskId: task.task.id,
+                    taskRunId: taskRun.id,
+                    jobId: ctx.jobId,
+                    commandRunId: ctx.commandRunId,
+                    source: 'auto',
+                    mode: 'auto',
+                    rawOutcome: 'infra_issue',
+                    recommendation: 'infra_issue',
+                    metadata: { reason: 'vcs_branch_missing', detail: branchCheck.message },
+                });
+                await this.deps.workspaceRepo.createTaskComment({
+                    taskId: task.task.id,
+                    taskRunId: taskRun.id,
+                    jobId: ctx.jobId,
+                    sourceCommand: 'qa-tasks',
+                    authorType: 'agent',
+                    category: 'qa_issue',
+                    body: `VCS validation failed: ${branchCheck.message ?? 'unknown error'}`,
+                    createdAt: new Date().toISOString(),
+                });
+            }
+            return { taskKey: task.task.key, outcome: 'infra_issue', notes: 'vcs_branch_missing' };
+        }
+        let profile;
+        try {
+            profile = await this.profileService.resolveProfileForTask(task.task, {
+                profileName: ctx.request.profileName,
+                level: ctx.request.level,
+            });
+        }
+        catch (error) {
+            await this.logTask(taskRun.id, `Profile resolution failed: ${error?.message ?? error}`, 'qa-profile');
+            await this.finishTaskRun(taskRun, 'failed');
+            if (!this.dryRunGuard) {
+                await this.deps.workspaceRepo.createTaskQaRun({
+                    taskId: task.task.id,
+                    taskRunId: taskRun.id,
+                    jobId: ctx.jobId,
+                    commandRunId: ctx.commandRunId,
+                    source: 'auto',
+                    mode: 'auto',
+                    rawOutcome: 'infra_issue',
+                    recommendation: 'infra_issue',
+                    metadata: { reason: 'profile_resolution_failed', message: error?.message ?? String(error) },
+                });
+            }
+            return { taskKey: task.task.key, outcome: 'infra_issue', notes: 'profile_resolution_failed' };
+        }
+        if (!profile) {
+            await this.logTask(taskRun.id, 'No QA profile available', 'qa-profile');
+            await this.finishTaskRun(taskRun, 'failed');
+            if (!this.dryRunGuard) {
+                await this.deps.workspaceRepo.createTaskQaRun({
+                    taskId: task.task.id,
+                    taskRunId: taskRun.id,
+                    jobId: ctx.jobId,
+                    commandRunId: ctx.commandRunId,
+                    source: 'auto',
+                    mode: 'auto',
+                    rawOutcome: 'infra_issue',
+                    recommendation: 'infra_issue',
+                    metadata: { reason: 'no_profile' },
+                });
+            }
+            return { taskKey: task.task.key, outcome: 'infra_issue', notes: 'no_profile' };
+        }
+        const adapter = this.adapterForProfile(profile);
+        if (!adapter) {
+            await this.logTask(taskRun.id, 'No QA adapter for profile', 'qa-adapter');
+            await this.finishTaskRun(taskRun, 'failed');
+            if (!this.dryRunGuard) {
+                await this.deps.workspaceRepo.createTaskQaRun({
+                    taskId: task.task.id,
+                    taskRunId: taskRun.id,
+                    jobId: ctx.jobId,
+                    commandRunId: ctx.commandRunId,
+                    source: 'auto',
+                    mode: 'auto',
+                    profileName: profile.name,
+                    runner: profile.runner,
+                    rawOutcome: 'infra_issue',
+                    recommendation: 'infra_issue',
+                    metadata: { reason: 'no_adapter' },
+                });
+            }
+            return { taskKey: task.task.key, outcome: 'infra_issue', profile: profile.name, runner: profile.runner, notes: 'no_adapter' };
+        }
+        const qaCtx = {
+            workspaceRoot: this.workspace.workspaceRoot,
+            jobId: ctx.jobId,
+            taskKey: task.task.key,
+            env: process.env,
+            testCommandOverride: ctx.request.testCommand,
+        };
+        const ensure = await adapter.ensureInstalled(profile, qaCtx);
+        if (!ensure.ok) {
+            await this.logTask(taskRun.id, ensure.message ?? 'QA install failed', 'qa-install');
+            if (!this.dryRunGuard) {
+                await this.applyStateTransition(task.task, 'infra_issue');
+                await this.finishTaskRun(taskRun, 'failed');
+                await this.deps.workspaceRepo.createTaskQaRun({
+                    taskId: task.task.id,
+                    taskRunId: taskRun.id,
+                    jobId: ctx.jobId,
+                    commandRunId: ctx.commandRunId,
+                    source: 'auto',
+                    mode: 'auto',
+                    profileName: profile.name,
+                    runner: profile.runner,
+                    rawOutcome: 'infra_issue',
+                    recommendation: 'infra_issue',
+                    metadata: { install: ensure.message, adapter: profile.runner },
+                });
+            }
+            return {
+                taskKey: task.task.key,
+                outcome: 'infra_issue',
+                profile: profile.name,
+                runner: profile.runner,
+                notes: ensure.message,
+            };
+        }
+        const artifactDir = path.join(this.workspace.workspaceRoot, '.mcoda', 'jobs', ctx.jobId, 'qa', task.task.key);
+        await PathHelper.ensureDir(artifactDir);
+        const result = await adapter.invoke(profile, { ...qaCtx, artifactDir });
+        await this.logTask(taskRun.id, `QA run completed with outcome ${result.outcome}`, 'qa-exec', {
+            exitCode: result.exitCode,
+        });
+        const interpretation = await this.interpretResult(task, profile, result, ctx.request.agentName, ctx.request.agentStream ?? true, ctx.jobId, ctx.commandRunId, taskRun.id);
+        const outcome = this.combineOutcome(result, interpretation.recommendation);
+        const artifacts = result.artifacts ?? [];
+        let qaRun;
+        if (!this.dryRunGuard) {
+            qaRun = await this.deps.workspaceRepo.createTaskQaRun({
+                taskId: task.task.id,
+                taskRunId: taskRun.id,
+                jobId: ctx.jobId,
+                commandRunId: ctx.commandRunId,
+                agentId: interpretation.agentId,
+                modelName: interpretation.modelName,
+                source: 'auto',
+                mode: 'auto',
+                profileName: profile.name,
+                runner: profile.runner,
+                rawOutcome: result.outcome,
+                recommendation: interpretation.recommendation,
+                artifacts,
+                rawResult: {
+                    adapter: result,
+                    agent: interpretation.rawOutput,
+                },
+                startedAt: result.startedAt,
+                finishedAt: result.finishedAt,
+                metadata: {
+                    tokensPrompt: interpretation.tokensPrompt,
+                    tokensCompletion: interpretation.tokensCompletion,
+                    testedScope: interpretation.testedScope,
+                    coverageSummary: interpretation.coverageSummary,
+                    failures: interpretation.failures,
+                },
+            });
+        }
+        if (!this.dryRunGuard) {
+            await this.applyStateTransition(task.task, outcome);
+            await this.finishTaskRun(taskRun, outcome === 'pass' ? 'succeeded' : 'failed');
+        }
+        const followups = [];
+        if (outcome === 'fix_required' && ctx.request.createFollowupTasks !== 'none') {
+            const suggestions = interpretation.followUps?.map((f) => this.toFollowupSuggestion(task.task, f, artifacts)) ?? [];
+            if (suggestions.length === 0) {
+                suggestions.push(this.buildFollowupSuggestion(task.task, result, ctx.request.notes));
+            }
+            const interactive = ctx.request.createFollowupTasks === 'prompt' && process.stdout.isTTY;
+            for (const suggestion of suggestions) {
+                let proceed = ctx.request.createFollowupTasks !== 'prompt';
+                if (interactive) {
+                    const rl = readline.createInterface({ input, output });
+                    const answer = await rl.question(`Create follow-up task "${suggestion.title}" for ${task.task.key}? [y/N]: `);
+                    rl.close();
+                    proceed = answer.trim().toLowerCase().startsWith('y');
+                }
+                if (!proceed)
+                    continue;
+                try {
+                    if (!this.dryRunGuard) {
+                        const created = await this.followupService.createFollowupTask({ ...task.task, storyKey: task.task.storyKey, epicKey: task.task.epicKey }, suggestion);
+                        followups.push(created.task.key);
+                        await this.logTask(taskRun.id, `Created follow-up ${created.task.key}`, 'qa-followup');
+                    }
+                }
+                catch (error) {
+                    await this.logTask(taskRun.id, `Failed to create follow-up task: ${error?.message ?? error}`, 'qa-followup');
+                }
+            }
+        }
+        const bodyLines = [
+            `QA outcome: ${outcome}`,
+            profile ? `Profile: ${profile.name} (${profile.runner ?? 'cli'})` : '',
+            interpretation.coverageSummary ? `Coverage: ${interpretation.coverageSummary}` : '',
+            interpretation.failures && interpretation.failures.length
+                ? `Failures:\n${interpretation.failures.map((f) => `- [${f.kind ?? 'issue'}] ${f.message}${f.evidence ? ` (${f.evidence})` : ''}`).join('\n')}`
+                : '',
+            result.stdout ? `Stdout:\n${result.stdout.slice(0, 4000)}` : '',
+            result.stderr ? `Stderr:\n${result.stderr.slice(0, 4000)}` : '',
+            artifacts.length ? `Artifacts:\n${artifacts.join('\n')}` : '',
+            followups.length ? `Follow-ups: ${followups.join(', ')}` : '',
+        ].filter(Boolean);
+        if (!this.dryRunGuard) {
+            await this.deps.workspaceRepo.createTaskComment({
+                taskId: task.task.id,
+                taskRunId: taskRun.id,
+                jobId: ctx.jobId,
+                sourceCommand: 'qa-tasks',
+                authorType: 'agent',
+                category: outcome === 'pass' ? 'qa_result' : 'qa_issue',
+                body: bodyLines.join('\n\n'),
+                createdAt: new Date().toISOString(),
+                metadata: {
+                    ...(artifacts.length ? { artifacts } : {}),
+                    ...(qaRun?.id ? { qaRunId: qaRun.id } : {}),
+                },
+            });
+        }
+        return {
+            taskKey: task.task.key,
+            outcome,
+            profile: profile.name,
+            runner: profile.runner,
+            artifacts,
+            followups,
+        };
+    }
+    async runManual(task, ctx) {
+        const taskRun = await this.createTaskRun(task.task, ctx.jobId, ctx.commandRunId);
+        const result = ctx.request.result ?? 'pass';
+        const notes = ctx.request.notes;
+        const outcome = result === 'pass' ? 'pass' : result === 'blocked' ? 'infra_issue' : 'fix_required';
+        const allowedStatuses = new Set(ctx.request.statusFilter ?? ['ready_to_qa']);
+        if (task.task.status && !allowedStatuses.has(task.task.status)) {
+            const message = `Task status ${task.task.status} not allowed for manual QA`;
+            await this.logTask(taskRun.id, message, 'status-gate');
+            await this.finishTaskRun(taskRun, 'failed');
+            return { taskKey: task.task.key, outcome: 'infra_issue', notes: 'status_gating' };
+        }
+        if (!ctx.request.dryRun) {
+            await this.applyStateTransition(task.task, outcome);
+            await this.finishTaskRun(taskRun, outcome === 'pass' ? 'succeeded' : 'failed');
+        }
+        const followups = [];
+        const artifacts = [];
+        if (!ctx.request.dryRun) {
+            await this.deps.workspaceRepo.createTaskQaRun({
+                taskId: task.task.id,
+                taskRunId: taskRun.id,
+                jobId: ctx.jobId,
+                commandRunId: ctx.commandRunId,
+                source: 'manual',
+                mode: 'manual',
+                rawOutcome: result,
+                recommendation: outcome,
+                evidenceUrl: ctx.request.evidenceUrl,
+                artifacts,
+                rawResult: { notes },
+                metadata: { notes, evidenceUrl: ctx.request.evidenceUrl },
+            });
+        }
+        if (!ctx.request.dryRun && ctx.request.createFollowupTasks !== 'none' && outcome === 'fix_required') {
+            const suggestions = [
+                {
+                    title: `Manual QA follow-up for ${task.task.key}`,
+                    description: notes ?? 'Manual QA reported failure. Please investigate.',
+                    type: 'bug',
+                    storyPoints: 1,
+                    priority: 90,
+                    tags: ['qa', 'manual'],
+                    evidenceUrl: ctx.request.evidenceUrl,
+                },
+            ];
+            const agentSuggestions = await this.suggestFollowupsFromAgent(task, notes, ctx.request.evidenceUrl, 'manual', ctx.jobId, ctx.commandRunId, taskRun.id);
+            if (agentSuggestions.length) {
+                suggestions.unshift(...agentSuggestions);
+            }
+            const interactive = ctx.request.createFollowupTasks === 'prompt' && process.stdout.isTTY;
+            for (const suggestion of suggestions) {
+                let proceed = ctx.request.createFollowupTasks === 'auto' || ctx.request.createFollowupTasks === undefined;
+                if (interactive) {
+                    const rl = readline.createInterface({ input, output });
+                    const answer = await rl.question(`Create follow-up task "${suggestion.title}" for ${task.task.key}? [y/N]: `);
+                    rl.close();
+                    proceed = answer.trim().toLowerCase().startsWith('y');
+                }
+                if (!proceed)
+                    continue;
+                try {
+                    const created = await this.followupService.createFollowupTask({ ...task.task, storyKey: task.task.storyKey, epicKey: task.task.epicKey }, suggestion);
+                    followups.push(created.task.key);
+                }
+                catch (error) {
+                    await this.logTask(taskRun.id, `Follow-up creation failed: ${error?.message ?? error}`, 'qa-followup');
+                }
+            }
+        }
+        const body = [
+            `Manual QA outcome: ${result}`,
+            notes ? `Notes: ${notes}` : '',
+            ctx.request.evidenceUrl ? `Evidence: ${ctx.request.evidenceUrl}` : '',
+            artifacts.length ? `Artifacts:\n${artifacts.join('\n')}` : '',
+            followups.length ? `Follow-ups: ${followups.join(', ')}` : '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+        if (!ctx.request.dryRun) {
+            await this.deps.workspaceRepo.createTaskComment({
+                taskId: task.task.id,
+                taskRunId: taskRun.id,
+                jobId: ctx.jobId,
+                sourceCommand: 'qa-tasks',
+                authorType: 'human',
+                category: result === 'pass' ? 'qa_result' : 'qa_issue',
+                body,
+                createdAt: new Date().toISOString(),
+                metadata: {
+                    ...(ctx.request.evidenceUrl ? { evidence: ctx.request.evidenceUrl } : {}),
+                    ...(artifacts.length ? { artifacts } : {}),
+                },
+            });
+        }
+        return {
+            taskKey: task.task.key,
+            outcome,
+            artifacts,
+            followups,
+            notes,
+        };
+    }
+    async run(request) {
+        const resume = request.resumeJobId ? await this.deps.jobService.getJob(request.resumeJobId) : undefined;
+        if (request.resumeJobId && !resume) {
+            throw new Error(`Resume requested but job ${request.resumeJobId} not found`);
+        }
+        const effectiveProject = request.projectKey ?? resume?.payload?.projectKey;
+        const effectiveEpic = request.epicKey ?? resume?.payload?.epicKey;
+        const effectiveStory = request.storyKey ?? resume?.payload?.storyKey;
+        const effectiveTasks = request.taskKeys?.length ? request.taskKeys : resume?.payload?.tasks;
+        const effectiveStatus = request.statusFilter ?? resume?.payload?.statusFilter ?? ['ready_to_qa'];
+        const selection = await this.selectionService.selectTasks({
+            projectKey: effectiveProject,
+            epicKey: effectiveEpic,
+            storyKey: effectiveStory,
+            taskKeys: effectiveTasks,
+            statusFilter: effectiveStatus,
+        });
+        this.dryRunGuard = request.dryRun ?? false;
+        if (request.dryRun) {
+            const dryResults = [];
+            for (const task of selection.ordered) {
+                let profile;
+                try {
+                    profile = await this.profileService.resolveProfileForTask(task.task, {
+                        profileName: request.profileName,
+                        level: request.level,
+                    });
+                }
+                catch {
+                    profile = undefined;
+                }
+                dryResults.push({
+                    taskKey: task.task.key,
+                    outcome: profile ? 'unclear' : 'infra_issue',
+                    profile: profile?.name,
+                    runner: profile?.runner,
+                    notes: profile ? 'Dry-run: QA planned' : 'Dry-run: no profile available',
+                });
+            }
+            return {
+                jobId: 'dry-run',
+                commandRunId: 'dry-run',
+                selection,
+                results: dryResults,
+                warnings: selection.warnings,
+            };
+        }
+        await this.ensureMcoda();
+        const completedKeys = new Set();
+        const checkpoints = request.resumeJobId ? await this.deps.jobService.readCheckpoints(request.resumeJobId) : [];
+        const priorResults = new Map();
+        for (const ckpt of checkpoints) {
+            if (ckpt.stage?.startsWith('task:')) {
+                const parts = ckpt.stage.split(':');
+                if (parts[1])
+                    completedKeys.add(parts[1]);
+            }
+            if (Array.isArray(ckpt.details?.completedTaskKeys)) {
+                for (const key of ckpt.details.completedTaskKeys) {
+                    completedKeys.add(key);
+                }
+            }
+            if (ckpt.details?.taskResult && ckpt.details.taskResult.taskKey) {
+                priorResults.set(ckpt.details.taskResult.taskKey, ckpt.details.taskResult);
+            }
+        }
+        const commandRun = await this.deps.jobService.startCommandRun('qa-tasks', effectiveProject, {
+            taskIds: selection.ordered.map((t) => t.task.key),
+            jobId: resume?.id,
+        });
+        const agentStream = request.agentStream !== false;
+        const job = resume && resume.id
+            ? resume
+            : await this.deps.jobService.startJob('qa', commandRun.id, effectiveProject, {
+                commandName: 'qa-tasks',
+                payload: {
+                    projectKey: effectiveProject,
+                    epicKey: effectiveEpic,
+                    storyKey: effectiveStory,
+                    tasks: effectiveTasks,
+                    statusFilter: effectiveStatus,
+                    mode: request.mode ?? 'auto',
+                    profile: request.profileName,
+                    level: request.level,
+                    agent: request.agentName,
+                    agentStream,
+                    createFollowups: request.createFollowupTasks ?? 'auto',
+                    dryRun: request.dryRun ?? false,
+                },
+                totalItems: selection.ordered.length,
+                processedItems: completedKeys.size,
+            });
+        if (resume?.id) {
+            try {
+                const qaRuns = await this.deps.workspaceRepo.listTaskQaRunsForJob(selection.ordered.map((t) => t.task.id), resume.id);
+                for (const run of qaRuns) {
+                    const task = selection.ordered.find((t) => t.task.id === run.taskId);
+                    if (task && run.recommendation) {
+                        completedKeys.add(task.task.key);
+                    }
+                }
+            }
+            catch {
+                // ignore resume enrichment failures
+            }
+        }
+        const remaining = selection.ordered.filter((t) => !completedKeys.has(t.task.key));
+        // Skip tasks that are already in a terminal QA state for this job (ready_to_qa -> completed/in_progress/blocked)
+        const terminalStatuses = new Set(['completed', 'in_progress', 'blocked']);
+        const skippedTerminal = [];
+        for (const t of remaining) {
+            if (terminalStatuses.has(t.task.status?.toLowerCase?.() ?? '')) {
+                completedKeys.add(t.task.key);
+                skippedTerminal.push({
+                    taskKey: t.task.key,
+                    outcome: 'pass',
+                    notes: `skipped (terminal status ${t.task.status})`,
+                });
+            }
+        }
+        const filteredRemaining = remaining.filter((t) => !terminalStatuses.has(t.task.status?.toLowerCase?.() ?? ''));
+        await this.deps.jobService.updateJobStatus(job.id, 'running', {
+            totalItems: selection.ordered.length,
+            processedItems: completedKeys.size,
+        });
+        await this.checkpoint(job.id, 'selection', {
+            ordered: selection.ordered.map((t) => t.task.key),
+            blocked: selection.blocked.map((t) => t.task.key),
+            completedTaskKeys: Array.from(completedKeys),
+        });
+        const results = [];
+        for (const task of selection.ordered) {
+            if (completedKeys.has(task.task.key)) {
+                results.push(priorResults.get(task.task.key) ?? { taskKey: task.task.key, outcome: 'pass', notes: 'skipped (resume)' });
+            }
+        }
+        results.push(...skippedTerminal);
+        try {
+            let processedCount = completedKeys.size;
+            for (const [index, task] of filteredRemaining.entries()) {
+                const mode = request.mode ?? 'auto';
+                if (mode === 'manual') {
+                    results.push(await this.runManual(task, { jobId: job.id, commandRunId: commandRun.id, request }));
+                }
+                else {
+                    results.push(await this.runAuto(task, { jobId: job.id, commandRunId: commandRun.id, request }));
+                }
+                completedKeys.add(task.task.key);
+                processedCount = completedKeys.size;
+                await this.deps.jobService.updateJobStatus(job.id, 'running', { processedItems: processedCount });
+                await this.checkpoint(job.id, `task:${task.task.key}:completed`, {
+                    processed: processedCount,
+                    completedTaskKeys: Array.from(completedKeys),
+                    taskResult: results[results.length - 1],
+                });
+            }
+            const failureCount = results.filter((r) => r.outcome !== 'pass').length;
+            const state = failureCount === 0 ? 'completed' : failureCount === results.length ? 'failed' : 'partial';
+            const errorSummary = failureCount ? `${failureCount} task(s) not passed QA` : undefined;
+            await this.deps.jobService.updateJobStatus(job.id, state, { errorSummary });
+            await this.deps.jobService.finishCommandRun(commandRun.id, state === 'completed' ? 'succeeded' : 'failed', errorSummary);
+            await this.checkpoint(job.id, 'completed', {
+                state,
+                processed: results.length,
+                failures: failureCount,
+                taskResults: results,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await this.deps.jobService.updateJobStatus(job.id, 'failed', { errorSummary: message });
+            await this.deps.jobService.finishCommandRun(commandRun.id, 'failed', message);
+            throw error;
+        }
+        return {
+            jobId: job.id,
+            commandRunId: commandRun.id,
+            selection,
+            results,
+            warnings: selection.warnings,
+        };
+    }
+}