@straiffi/archon 1.7.1 → 1.7.3

package/dist/server/workers/review.js

@@ -1,5 +1,5 @@
 import db from '../db.js';
-import { formatAgentErrorForTranscript, getAgentErrorTranscriptRuns, runAgent, storeTicketUsageSnapshot, storeTicketUsageSnapshotDirect } from '../lib/agent.js';
+import { formatAgentErrorForTranscript, getAgentErrorTranscriptRuns, registerReviewProcess, runAgent, storeTicketUsageSnapshot, storeTicketUsageSnapshotDirect, untrackReviewProcess, } from '../lib/agent.js';
 import config from '../lib/config.js';
 import { persistProjectMemorySuggestions } from '../lib/projectMemory.js';
 import { getReviewDiffDataAsync, resolveWorktreePath } from '../lib/git.js';
@@ -7,6 +7,7 @@ import { getProjectMemoryPromptBlock } from '../lib/projectMemoryPrompt.js';
 import { extractProjectMemorySuggestionsFromOutput, getProjectMemorySuggestionPromptRules } from '../lib/projectMemorySuggestions.js';
 import { getEffectiveProject } from '../lib/projects.js';
 import { enqueue, isRunning } from '../lib/queue.js';
+import { getExecutionRun, transitionExecutionRun, withExecutionRunTransaction } from '../lib/executionRuns.js';
 import { buildReviewContext } from '../lib/reviewContext.js';
 import { computeDiffSignature, createReviewRun, hasPriorReviewRunForBundle, insertReviewFindings, parseStructuredReviewOutput, } from '../lib/reviewFindings.js';
 import { buildSpecCoverageContext } from '../lib/specCoverageContext.js';
@@ -18,16 +19,29 @@ import { clearTicketStreamingResponse, createTicketMessage, markTicketDescriptio
 import { captureStageBaseline, captureStageSuccess } from '../lib/ticketUndo.js';
 import { beginTicketThinkingRun, bindTicketThinkingMessage } from '../lib/thinkingState.js';
 import { autoParkTicketIfStale, getTicket, resolveTicketBranch, resolveTicketTool, resolveTicketWorkerKey } from '../lib/tickets.js';
-import { clearAgentRunsForParent, createAgentRun, emitAgentRunsUpdated, listAgentRunsForParent, } from '../lib/agentRuns.js';
+import { createAgentRun, emitAgentRunsUpdated, getAgentRun, terminalizeAgentRunsForExecutionRun, } from '../lib/agentRuns.js';
 import { buildAutomationFixInstruction, buildAutomationFixStatusMessage, decideReviewAutomation, depthAtLeast, getBundleAutomationState, recordAutomationPause, resetBundleAutomationLoop, resolveAutomationConfig, upsertBundleAutomationState, } from '../lib/ticketAutomation.js';
 import { runAutomationCommitChain } from '../lib/ticketAutomationCommit.js';
-import { startFollowUp } from './followUp.js';
+import { submitTicketFollowUp } from '../lib/ticketFollowUpOperations.js';
+import { completeAutomationProgression, createAutomationReviewFix, ensureAutomationProgression, finishAutomationReviewFix, resolveProgressionForChild, waitAutomationProgression, } from '../lib/automationProgression.js';
 import { formatBuildOpenQuestionAnswersPrompt, listAnsweredBuildOpenQuestionsForBundle } from '../lib/buildOpenQuestions.js';
 const getErrorMessage = (error) => {
     return error instanceof Error ? error.message : String(error);
 };
-const updateStatus = (ticketId, status, log, io) => {
-    db.prepare('UPDATE tickets SET agent_status = ?, agent_log = ?, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(status, log ?? null, ticketId);
+const defaultInitiation = {
+    initiator: 'user',
+    causalParentRunId: null,
+    retrySourceRunId: null,
+    workflowContext: null,
+};
+const asGenericEmitter = (io) => io;
+const updateStatus = (ticketId, status, log, io, operation) => {
+    if (operation) {
+        db.prepare('UPDATE tickets SET agent_status = ?, agent_operation = ?, agent_log = ?, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(status, operation, log ?? null, ticketId);
+    }
+    else {
+        db.prepare('UPDATE tickets SET agent_status = ?, agent_log = ?, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(status, log ?? null, ticketId);
+    }
     const updatedTicket = getTicket(ticketId);
     if (updatedTicket?.worktree_bundle_id && updatedTicket.state !== 'plan') {
         markTicketDescriptionVisibleInBundle(ticketId);
@@ -43,8 +57,48 @@ const stripSystemReminderBlocks = (output) => {
 const normalizeReviewOutput = (output) => {
     return extractProjectMemorySuggestionsFromOutput(stripSystemReminderBlocks(output));
 };
+const resolveStructuredReviewOutput = (parentResponse, transcriptRuns) => {
+    const normalizedParent = typeof parentResponse === 'string'
+        ? normalizeReviewOutput(parentResponse)
+        : { cleanedOutput: '', suggestions: [] };
+    const parsedParent = normalizedParent.cleanedOutput
+        ? parseStructuredReviewOutput(normalizedParent.cleanedOutput)
+        : null;
+    if (parsedParent?.status === 'completed') {
+        return { normalizedParent, parsed: parsedParent };
+    }
+    const parsedSubagentOutputs = transcriptRuns.flatMap(run => {
+        if (run.role !== 'subagent' || run.agent_status !== 'done' || !run.response_text?.trim()) {
+            return [];
+        }
+        const normalized = normalizeReviewOutput(run.response_text);
+        if (!normalized.cleanedOutput) {
+            return [];
+        }
+        const parsed = parseStructuredReviewOutput(normalized.cleanedOutput);
+        return parsed.status === 'completed' ? [parsed] : [];
+    });
+    if (parsedSubagentOutputs.length === 0) {
+        return { normalizedParent, parsed: parsedParent };
+    }
+    const findings = parsedSubagentOutputs
+        .flatMap(output => output.findings)
+        .map((finding, index) => ({ ...finding, ordinal: index + 1 }));
+    return {
+        normalizedParent,
+        parsed: {
+            cleanedMarkdown: parsedSubagentOutputs
+                .map(output => output.cleanedMarkdown)
+                .filter(Boolean)
+                .join('\n\n'),
+            findings,
+            status: 'completed',
+        },
+    };
+};
 const MAX_INLINE_DIFF_LINES = 400;
 const MAX_INLINE_DIFF_CHARS = 20_000;
+const SUBAGENT_REVIEW_GUIDANCE = 'If you delegate any part of the review to subagents, you remain responsible for evaluating their results and consolidating every accepted finding into your final response using the exact format below.';
 const countLines = (value) => {
     if (!value) {
         return 0;
@@ -98,6 +152,8 @@ Before writing findings, perform this investigation workflow:
 4. Check whether the change is consistent with the project's accepted decisions and conventions.
 5. Only then report genuine issues that are supported by the code you inspected.
 
+${SUBAGENT_REVIEW_GUIDANCE}
+
 Do not report that you performed these steps. Do not include summaries, praise, or implementation advice beyond the requested findings format.
 
 ${projectMemory ? `${projectMemory}
@@ -157,6 +213,8 @@ Before writing findings, perform this investigation workflow:
 3. Compare the implementation against the spec_context block: are all acceptance criteria satisfied, are listed edge cases handled, and does the change stay within scope?
 4. Only then report genuine conformance gaps that are supported by the code you inspected.
 
+${SUBAGENT_REVIEW_GUIDANCE}
+
 Do not report that you performed these steps. Do not include summaries, praise, or implementation advice beyond the requested findings format.
 
 ${projectMemory ? `${projectMemory}
@@ -197,22 +255,51 @@ Use an empty findings array when there are no genuine issues. The JSON must be v
 
 Do not include planning text, implementation steps, or commentary about changing modes.`, ticket.skills);
 };
-const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parsedStatus, findings, io) => {
+const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parsedStatus, findings, io, executionContext, initiation) => {
     if (!ticket.worktree_bundle_id || !ticket.project_id) {
         return false;
     }
     const projectId = ticket.project_id;
     const bundleId = ticket.worktree_bundle_id;
-    const config = resolveAutomationConfig(ticket.bundle ?? null, project);
+    const liveTicket = getTicket(ticket.id) ?? ticket;
+    const liveProject = getEffectiveProject(liveTicket) ?? project;
+    const config = resolveAutomationConfig(liveTicket.bundle ?? null, liveProject);
     const bundleState = getBundleAutomationState(projectId, bundleId);
     const decision = decideReviewAutomation(config, bundleState, reviewRunId, parsedStatus, findings);
+    const progression = initiation.initiator === 'automation'
+        ? resolveProgressionForChild({ projectId, bundleId, childRunId: executionContext.runId })
+        : null;
     switch (decision.kind) {
         case 'manual':
+            if (progression) {
+                completeAutomationProgression({
+                    projectId,
+                    bundleId,
+                    progressionRunId: progression.id,
+                    domainStatus: 'manual_boundary_reached',
+                    broadcaster: asGenericEmitter(io),
+                });
+                return true;
+            }
             return false;
         case 'paused':
             return true;
         case 'parse_failed': {
-            recordAutomationPause(projectId, bundleId, 'review', 'review parse failed');
+            if (progression) {
+                waitAutomationProgression({
+                    projectId,
+                    bundleId,
+                    progressionRunId: progression.id,
+                    pauseCode: 'review',
+                    pauseReason: 'review parse failed',
+                    reasonCode: 'stage_failed',
+                    pausedStageRunId: executionContext.runId,
+                    broadcaster: asGenericEmitter(io),
+                });
+            }
+            else {
+                recordAutomationPause(projectId, bundleId, 'review', 'review parse failed');
+            }
             const pausedTicket = getTicket(ticket.id);
             if (pausedTicket) {
                 io.emit('ticket:updated', pausedTicket);
@@ -220,14 +307,72 @@ const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parse
             return true;
         }
         case 'fix_iteration': {
+            const previousIteration = bundleState?.review_iteration_count ?? 0;
+            const previousFixLoopActive = bundleState?.fix_loop_active ?? 0;
             upsertBundleAutomationState(projectId, bundleId, {
                 review_iteration_count: decision.iteration,
                 fix_loop_active: 1,
             });
             const instruction = buildAutomationFixInstruction(config.reviewSeverity);
-            const started = startFollowUp(ticket, io, instruction, 'build');
-            if (!started) {
-                recordAutomationPause(projectId, bundleId, 'review', 'fix follow-up could not start (ticket already running)');
+            let reviewFix = null;
+            try {
+                reviewFix = progression
+                    ? createAutomationReviewFix({
+                        projectId,
+                        bundleId,
+                        ticketId: ticket.id,
+                        ticketTitle: ticket.title,
+                        progressionRunId: progression.id,
+                        workflowContext: initiation.workflowContext,
+                        triggeringReviewRunId: executionContext.runId,
+                        broadcaster: asGenericEmitter(io),
+                    })
+                    : null;
+            }
+            catch (error) {
+                upsertBundleAutomationState(projectId, bundleId, {
+                    review_iteration_count: previousIteration,
+                    fix_loop_active: previousFixLoopActive,
+                });
+                throw error;
+            }
+            const started = submitTicketFollowUp({
+                ticketId: ticket.id,
+                requestedProjectId: projectId,
+                payload: { instruction, mode: 'build' },
+                broadcaster: asGenericEmitter(io),
+                initiation: {
+                    initiator: 'automation',
+                    causalParentRunId: reviewFix?.runId ?? executionContext.runId,
+                    workflowContext: initiation.workflowContext,
+                },
+            });
+            if (!started.ok) {
+                upsertBundleAutomationState(projectId, bundleId, {
+                    review_iteration_count: previousIteration,
+                    fix_loop_active: previousFixLoopActive,
+                });
+                if (reviewFix && progression) {
+                    finishAutomationReviewFix({
+                        projectId,
+                        reviewFixRunId: reviewFix.runId,
+                        failedMessage: started.error,
+                        broadcaster: asGenericEmitter(io),
+                    });
+                    waitAutomationProgression({
+                        projectId,
+                        bundleId,
+                        progressionRunId: progression.id,
+                        pauseCode: 'review',
+                        pauseReason: `fix follow-up could not start: ${started.error}`,
+                        reasonCode: 'stage_failed',
+                        pausedStageRunId: reviewFix.runId,
+                        broadcaster: asGenericEmitter(io),
+                    });
+                }
+                else {
+                    recordAutomationPause(projectId, bundleId, 'review', `fix follow-up could not start: ${started.error}`);
+                }
                 const pausedTicket = getTicket(ticket.id);
                 if (pausedTicket) {
                     io.emit('ticket:updated', pausedTicket);
@@ -243,7 +388,21 @@ const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parse
             return true;
         }
         case 'pause_blocking': {
-            recordAutomationPause(projectId, bundleId, 'review', decision.reason);
+            if (progression) {
+                waitAutomationProgression({
+                    projectId,
+                    bundleId,
+                    progressionRunId: progression.id,
+                    pauseCode: 'review',
+                    pauseReason: decision.reason,
+                    reasonCode: 'precondition_failed',
+                    pausedStageRunId: executionContext.runId,
+                    broadcaster: asGenericEmitter(io),
+                });
+            }
+            else {
+                recordAutomationPause(projectId, bundleId, 'review', decision.reason);
+            }
             const pausedTicket = getTicket(ticket.id);
             if (pausedTicket) {
                 io.emit('ticket:updated', pausedTicket);
@@ -253,288 +412,686 @@ const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parse
         case 'clean': {
             resetBundleAutomationLoop(projectId, bundleId);
             if (depthAtLeast(config.depth, 'auto_commit')) {
-                await runAutomationCommitChain(ticket, project, ticket.bundle ?? null, config, io);
+                const commitProgressionRunId = progression?.id ?? ensureAutomationProgression({
+                    projectId,
+                    bundleId,
+                    ticketId: ticket.id,
+                    ticketTitle: ticket.title,
+                    parentRunId: executionContext.runId,
+                    workflowContext: initiation.workflowContext,
+                    broadcaster: asGenericEmitter(io),
+                }).runId;
+                await runAutomationCommitChain(ticket, project, ticket.bundle ?? null, config, io, commitProgressionRunId, undefined, executionContext.runId);
                 return true;
             }
+            if (progression) {
+                completeAutomationProgression({
+                    projectId,
+                    bundleId,
+                    progressionRunId: progression.id,
+                    broadcaster: asGenericEmitter(io),
+                });
+            }
             return false;
         }
     }
 };
-export const startReview = (ticket, io) => {
+export function startReview(ticket, io, options) {
+    const legacyResult = options === undefined;
+    const reject = (reason, error) => (legacyResult ? false : { accepted: false, reason, error });
     if (ticket.project_id
         && ticket.worktree_bundle_id
         && hasActiveBuildOpenQuestionBatch(ticket.project_id, ticket.worktree_bundle_id)) {
-        return false;
+        return reject('busy', 'Build open question resolution is still in progress');
     }
     const jobKey = resolveTicketWorkerKey(ticket, 'review');
     if (!jobKey || isRunning(jobKey)) {
-        return false;
+        return reject('busy', 'Ticket review is already scheduled or running');
     }
     const branch = resolveTicketBranch(ticket);
     if (!branch) {
-        return false;
+        return reject('project_unavailable', 'Worktree not ready yet');
     }
-    enqueue(jobKey, async () => {
-        registerBundleActivity(ticket, 'review');
-        const project = getEffectiveProject(ticket);
-        if (!project) {
-            updateStatus(ticket.id, 'error', 'Ticket project no longer exists', io);
-            unregisterBundleActivity(ticket, 'review');
-            return;
-        }
-        const cwd = ticket.bundle?.kind === 'project_root' ? project.repo_path : resolveWorktreePath(branch, project);
-        const tool = resolveTicketTool(ticket, config.tool ?? 'opencode');
-        beginTicketThinkingRun(ticket.id);
-        updateStatus(ticket.id, 'running', 'Preparing review baseline...', io);
-        try {
-            await captureStageBaseline(ticket.id, 'review');
-            updateStatus(ticket.id, 'running', 'Computing review diff...', io);
-            const diffText = (await getReviewDiffDataAsync({ cwd, branch, project })).diff;
-            const reviewContext = buildReviewContext({ cwd, branch, project });
-            const diffSignature = computeDiffSignature(diffText);
-            const supplementalRequirements = ticket.project_id && ticket.worktree_bundle_id
-                ? formatBuildOpenQuestionAnswersPrompt(listAnsweredBuildOpenQuestionsForBundle(ticket.project_id, ticket.worktree_bundle_id))
-                : '';
-            const runSpecCoverage = Boolean(project.spec_aware_code_review_enabled)
-                && Boolean(ticket.origin_spec_snapshot_id)
-                && ticket.project_id != null
-                && ticket.worktree_bundle_id != null
-                && !hasPriorReviewRunForBundle(ticket.project_id, ticket.worktree_bundle_id);
-            let specContext = null;
-            if (runSpecCoverage && ticket.project_id && ticket.worktree_bundle_id) {
-                const bundleTickets = listTickets(ticket.project_id)
-                    .filter(bundleTicket => bundleTicket.worktree_bundle_id === ticket.worktree_bundle_id);
-                specContext = buildSpecCoverageContext({ ticket, bundleTickets });
+    const project = getEffectiveProject(ticket);
+    if (!project || !ticket.project_id || project.id !== ticket.project_id) {
+        return reject('project_unavailable', 'Ticket project is unavailable');
+    }
+    const initiation = { ...defaultInitiation, ...options?.initiation };
+    let acceptedTicket = ticket;
+    let compensateAcceptance;
+    let executionContext;
+    try {
+        executionContext = withExecutionRunTransaction(transaction => {
+            const acceptance = options?.accept?.();
+            if (acceptance) {
+                acceptedTicket = acceptance.ticket;
+                compensateAcceptance = acceptance.compensate;
             }
-            const blindRunStreamTarget = (() => {
-                try {
-                    const runId = createAgentRun({
-                        parentType: 'ticket',
-                        parentId: ticket.id,
-                        runIndex: 0,
-                        label: 'Code Review',
-                        role: 'code-review',
+            if (initiation.initiator === 'automation' && initiation.causalParentRunId) {
+                const activeChild = db.prepare(`
+          SELECT id FROM execution_runs
+          WHERE project_id = ? AND parent_run_id = ?
+            AND kind IN ('review', 'automation_review_fix', 'automation_commit', 'automation_push', 'automation_pull_request')
+            AND status IN ('queued', 'running', 'waiting')
+          LIMIT 1
+        `).get(project.id, initiation.causalParentRunId);
+                if (activeChild) {
+                    throw new Error('Automation progression already has an active child');
+                }
+                const progressionTicketLink = db.prepare(`
+          SELECT 1 FROM execution_run_links
+          WHERE execution_run_id = ? AND project_id = ? AND entity_type = 'ticket' AND entity_id = ?
+        `).get(initiation.causalParentRunId, project.id, acceptedTicket.id);
+                if (!progressionTicketLink) {
+                    transaction.addExecutionRunLink({
+                        projectId: project.id,
+                        runId: initiation.causalParentRunId,
+                        link: {
+                            entityType: 'ticket',
+                            entityId: acceptedTicket.id,
+                            relationship: 'context',
+                            label: acceptedTicket.title,
+                        },
                     });
-                    return { runId, label: 'Code Review', role: 'code-review', runIndex: 0 };
                 }
-                catch (err) {
-                    console.warn('[review] createAgentRun failed for blind run; falling back to legacy streaming', getErrorMessage(err));
-                    return null;
+            }
+            const executionRun = transaction.createExecutionRun({
+                projectId: project.id,
+                kind: 'review',
+                domainStatus: 'queued',
+                sourceReference: { kind: 'ticket', id: acceptedTicket.id, label: acceptedTicket.title },
+                links: [
+                    ...(acceptedTicket.worktree_bundle_id
+                        ? [{ entityType: 'bundle', entityId: acceptedTicket.worktree_bundle_id, relationship: 'context' }]
+                        : []),
+                    ...(acceptedTicket.origin_spec_snapshot_id
+                        ? [{ entityType: 'spec_snapshot', entityId: acceptedTicket.origin_spec_snapshot_id, relationship: 'context' }]
+                        : []),
+                ],
+                initiatedBy: initiation.initiator,
+                parentRunId: initiation.causalParentRunId,
+                retryOfRunId: initiation.retrySourceRunId,
+                metadata: initiation.workflowContext,
+                eventType: 'review_created',
+            });
+            return {
+                runId: executionRun.id,
+                correlationId: executionRun.correlation_id,
+                projectId: executionRun.project_id,
+                kind: executionRun.kind,
+            };
+        }, asGenericEmitter(io));
+    }
+    catch (error) {
+        return reject('invalid_context', getErrorMessage(error));
+    }
+    let queuedJob;
+    try {
+        queuedJob = enqueue(jobKey, async () => {
+            const scheduledRun = getExecutionRun(executionContext.projectId, executionContext.runId);
+            if (!scheduledRun || !['queued', 'running', 'waiting'].includes(scheduledRun.status)) {
+                return;
+            }
+            let activityRegistered = false;
+            let registeredReviewProcess = null;
+            let finalizeStoppedReviewAfterFailure = null;
+            try {
+                registerBundleActivity(acceptedTicket, 'review');
+                activityRegistered = true;
+                const currentTicket = getTicket(acceptedTicket.id);
+                if (!currentTicket || currentTicket.project_id !== executionContext.projectId) {
+                    throw new Error('Ticket no longer exists in the execution project');
                 }
-            })();
-            let specCoverageRunStreamTarget = null;
-            if (specContext) {
-                try {
+                const project = getEffectiveProject(currentTicket);
+                if (!project) {
+                    throw new Error('Ticket project no longer exists');
+                }
+                const cwd = ticket.bundle?.kind === 'project_root' ? project.repo_path : resolveWorktreePath(branch, project);
+                const tool = resolveTicketTool(ticket, config.tool ?? 'opencode');
+                const reviewProcessState = registerReviewProcess(acceptedTicket.id);
+                registeredReviewProcess = reviewProcessState;
+                const createdAgentRunIds = [];
+                const storeCreatedAgentRunUsage = () => {
+                    if (tool !== 'opencode') {
+                        return;
+                    }
+                    for (const runId of createdAgentRunIds) {
+                        const agentRun = getAgentRun(runId);
+                        if (agentRun?.session_id) {
+                            storeTicketUsageSnapshot(ticket.id, agentRun.session_id);
+                        }
+                    }
+                };
+                const finalizeStoppedReview = ({ finalResponse = null, responseTiming = null, specCoverageResponse = null, transcriptRuns = [], usageSnapshot, } = {}) => {
+                    storeCreatedAgentRunUsage();
+                    if (tool === 'claude' && usageSnapshot) {
+                        storeTicketUsageSnapshotDirect(ticket.id, usageSnapshot);
+                    }
+                    let messageId = null;
+                    const fallbackContent = transcriptRuns.length > 0
+                        ? finalResponse?.trim()
+                            || specCoverageResponse?.trim()
+                            || transcriptRuns.find(run => run.response_text?.trim())?.response_text?.trim()
+                            || transcriptRuns.find(run => run.thinking_log?.trim())?.thinking_log?.trim()
+                            || ''
+                        : '';
+                    clearTicketStreamingResponse(ticket.id);
+                    withExecutionRunTransaction(transaction => {
+                        if (fallbackContent) {
+                            messageId = createTicketMessage({
+                                ticketId: ticket.id,
+                                role: 'assistant',
+                                kind: 'final_response',
+                                content: fallbackContent,
+                                responseTiming,
+                                transcriptRuns,
+                            });
+                            transaction.addExecutionRunLink({
+                                projectId: executionContext.projectId,
+                                runId: executionContext.runId,
+                                link: {
+                                    entityType: 'ticket_message',
+                                    entityId: messageId,
+                                    relationship: 'result',
+                                    expectedParent: { entityType: 'ticket', entityId: ticket.id },
+                                },
+                            });
+                        }
+                        if (messageId) {
+                            bindTicketThinkingMessage(ticket.id, messageId);
+                        }
+                        db.prepare('UPDATE tickets SET agent_status = ?, agent_log = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND project_id = ?')
+                            .run('stopped', ticket.id, executionContext.projectId);
+                        terminalizeAgentRunsForExecutionRun(executionContext.runId, 'stopped', null);
+                        transaction.transitionExecutionRun({
+                            projectId: executionContext.projectId,
+                            runId: executionContext.runId,
+                            status: 'cancelled',
+                            domainStatus: 'stopped',
+                            eventType: 'review_cancelled',
+                        });
+                    }, asGenericEmitter(io));
+                    if (initiation.initiator === 'automation' && acceptedTicket.project_id && acceptedTicket.worktree_bundle_id) {
+                        try {
+                            const progression = resolveProgressionForChild({
+                                projectId: acceptedTicket.project_id,
+                                bundleId: acceptedTicket.worktree_bundle_id,
+                                childRunId: executionContext.runId,
+                            });
+                            waitAutomationProgression({
+                                projectId: acceptedTicket.project_id,
+                                bundleId: acceptedTicket.worktree_bundle_id,
+                                progressionRunId: progression.id,
+                                pauseCode: 'review',
+                                pauseReason: 'Automated review was stopped',
+                                reasonCode: 'stage_failed',
+                                pausedStageRunId: executionContext.runId,
+                                broadcaster: asGenericEmitter(io),
+                            });
+                        }
+                        catch {
+                            // A concurrent progression stop remains authoritative.
+                        }
+                    }
+                    updateStatus(ticket.id, 'stopped', null, io);
+                    emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', ticket.id);
+                };
+                finalizeStoppedReviewAfterFailure = finalizeStoppedReview;
+                const stopReviewBeforeAgentIfRequested = () => {
+                    if (!reviewProcessState.stopRequested) {
+                        return false;
+                    }
+                    finalizeStoppedReview();
+                    return true;
+                };
+                beginTicketThinkingRun(ticket.id);
+                withExecutionRunTransaction(transaction => {
+                    db.prepare('UPDATE tickets SET agent_status = ?, agent_operation = ?, agent_log = ?, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND project_id = ?').run('running', 'review', 'Preparing review baseline...', ticket.id, executionContext.projectId);
+                    transaction.transitionExecutionRun({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        status: 'running',
+                        domainStatus: 'running',
+                        eventType: 'review_started',
+                    });
+                }, asGenericEmitter(io));
+                updateStatus(ticket.id, 'running', 'Preparing review baseline...', io, 'review');
+                await captureStageBaseline(ticket.id, 'review');
+                if (stopReviewBeforeAgentIfRequested()) {
+                    return;
+                }
+                updateStatus(ticket.id, 'running', 'Computing review diff...', io);
+                const diffText = (await getReviewDiffDataAsync({ cwd, branch, project })).diff;
+                if (stopReviewBeforeAgentIfRequested()) {
+                    return;
+                }
+                const reviewContext = buildReviewContext({ cwd, branch, project });
+                const diffSignature = computeDiffSignature(diffText);
+                const supplementalRequirements = ticket.project_id && ticket.worktree_bundle_id
+                    ? formatBuildOpenQuestionAnswersPrompt(listAnsweredBuildOpenQuestionsForBundle(ticket.project_id, ticket.worktree_bundle_id))
+                    : '';
+                const runSpecCoverage = Boolean(project.spec_aware_code_review_enabled)
+                    && Boolean(ticket.origin_spec_snapshot_id)
+                    && ticket.project_id != null
+                    && ticket.worktree_bundle_id != null
+                    && !hasPriorReviewRunForBundle(ticket.project_id, ticket.worktree_bundle_id);
+                let specContext = null;
+                if (runSpecCoverage && ticket.project_id && ticket.worktree_bundle_id) {
+                    const bundleTickets = listTickets(ticket.project_id)
+                        .filter(bundleTicket => bundleTicket.worktree_bundle_id === ticket.worktree_bundle_id);
+                    specContext = buildSpecCoverageContext({ ticket, bundleTickets });
+                }
+                const blindRunId = createAgentRun({
+                    executionRunId: executionContext.runId,
+                    parentType: 'ticket',
+                    parentId: ticket.id,
+                    runIndex: 0,
+                    label: 'Code Review',
+                    role: 'code-review',
+                });
+                createdAgentRunIds.push(blindRunId);
+                const blindRunStreamTarget = { runId: blindRunId, label: 'Code Review', role: 'code-review', runIndex: 0 };
+                let specCoverageRunStreamTarget = null;
+                if (specContext) {
                     const runId = createAgentRun({
+                        executionRunId: executionContext.runId,
                         parentType: 'ticket',
                         parentId: ticket.id,
                         runIndex: 1,
                         label: 'Spec-Coverage Review',
                         role: 'spec-coverage',
                     });
+                    createdAgentRunIds.push(runId);
                     specCoverageRunStreamTarget = { runId, label: 'Spec-Coverage Review', role: 'spec-coverage', runIndex: 1 };
                 }
-                catch (err) {
-                    console.warn('[review] createAgentRun failed for spec-coverage run; falling back to legacy streaming', getErrorMessage(err));
-                }
-            }
-            const createdAgentRuns = Boolean(blindRunStreamTarget) || Boolean(specCoverageRunStreamTarget);
-            if (createdAgentRuns) {
                 emitAgentRunsUpdated(io, 'ticket', ticket.id);
-            }
-            const blindPrompt = reviewPrompt({
-                ticket,
-                diff: diffText,
-                memoryEnabled: Boolean(project.memory_enabled),
-                reviewContext,
-                agentRunId: blindRunStreamTarget?.runId ?? null,
-                supplementalRequirements,
-            });
-            const blindRun = async () => {
-                return runAgent({
-                    ticketId: ticket.id,
-                    tool,
-                    prompt: blindPrompt,
-                    cwd,
-                    model: ticket.model,
-                    variant: ticket.variant,
-                    emitSuccessUpdate: false,
-                    io,
-                    runStream: blindRunStreamTarget ?? undefined,
+                const blindPrompt = reviewPrompt({
+                    ticket,
+                    diff: diffText,
+                    memoryEnabled: Boolean(project.memory_enabled),
+                    reviewContext,
+                    agentRunId: blindRunStreamTarget.runId,
+                    supplementalRequirements,
                 });
-            };
-            const specCoverageRun = async () => {
-                if (!specContext) {
-                    return null;
-                }
-                try {
-                    return await runAgent({
+                const blindRun = async () => {
+                    return runAgent({
                         ticketId: ticket.id,
                         tool,
-                        prompt: specCoverageReviewPrompt({
-                            ticket,
-                            diff: diffText,
-                            reviewContext,
-                            specContext,
-                            agentRunId: specCoverageRunStreamTarget?.runId ?? null,
-                            supplementalRequirements,
-                        }),
+                        prompt: blindPrompt,
                         cwd,
                         model: ticket.model,
                         variant: ticket.variant,
                         emitSuccessUpdate: false,
+                        executionContext,
                         io,
-                        runStream: specCoverageRunStreamTarget ?? undefined,
+                        runStream: blindRunStreamTarget,
+                        reviewProcessState,
                     });
+                };
+                const specCoverageRun = async () => {
+                    if (!specContext) {
+                        return null;
+                    }
+                    try {
+                        return await runAgent({
+                            ticketId: ticket.id,
+                            tool,
+                            prompt: specCoverageReviewPrompt({
+                                ticket,
+                                diff: diffText,
+                                reviewContext,
+                                specContext,
+                                agentRunId: specCoverageRunStreamTarget?.runId ?? null,
+                                supplementalRequirements,
+                            }),
+                            cwd,
+                            model: ticket.model,
+                            variant: ticket.variant,
+                            emitSuccessUpdate: false,
+                            executionContext,
+                            io,
+                            runStream: specCoverageRunStreamTarget ?? undefined,
+                            reviewProcessState,
+                        });
+                    }
+                    catch (err) {
+                        console.warn('[review] spec-coverage pass failed; falling back to blind-only', getErrorMessage(err));
+                        const transcriptRuns = getAgentErrorTranscriptRuns(err);
+                        return transcriptRuns
+                            ? { response: null, responseTiming: null, transcriptRuns }
+                            : null;
+                    }
+                };
+                let blindResult;
+                let specCoverageResult = null;
+                if (specContext) {
+                    const [blindSettled, specCoverageSettled] = await Promise.allSettled([blindRun(), specCoverageRun()]);
+                    if (blindSettled.status === 'rejected') {
+                        throw blindSettled.reason;
+                    }
+                    blindResult = blindSettled.value;
+                    specCoverageResult = specCoverageSettled.status === 'fulfilled' ? specCoverageSettled.value : null;
                 }
-                catch (err) {
-                    console.warn('[review] spec-coverage pass failed; falling back to blind-only', getErrorMessage(err));
-                    const transcriptRuns = getAgentErrorTranscriptRuns(err);
-                    return transcriptRuns
-                        ? { response: null, responseTiming: null, transcriptRuns }
-                        : null;
+                else {
+                    blindResult = await blindRun();
                 }
-            };
-            let blindResult;
-            let specCoverageResult = null;
-            if (specContext) {
-                const [blindSettled, specCoverageSettled] = await Promise.allSettled([blindRun(), specCoverageRun()]);
-                if (blindSettled.status === 'rejected') {
-                    throw blindSettled.reason;
+                const { response: finalResponse, responseTiming, usageSnapshot } = blindResult;
+                const transcriptRuns = [
+                    ...(blindResult.transcriptRuns ?? []),
+                    ...(specCoverageResult?.transcriptRuns ?? []),
+                ];
+                if (reviewProcessState.stopRequested) {
+                    finalizeStoppedReview({
+                        finalResponse,
+                        responseTiming,
+                        specCoverageResponse: specCoverageResult?.response ?? null,
+                        transcriptRuns,
+                        usageSnapshot,
+                    });
+                    return;
                 }
-                blindResult = blindSettled.value;
-                specCoverageResult = specCoverageSettled.status === 'fulfilled' ? specCoverageSettled.value : null;
-            }
-            else {
-                blindResult = await blindRun();
-            }
-            const { response: finalResponse, responseTiming, usageSnapshot } = blindResult;
-            const transcriptRuns = [
-                ...(blindResult.transcriptRuns ?? []),
-                ...(specCoverageResult?.transcriptRuns ?? []),
-            ];
-            const normalizedResponse = typeof finalResponse === 'string'
-                ? normalizeReviewOutput(finalResponse)
-                : { cleanedOutput: '', suggestions: [] };
-            let reviewRunId = null;
-            let parsedFindings = [];
-            let parsedStatus = null;
-            let persistedMessageId = null;
-            if (normalizedResponse.cleanedOutput) {
-                const blindParsed = parseStructuredReviewOutput(normalizedResponse.cleanedOutput);
-                const specCoverageSpecOutput = typeof specCoverageResult?.response === 'string'
-                    ? stripSystemReminderBlocks(specCoverageResult.response)
+                const { normalizedParent: normalizedResponse, parsed: blindParsed, } = resolveStructuredReviewOutput(finalResponse, blindResult.transcriptRuns ?? []);
+                let reviewRunId = null;
+                let parsedFindings = [];
+                let parsedStatus = null;
+                let persistedMessageId = null;
+                let reviewContent = null;
+                let findingsToPersist = [];
+                if (blindParsed?.cleanedMarkdown) {
+                    const specCoverageSpecOutput = typeof specCoverageResult?.response === 'string'
+                        ? stripSystemReminderBlocks(specCoverageResult.response)
+                        : '';
+                    const specParsed = specCoverageSpecOutput
+                        ? parseStructuredReviewOutput(specCoverageSpecOutput)
+                        : null;
+                    const mergedFindings = specParsed && specParsed.status === 'completed'
+                        ? [...blindParsed.findings, ...specParsed.findings.map(finding => ({
+                                ...finding,
+                                ordinal: finding.ordinal + blindParsed.findings.length,
+                            }))]
+                        : blindParsed.findings;
+                    const combinedMarkdown = specParsed && specParsed.cleanedMarkdown
+                        ? `${blindParsed.cleanedMarkdown}\n\n## Spec-Coverage Review\n${specParsed.cleanedMarkdown}`
+                        : blindParsed.cleanedMarkdown;
+                    parsedFindings = mergedFindings;
+                    parsedStatus = blindParsed.status;
+                    reviewContent = combinedMarkdown;
+                    findingsToPersist = mergedFindings;
+                }
+                const fallbackContent = !reviewContent && transcriptRuns.length > 0
+                    ? finalResponse?.trim()
+                        || specCoverageResult?.response?.trim()
+                        || transcriptRuns.find(run => run.response_text?.trim())?.response_text?.trim()
+                        || transcriptRuns.find(run => run.thinking_log?.trim())?.thinking_log?.trim()
+                        || ''
                     : '';
-                const specParsed = specCoverageSpecOutput
-                    ? parseStructuredReviewOutput(specCoverageSpecOutput)
-                    : null;
-                const mergedFindings = specParsed && specParsed.status === 'completed'
-                    ? [...blindParsed.findings, ...specParsed.findings.map(finding => ({
-                            ...finding,
-                            ordinal: finding.ordinal + blindParsed.findings.length,
-                        }))]
-                    : blindParsed.findings;
-                const combinedMarkdown = specParsed && specParsed.cleanedMarkdown
-                    ? `${blindParsed.cleanedMarkdown}\n\n## Spec-Coverage Review\n${specParsed.cleanedMarkdown}`
-                    : blindParsed.cleanedMarkdown;
-                parsedFindings = mergedFindings;
-                parsedStatus = blindParsed.status;
-                persistedMessageId = createTicketMessage({
-                    ticketId: ticket.id,
-                    role: 'assistant',
-                    kind: 'final_response',
-                    content: combinedMarkdown,
-                    responseTiming,
-                    transcriptRuns: transcriptRuns.length > 0 ? transcriptRuns : null,
-                });
+                const parseFailed = parsedStatus !== 'completed';
+                const persisted = withExecutionRunTransaction(transaction => {
+                    clearTicketStreamingResponse(ticket.id);
+                    const content = reviewContent ?? fallbackContent;
+                    const messageId = content
+                        ? createTicketMessage({
+                            ticketId: ticket.id,
+                            role: 'assistant',
+                            kind: 'final_response',
+                            content,
+                            responseTiming,
+                            transcriptRuns: transcriptRuns.length > 0 ? transcriptRuns : null,
+                        })
+                        : null;
+                    let createdReviewRunId = null;
+                    if (messageId && reviewContent && parsedStatus) {
+                        createdReviewRunId = createReviewRun({
+                            ticketId: ticket.id,
+                            projectId: ticket.project_id,
+                            worktreeBundleId: ticket.worktree_bundle_id,
+                            diffSignature,
+                            workspaceSignature: reviewContext.workspaceSignature,
+                            messageId,
+                            status: parsedStatus,
+                        });
+                        if (findingsToPersist.length > 0) {
+                            insertReviewFindings(createdReviewRunId, findingsToPersist);
+                        }
+                    }
+                    if (messageId) {
+                        transaction.addExecutionRunLink({
+                            projectId: executionContext.projectId,
+                            runId: executionContext.runId,
+                            link: {
+                                entityType: 'ticket_message',
+                                entityId: messageId,
+                                relationship: 'result',
+                                expectedParent: { entityType: 'ticket', entityId: ticket.id },
+                            },
+                        });
+                    }
+                    if (createdReviewRunId) {
+                        transaction.addExecutionRunLink({
+                            projectId: executionContext.projectId,
+                            runId: executionContext.runId,
+                            link: {
+                                entityType: 'review_run',
+                                entityId: createdReviewRunId,
+                                relationship: 'result',
+                                expectedParent: { entityType: 'ticket', entityId: ticket.id },
+                            },
+                        });
+                    }
+                    db.prepare('UPDATE tickets SET agent_status = ?, agent_log = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND project_id = ?')
+                        .run('done', ticket.id, executionContext.projectId);
+                    terminalizeAgentRunsForExecutionRun(executionContext.runId, parseFailed ? 'error' : 'done', parseFailed ? 'Review output could not be parsed' : null);
+                    transaction.transitionExecutionRun({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        status: parseFailed ? 'failed' : 'completed',
+                        domainStatus: parsedStatus ?? 'parse_failed',
+                        ...(parseFailed ? { failure: { code: 'parse_failed', message: 'Review output could not be parsed' } } : {}),
+                        eventType: parseFailed ? 'review_parse_failed' : 'review_completed',
+                    });
+                    return { messageId, reviewRunId: createdReviewRunId };
+                }, asGenericEmitter(io));
+                persistedMessageId = persisted.messageId;
+                reviewRunId = persisted.reviewRunId;
                 if (persistedMessageId) {
                     bindTicketThinkingMessage(ticket.id, persistedMessageId);
                 }
-                reviewRunId = createReviewRun({
-                    ticketId: ticket.id,
-                    projectId: ticket.project_id,
-                    worktreeBundleId: ticket.worktree_bundle_id,
-                    diffSignature,
-                    workspaceSignature: reviewContext.workspaceSignature,
-                    messageId: persistedMessageId,
-                    status: parsedStatus,
-                });
-                if (mergedFindings.length > 0) {
-                    insertReviewFindings(reviewRunId, mergedFindings);
-                }
-            }
-            if (!persistedMessageId && transcriptRuns.length > 0) {
-                const fallbackContent = finalResponse?.trim()
-                    || specCoverageResult?.response?.trim()
-                    || transcriptRuns.find(run => run.response_text?.trim())?.response_text?.trim()
-                    || transcriptRuns.find(run => run.thinking_log?.trim())?.thinking_log?.trim()
-                    || '';
-                if (fallbackContent) {
-                    persistedMessageId = createTicketMessage({
-                        ticketId: ticket.id,
-                        role: 'assistant',
-                        kind: 'final_response',
-                        content: fallbackContent,
-                        responseTiming,
-                        transcriptRuns,
+                if (reviewRunId && ticket.project_id && ticket.worktree_bundle_id) {
+                    io.emit('review-findings:updated', {
+                        project_id: ticket.project_id,
+                        worktree_bundle_id: ticket.worktree_bundle_id,
+                        review_run_id: reviewRunId,
                     });
-                    if (persistedMessageId) {
-                        bindTicketThinkingMessage(ticket.id, persistedMessageId);
+                }
+                storeCreatedAgentRunUsage();
+                if (tool === 'claude' && usageSnapshot) {
+                    storeTicketUsageSnapshotDirect(ticket.id, usageSnapshot);
+                }
+                emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', ticket.id);
+                updateStatus(ticket.id, 'done', null, io);
+                const completedWithMessage = getTicket(ticket.id);
+                if (completedWithMessage) {
+                    io.emit('ticket:updated', completedWithMessage);
+                }
+                const updated = getTicket(ticket.id);
+                if (updated?.agent_status === 'done') {
+                    if (project.memory_enabled && normalizedResponse.suggestions.length > 0) {
+                        persistProjectMemorySuggestions(project.id, ticket.id, 'review', normalizedResponse.suggestions);
+                    }
+                    captureStageSuccess(ticket.id, 'review');
+                    let handled = false;
+                    try {
+                        handled = await runReviewCompletionAutomation(updated, project, reviewRunId, parsedStatus, parsedFindings, io, executionContext, initiation);
+                    }
+                    catch (automationError) {
+                        if (ticket.project_id && ticket.worktree_bundle_id) {
+                            const reason = getErrorMessage(automationError);
+                            if (initiation.initiator === 'automation') {
+                                const progression = resolveProgressionForChild({
+                                    projectId: ticket.project_id,
+                                    bundleId: ticket.worktree_bundle_id,
+                                    childRunId: executionContext.runId,
+                                });
+                                waitAutomationProgression({
+                                    projectId: ticket.project_id,
+                                    bundleId: ticket.worktree_bundle_id,
+                                    progressionRunId: progression.id,
+                                    pauseCode: 'review',
+                                    pauseReason: reason,
+                                    reasonCode: 'stage_failed',
+                                    pausedStageRunId: executionContext.runId,
+                                    broadcaster: asGenericEmitter(io),
+                                });
+                            }
+                            else {
+                                recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'review', reason);
+                            }
+                            handled = true;
+                        }
+                    }
+                    if (!handled) {
+                        const completed = autoParkTicketIfStale(ticket.id);
+                        if (completed) {
+                            io.emit('ticket:updated', completed);
+                        }
                     }
                 }
             }
-            const agentRuns = listAgentRunsForParent('ticket', ticket.id);
-            for (const agentRun of agentRuns) {
-                if (agentRun.session_id && tool === 'opencode') {
-                    storeTicketUsageSnapshot(ticket.id, agentRun.session_id);
+            catch (err) {
+                if (registeredReviewProcess?.stopRequested && finalizeStoppedReviewAfterFailure) {
+                    finalizeStoppedReviewAfterFailure({ transcriptRuns: getAgentErrorTranscriptRuns(err) ?? [] });
+                    return;
                 }
-            }
-            if (tool === 'claude' && usageSnapshot) {
-                storeTicketUsageSnapshotDirect(ticket.id, usageSnapshot);
-            }
-            clearTicketStreamingResponse(ticket.id);
-            clearAgentRunsForParent('ticket', ticket.id);
-            emitAgentRunsUpdated(io, 'ticket', ticket.id);
-            updateStatus(ticket.id, 'done', null, io);
-            const completedWithMessage = getTicket(ticket.id);
-            if (completedWithMessage) {
-                io.emit('ticket:updated', completedWithMessage);
-            }
-            const updated = getTicket(ticket.id);
-            if (updated?.agent_status === 'done') {
-                if (project.memory_enabled && normalizedResponse.suggestions.length > 0) {
-                    persistProjectMemorySuggestions(project.id, ticket.id, 'review', normalizedResponse.suggestions);
+                const transcriptRuns = getAgentErrorTranscriptRuns(err);
+                const errorContent = formatAgentErrorForTranscript(err);
+                const message = getErrorMessage(err);
+                const executionRun = getExecutionRun(executionContext.projectId, executionContext.runId);
+                if (!executionRun || !['queued', 'running', 'waiting'].includes(executionRun.status)) {
+                    return;
+                }
+                let ownedProgressionId = null;
+                if (initiation.initiator === 'automation' && acceptedTicket.project_id && acceptedTicket.worktree_bundle_id) {
+                    try {
+                        ownedProgressionId = resolveProgressionForChild({
+                            projectId: acceptedTicket.project_id,
+                            bundleId: acceptedTicket.worktree_bundle_id,
+                            childRunId: executionContext.runId,
+                        }).id;
+                    }
+                    catch {
+                        ownedProgressionId = null;
+                    }
+                }
+                try {
+                    withExecutionRunTransaction(transaction => {
+                        if (errorContent) {
+                            const messageId = createTicketMessage({
+                                ticketId: acceptedTicket.id,
+                                role: 'assistant',
+                                kind: 'error',
+                                content: errorContent,
+                                transcriptRuns,
+                            });
+                            transaction.addExecutionRunLink({
+                                projectId: executionContext.projectId,
+                                runId: executionContext.runId,
+                                link: {
+                                    entityType: 'ticket_message',
+                                    entityId: messageId,
+                                    relationship: 'result',
+                                    expectedParent: { entityType: 'ticket', entityId: acceptedTicket.id },
+                                },
+                            });
+                        }
+                        db.prepare('UPDATE tickets SET agent_status = ?, agent_log = ?, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND project_id = ?')
+                            .run('error', message, acceptedTicket.id, executionContext.projectId);
+                        terminalizeAgentRunsForExecutionRun(executionContext.runId, 'error', message);
+                        transaction.transitionExecutionRun({
+                            projectId: executionContext.projectId,
+                            runId: executionContext.runId,
+                            status: 'failed',
+                            domainStatus: 'error',
+                            failure: { code: 'review_failed', message },
+                            eventType: 'review_failed',
+                        });
+                        if (ownedProgressionId && acceptedTicket.project_id && acceptedTicket.worktree_bundle_id) {
+                            waitAutomationProgression({
+                                projectId: acceptedTicket.project_id,
+                                bundleId: acceptedTicket.worktree_bundle_id,
+                                progressionRunId: ownedProgressionId,
+                                pauseCode: 'review',
+                                pauseReason: message,
+                                reasonCode: 'stage_failed',
+                                pausedStageRunId: executionContext.runId,
+                                broadcaster: asGenericEmitter(io),
+                            });
+                        }
+                    }, asGenericEmitter(io));
                 }
-                captureStageSuccess(ticket.id, 'review');
-                const handled = await runReviewCompletionAutomation(updated, project, reviewRunId, parsedStatus, parsedFindings, io);
-                if (!handled) {
-                    const completed = autoParkTicketIfStale(ticket.id);
-                    if (completed) {
-                        io.emit('ticket:updated', completed);
+                catch {
+                    const currentExecutionRun = getExecutionRun(executionContext.projectId, executionContext.runId);
+                    if (currentExecutionRun && ['queued', 'running', 'waiting'].includes(currentExecutionRun.status)) {
+                        terminalizeAgentRunsForExecutionRun(executionContext.runId, 'error', message);
+                        transitionExecutionRun({
+                            projectId: executionContext.projectId,
+                            runId: executionContext.runId,
+                            status: 'failed',
+                            domainStatus: 'error',
+                            failure: { code: 'review_failed', message },
+                            eventType: 'review_failed',
+                        }, asGenericEmitter(io));
+                    }
+                    if (ownedProgressionId && acceptedTicket.project_id && acceptedTicket.worktree_bundle_id) {
+                        try {
+                            waitAutomationProgression({
+                                projectId: acceptedTicket.project_id,
+                                bundleId: acceptedTicket.worktree_bundle_id,
+                                progressionRunId: ownedProgressionId,
+                                pauseCode: 'review',
+                                pauseReason: message,
+                                reasonCode: 'stage_failed',
+                                pausedStageRunId: executionContext.runId,
+                                broadcaster: asGenericEmitter(io),
+                            });
+                        }
+                        catch {
+                            // Preserve the terminal Review result when ownership was concurrently cancelled.
+                        }
                     }
                 }
+                if (getTicket(acceptedTicket.id)) {
+                    emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', acceptedTicket.id);
+                    updateStatus(acceptedTicket.id, 'error', message, io);
+                }
             }
-        }
-        catch (err) {
-            const transcriptRuns = getAgentErrorTranscriptRuns(err);
-            const errorContent = formatAgentErrorForTranscript(err);
-            if (errorContent) {
-                createTicketMessage({
-                    ticketId: ticket.id,
-                    role: 'assistant',
-                    kind: 'error',
-                    content: errorContent,
-                    transcriptRuns,
-                });
+            finally {
+                if (registeredReviewProcess) {
+                    untrackReviewProcess(acceptedTicket.id, registeredReviewProcess);
+                }
+                if (activityRegistered) {
+                    unregisterBundleActivity(acceptedTicket, 'review');
+                }
             }
-            clearAgentRunsForParent('ticket', ticket.id);
-            emitAgentRunsUpdated(io, 'ticket', ticket.id);
-            updateStatus(ticket.id, 'error', getErrorMessage(err), io);
-        }
-        finally {
-            unregisterBundleActivity(ticket, 'review');
-        }
+        });
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        withExecutionRunTransaction(transaction => {
+            compensateAcceptance?.();
+            transaction.transitionExecutionRun({
+                projectId: executionContext.projectId,
+                runId: executionContext.runId,
+                status: 'failed',
+                domainStatus: ticket.agent_status ?? 'idle',
+                failure: { code: 'queue_failed', message },
+                eventType: 'review_failed',
+            });
+        }, asGenericEmitter(io));
+        return reject('queue_failed', message);
+    }
+    queuedJob.catch(() => {
+        // The queued callback owns domain and execution failure finalization.
     });
-    return true;
-};
+    return legacyResult ? true : { accepted: true, executionContext };
+}
 //# sourceMappingURL=review.js.map