@straiffi/archon 1.7.2 → 1.7.4

package/dist/server/workers/followUp.js

@@ -1,6 +1,7 @@
 import db from '../db.js';
 import { formatAgentErrorForTranscript, getAgentErrorTranscriptRuns, runAgent } from '../lib/agent.js';
-import { clearAndEmitAgentRunsForParent } from '../lib/agentRuns.js';
+import { createAgentRun, emitAgentRunsUpdated, getAgentRun, terminalizeAgentRunsForExecutionRun } from '../lib/agentRuns.js';
+import { getExecutionRun, withExecutionRunTransaction } from '../lib/executionRuns.js';
 import config from '../lib/config.js';
 import { failBuildOpenQuestionBatch, filterResolvedBuildOpenQuestionsForBatch, listBuildOpenQuestionsForBundle, reconcileBuildOpenQuestions, setBuildOpenQuestionBatchStatus, } from '../lib/buildOpenQuestions.js';
 import { PLAN_MODE_QUESTION_PROMPT_RULES } from '../lib/planModeQuestions.js';
@@ -21,11 +22,29 @@ import { autoParkTicketIfStale, getTicket, listTickets, resolveTicketBranch, res
 import { decideReviewFollowUpAutomation, clearAutomationPause, depthAtLeast, getBundleAutomationState, recordAutomationPause, resolveAutomationConfig, } from '../lib/ticketAutomation.js';
 import { startReview } from './review.js';
 import { transitionBundleToReview } from '../lib/bundleReviewOperations.js';
+import { ensureAutomationProgression, finishAutomationReviewFix, completeAutomationProgression, resolveProgressionForChild, runAutomationProgression, waitAutomationProgression, } from '../lib/automationProgression.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 asGenericEmitter = (io) => io;
+const waitReviewFixProgression = (input) => {
+    try {
+        waitAutomationProgression(input);
+    }
+    catch (error) {
+        const state = getBundleAutomationState(input.projectId, input.bundleId);
+        if (state?.automation_progression_run_id === input.progressionRunId) {
+            throw error;
+        }
+    }
+};
+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);
@@ -153,266 +172,775 @@ Use the review findings as the source of truth unless the follow-up instruction
 
 ${getProjectMemorySuggestionPromptRules(memoryEnabled, 'follow_up')}` : ''}`;
 };
-const runReviewFollowUpCompletionAutomation = (ticket, project, io) => {
+const runReviewFollowUpCompletionAutomation = (ticket, project, 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 = decideReviewFollowUpAutomation(config, bundleState);
+    const followUpRun = getExecutionRun(projectId, executionContext.runId);
+    const reviewFixRun = followUpRun?.parent_run_id
+        ? getExecutionRun(projectId, followUpRun.parent_run_id)
+        : null;
+    const progression = reviewFixRun?.kind === 'automation_review_fix'
+        ? resolveProgressionForChild({
+            projectId,
+            bundleId,
+            childRunId: executionContext.runId,
+            allowReviewFixParent: true,
+        })
+        : null;
     switch (decision.kind) {
         case 'manual':
+            if (progression && reviewFixRun) {
+                finishAutomationReviewFix({
+                    projectId,
+                    reviewFixRunId: reviewFixRun.id,
+                    broadcaster: asGenericEmitter(io),
+                });
+                completeAutomationProgression({
+                    projectId,
+                    bundleId,
+                    progressionRunId: progression.id,
+                    domainStatus: 'manual_boundary_reached',
+                    broadcaster: asGenericEmitter(io),
+                });
+                return true;
+            }
             return false;
         case 'paused':
+            if (reviewFixRun) {
+                finishAutomationReviewFix({
+                    projectId,
+                    reviewFixRunId: reviewFixRun.id,
+                    broadcaster: asGenericEmitter(io),
+                });
+            }
             return true;
         case 're_review': {
-            startReview(ticket, io);
+            if (!progression || !reviewFixRun) {
+                const legacyProgression = ensureAutomationProgression({
+                    projectId,
+                    bundleId,
+                    ticketId: ticket.id,
+                    ticketTitle: ticket.title,
+                    parentRunId: executionContext.runId,
+                    workflowContext: initiation?.workflowContext ?? null,
+                    broadcaster: asGenericEmitter(io),
+                });
+                const reviewResult = startReview(ticket, io, {
+                    initiation: {
+                        initiator: 'automation',
+                        causalParentRunId: legacyProgression.runId,
+                        workflowContext: initiation?.workflowContext ?? null,
+                    },
+                });
+                if (!reviewResult.accepted) {
+                    waitAutomationProgression({
+                        projectId,
+                        bundleId,
+                        progressionRunId: legacyProgression.runId,
+                        pauseCode: 'review',
+                        pauseReason: `Automatic re-review could not start: ${reviewResult.error}`,
+                        reasonCode: 'stage_failed',
+                        pausedStageRunId: executionContext.runId,
+                        broadcaster: asGenericEmitter(io),
+                    });
+                    const pausedTicket = getTicket(ticket.id);
+                    if (pausedTicket) {
+                        io.emit('ticket:updated', pausedTicket);
+                    }
+                }
+                return true;
+            }
+            if (followUpRun?.parent_run_id) {
+                finishAutomationReviewFix({
+                    projectId,
+                    reviewFixRunId: followUpRun.parent_run_id,
+                    broadcaster: asGenericEmitter(io),
+                });
+            }
+            const reviewResult = startReview(ticket, io, {
+                initiation: {
+                    initiator: 'automation',
+                    causalParentRunId: progression.id,
+                    workflowContext: initiation?.workflowContext ?? null,
+                },
+            });
+            if (!reviewResult.accepted) {
+                waitReviewFixProgression({
+                    projectId,
+                    bundleId,
+                    progressionRunId: progression.id,
+                    pauseCode: 'review',
+                    pauseReason: `Automatic re-review could not start: ${reviewResult.error}`,
+                    reasonCode: 'stage_failed',
+                    pausedStageRunId: executionContext.runId,
+                    broadcaster: asGenericEmitter(io),
+                });
+                const pausedTicket = getTicket(ticket.id);
+                if (pausedTicket) {
+                    io.emit('ticket:updated', pausedTicket);
+                }
+            }
             return true;
         }
         case 'fall_through':
             return false;
     }
 };
-export const startFollowUp = (ticket, io, instruction, mode = 'build', options = {}) => {
+export const isFollowUpRunning = (ticket) => {
+    const jobKey = resolveTicketWorkerKey(ticket, 'follow_up');
+    return !jobKey || isRunning(jobKey);
+};
+export function startFollowUp(ticket, io, instruction, mode = 'build', options = {}) {
+    const structuredResult = options.executionContext !== undefined;
+    const reject = (reason, error) => (structuredResult ? { accepted: false, reason, error } : false);
     const jobKey = resolveTicketWorkerKey(ticket, 'follow_up');
     if (!jobKey || isRunning(jobKey)) {
-        return false;
+        return reject('busy', 'Ticket follow-up is already scheduled or running');
     }
-    beginTicketThinkingRun(ticket.id);
-    clearAndEmitAgentRunsForParent(io, 'ticket', ticket.id);
-    updateStatus(ticket.id, 'running', null, io);
-    const activityKind = ticket.state === 'build' ? 'build_follow_up' : 'review_follow_up';
-    enqueue(jobKey, async () => {
-        registerBundleActivity(ticket, activityKind);
-        let buildOpenQuestionBatchCompleted = false;
+    const project = getEffectiveProject(ticket);
+    if (!project || !ticket.project_id || project.id !== ticket.project_id) {
+        return reject('project_unavailable', 'Ticket project is unavailable');
+    }
+    const runConfig = options.runConfig ?? {
+        tool: resolveTicketTool(ticket, config.tool ?? 'opencode'),
+        model: ticket.model,
+        variant: ticket.variant,
+        skills: ticket.skills,
+    };
+    let executionContext = options.executionContext;
+    if (!executionContext) {
+        const initiation = {
+            initiator: 'user',
+            causalParentRunId: null,
+            retrySourceRunId: null,
+            workflowContext: null,
+            ...options.initiation,
+        };
         try {
-            const project = getEffectiveProject(ticket);
-            if (!project) {
-                if (options.buildOpenQuestionBatchId) {
-                    failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, 'Ticket project no longer exists');
-                    if (ticket.project_id && ticket.worktree_bundle_id) {
-                        recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', 'Build open question follow-up failed: Ticket project no longer exists');
-                        emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
-                    }
-                }
-                updateStatus(ticket.id, 'error', 'Ticket project no longer exists', io);
-                return;
+            executionContext = withExecutionRunTransaction(transaction => {
+                const executionRun = transaction.createExecutionRun({
+                    projectId: project.id,
+                    kind: 'build_follow_up',
+                    domainStatus: 'queued',
+                    sourceReference: { kind: 'ticket', id: ticket.id, label: ticket.title },
+                    links: ticket.worktree_bundle_id
+                        ? [{ entityType: 'bundle', entityId: ticket.worktree_bundle_id, relationship: 'context' }]
+                        : [],
+                    initiatedBy: initiation.initiator,
+                    parentRunId: initiation.causalParentRunId,
+                    retryOfRunId: initiation.retrySourceRunId,
+                    metadata: {
+                        ...(initiation.workflowContext ?? {}),
+                        retry_tool: runConfig.tool,
+                        retry_model: runConfig.model,
+                        retry_variant: runConfig.variant,
+                        retry_skills: runConfig.skills,
+                    },
+                    eventType: initiation.retrySourceRunId ? 'retry_started' : 'build_follow_up_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 ownedProgressionRunId = null;
+    let ownedReviewFixRunId = null;
+    let ownedReviewProgressionRunId = null;
+    if (options.buildOpenQuestionBatchId) {
+        try {
+            const executionRun = getExecutionRun(executionContext.projectId, executionContext.runId);
+            if (executionRun?.kind !== 'build_follow_up'
+                || executionRun.initiated_by !== 'user'
+                || executionRun.metadata?.build_open_question_batch_id !== options.buildOpenQuestionBatchId
+                || !ticket.worktree_bundle_id) {
+                throw new Error('Build open question follow-up ownership is invalid');
             }
-            const branch = resolveTicketBranch(ticket);
-            if (!branch) {
-                if (options.buildOpenQuestionBatchId) {
-                    failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, 'Worktree not ready yet');
-                    if (ticket.project_id && ticket.worktree_bundle_id) {
-                        recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', 'Build open question follow-up failed to start: Worktree not ready yet');
-                        emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
-                    }
+            ownedProgressionRunId = resolveProgressionForChild({
+                projectId: executionContext.projectId,
+                bundleId: ticket.worktree_bundle_id,
+                childRunId: executionContext.runId,
+            }).id;
+        }
+        catch (error) {
+            return reject('invalid_context', getErrorMessage(error));
+        }
+    }
+    if (!options.buildOpenQuestionBatchId && ticket.worktree_bundle_id) {
+        const followUpRun = getExecutionRun(executionContext.projectId, executionContext.runId);
+        const parent = followUpRun?.parent_run_id
+            ? getExecutionRun(executionContext.projectId, followUpRun.parent_run_id)
+            : null;
+        if (parent?.kind === 'automation_review_fix') {
+            try {
+                ownedReviewFixRunId = parent.id;
+                ownedReviewProgressionRunId = resolveProgressionForChild({
+                    projectId: executionContext.projectId,
+                    bundleId: ticket.worktree_bundle_id,
+                    childRunId: executionContext.runId,
+                    allowReviewFixParent: true,
+                }).id;
+            }
+            catch (error) {
+                return reject('invalid_context', getErrorMessage(error));
+            }
+        }
+    }
+    if (!structuredResult) {
+        beginTicketThinkingRun(ticket.id);
+        const operation = ticket.state === 'review' && mode !== 'plan' ? 'follow_up' : undefined;
+        updateStatus(ticket.id, 'running', null, io, operation);
+    }
+    const activityKind = ticket.state === 'build' ? 'build_follow_up' : 'review_follow_up';
+    let queuedJob;
+    try {
+        queuedJob = enqueue(jobKey, async () => {
+            const scheduledRun = getExecutionRun(executionContext.projectId, executionContext.runId);
+            if (!scheduledRun || !['queued', 'running', 'waiting'].includes(scheduledRun.status)) {
+                if (options.buildOpenQuestionBatchId
+                    && scheduledRun
+                    && ['failed', 'cancelled', 'interrupted'].includes(scheduledRun.status)) {
+                    failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, 'Build open question follow-up was stopped');
                 }
-                updateStatus(ticket.id, 'error', 'Worktree not ready yet', io);
                 return;
             }
-            const cwd = ticket.bundle?.kind === 'project_root' ? project.repo_path : resolveWorktreePath(branch, project);
-            const tool = resolveTicketTool(ticket, config.tool ?? 'opencode');
-            const isBuildTicket = ticket.state === 'build';
-            const isReviewTicket = ticket.state === 'review';
-            const isPlanMode = mode === 'plan';
-            const latestReviewFindings = isBuildTicket
-                ? ''
-                : getLatestReviewMarkdownForContext({
-                    ticketId: ticket.id,
-                    projectId: ticket.project_id,
-                    worktreeBundleId: ticket.worktree_bundle_id,
+            registerBundleActivity(ticket, activityKind);
+            let buildOpenQuestionBatchCompleted = false;
+            try {
+                withExecutionRunTransaction(transaction => {
+                    const operation = ticket.state === 'review' && mode !== 'plan' ? 'follow_up' : null;
+                    db.prepare('UPDATE tickets SET agent_status = ?, agent_operation = ?, agent_log = NULL, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND project_id = ?').run('running', operation, ticket.id, executionContext.projectId);
+                    transaction.transitionExecutionRun({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        status: 'running',
+                        domainStatus: 'running',
+                        eventType: 'build_follow_up_started',
+                    });
+                }, asGenericEmitter(io));
+                beginTicketThinkingRun(ticket.id);
+                updateStatus(ticket.id, 'running', null, io, ticket.state === 'review' && mode !== 'plan' ? 'follow_up' : undefined);
+                const project = getEffectiveProject(ticket);
+                if (!project) {
+                    throw new Error('Ticket project no longer exists');
+                }
+                const branch = resolveTicketBranch(ticket);
+                if (!branch) {
+                    throw new Error('Worktree not ready yet');
+                }
+                const cwd = ticket.bundle?.kind === 'project_root' ? project.repo_path : resolveWorktreePath(branch, project);
+                const runTicket = { ...ticket, ...runConfig };
+                const tool = resolveTicketTool(runTicket, config.tool ?? 'opencode');
+                const isBuildTicket = ticket.state === 'build';
+                const isReviewTicket = ticket.state === 'review';
+                const isPlanMode = mode === 'plan';
+                const latestReviewFindings = isBuildTicket
+                    ? ''
+                    : getLatestReviewMarkdownForContext({
+                        ticketId: ticket.id,
+                        projectId: ticket.project_id,
+                        worktreeBundleId: ticket.worktree_bundle_id,
+                    });
+                if (isBuildTicket && !isPlanMode) {
+                    clearBuildCompletion(ticket.id);
+                }
+                const isReviewResume = isReviewTicket && !isPlanMode && Boolean(ticket.session_id) && hasPreviousReviewFollowUp(ticket);
+                const prompt = isPlanMode
+                    ? questionFollowUpPrompt(runTicket, instruction, Boolean(project.memory_enabled))
+                    : isBuildTicket
+                        ? followUpPrompt(runTicket, instruction, Boolean(project.memory_enabled), !options.buildOpenQuestionBatchId)
+                        : prependSkillPromptBlock(reviewFindingsFollowUpPrompt(runTicket, latestReviewFindings, instruction, Boolean(project.memory_enabled)), runTicket.skills);
+                const resumeSessionId = options.providerContinuation === 'fresh' || isPlanMode
+                    ? null
+                    : (isBuildTicket || isReviewResume ? ticket.session_id : null);
+                const mainRunId = createAgentRun({
+                    executionRunId: executionContext.runId,
+                    parentType: 'ticket',
+                    parentId: ticket.id,
+                    label: ticket.state === 'review' ? 'Review follow-up' : 'Build follow-up',
+                    role: 'main',
                 });
-            if (isBuildTicket && !isPlanMode) {
-                clearBuildCompletion(ticket.id);
-            }
-            const isReviewResume = isReviewTicket && !isPlanMode && Boolean(ticket.session_id) && hasPreviousReviewFollowUp(ticket);
-            const prompt = isPlanMode
-                ? questionFollowUpPrompt(ticket, instruction, Boolean(project.memory_enabled))
-                : isBuildTicket
-                    ? followUpPrompt(ticket, instruction, Boolean(project.memory_enabled), !options.buildOpenQuestionBatchId)
-                    : prependSkillPromptBlock(reviewFindingsFollowUpPrompt(ticket, latestReviewFindings, instruction, Boolean(project.memory_enabled)), ticket.skills);
-            const resumeSessionId = isPlanMode ? null : (isBuildTicket || isReviewResume ? ticket.session_id : null);
-            const { response: finalResponse, responseTiming, transcriptRuns } = await runAgent({
-                ticketId: ticket.id,
-                tool,
-                prompt,
-                cwd,
-                model: ticket.model,
-                variant: ticket.variant,
-                resumeSessionId,
-                trackBuildProcess: !isPlanMode && (isBuildTicket || isReviewTicket),
-                emitSuccessUpdate: false,
-                io,
-                opencodeAgentMode: isPlanMode ? mode : undefined,
-            });
-            const parsedResponse = typeof finalResponse === 'string'
-                ? parseAgentResponseWithOpenQuestions(finalResponse)
-                : { response: '', openQuestions: [], hasOpenQuestionsMetadata: false, suggestions: [] };
-            const openQuestions = options.buildOpenQuestionBatchId
-                ? filterResolvedBuildOpenQuestionsForBatch(options.buildOpenQuestionBatchId, parsedResponse.openQuestions)
-                : parsedResponse.openQuestions;
-            const assistantMessage = isBuildTicket
-                ? formatAssistantMessageWithOpenQuestions({
-                    response: parsedResponse.response,
-                    openQuestions,
-                })
-                : parsedResponse.response.trim();
-            let assistantMessageId = null;
-            if (assistantMessage) {
-                assistantMessageId = createTicketMessage({
+                const mainRun = getAgentRun(mainRunId);
+                if (!mainRun) {
+                    throw new Error('Unable to create the follow-up agent run');
+                }
+                emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', ticket.id);
+                const { response: finalResponse, responseTiming, transcriptRuns } = await runAgent({
                     ticketId: ticket.id,
-                    role: 'assistant',
-                    kind: 'final_response',
-                    content: assistantMessage,
-                    responseTiming,
-                    transcriptRuns,
+                    tool,
+                    prompt,
+                    cwd,
+                    model: runTicket.model,
+                    variant: runTicket.variant,
+                    resumeSessionId,
+                    trackBuildProcess: !isPlanMode && (isBuildTicket || isReviewTicket),
+                    emitSuccessUpdate: false,
+                    persistSessionIdToTicket: !isPlanMode,
+                    executionContext,
+                    runStream: {
+                        runId: mainRun.id,
+                        label: mainRun.label,
+                        role: mainRun.role,
+                        runIndex: mainRun.run_index,
+                    },
+                    io,
+                    opencodeAgentMode: isPlanMode ? mode : undefined,
                 });
+                const parsedResponse = typeof finalResponse === 'string'
+                    ? parseAgentResponseWithOpenQuestions(finalResponse)
+                    : { response: '', openQuestions: [], hasOpenQuestionsMetadata: false, suggestions: [] };
+                const openQuestions = options.buildOpenQuestionBatchId
+                    ? filterResolvedBuildOpenQuestionsForBatch(options.buildOpenQuestionBatchId, parsedResponse.openQuestions)
+                    : parsedResponse.openQuestions;
+                const assistantMessage = isBuildTicket
+                    ? formatAssistantMessageWithOpenQuestions({
+                        response: parsedResponse.response,
+                        openQuestions,
+                    })
+                    : parsedResponse.response.trim();
+                const completedMainRun = getAgentRun(mainRun.id);
+                const completionStatus = completedMainRun?.agent_status === 'stopped' ? 'stopped' : 'done';
+                const authoritativeResult = withExecutionRunTransaction(transaction => {
+                    const assistantMessageId = assistantMessage
+                        ? createTicketMessage({
+                            ticketId: ticket.id,
+                            role: 'assistant',
+                            kind: 'final_response',
+                            content: assistantMessage,
+                            responseTiming,
+                            transcriptRuns,
+                        })
+                        : null;
+                    db.prepare('UPDATE tickets SET agent_status = ?, agent_log = NULL, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND project_id = ?').run(completionStatus, ticket.id, executionContext.projectId);
+                    const completedTicket = getTicket(ticket.id) ?? ticket;
+                    if (isBuildTicket && !isPlanMode && completionStatus === 'done') {
+                        markBuildCompleted(ticket.id);
+                        if (parsedResponse.hasOpenQuestionsMetadata) {
+                            db.prepare('UPDATE tickets SET planning_context_json = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(JSON.stringify(createTicketOpenQuestionsContext(completedTicket, openQuestions)), ticket.id);
+                            if (ticket.project_id && ticket.worktree_bundle_id) {
+                                reconcileBuildOpenQuestions({
+                                    projectId: ticket.project_id,
+                                    bundleId: ticket.worktree_bundle_id,
+                                    ticketId: ticket.id,
+                                    questions: openQuestions,
+                                    sourceKey: `follow-up:${ticket.id}:${assistantMessageId ?? completedTicket.updated_at}`,
+                                });
+                            }
+                        }
+                    }
+                    if (assistantMessageId) {
+                        transaction.addExecutionRunLink({
+                            projectId: executionContext.projectId,
+                            runId: executionContext.runId,
+                            link: {
+                                entityType: 'ticket_message',
+                                entityId: assistantMessageId,
+                                relationship: 'result',
+                                expectedParent: { entityType: 'ticket', entityId: ticket.id },
+                            },
+                        });
+                    }
+                    let batchCompleted = false;
+                    if (options.buildOpenQuestionBatchId) {
+                        if (completionStatus === 'stopped') {
+                            failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, 'Build open question follow-up was stopped');
+                        }
+                        else if (parsedResponse.hasOpenQuestionsMetadata) {
+                            setBuildOpenQuestionBatchStatus(options.buildOpenQuestionBatchId, 'done');
+                            batchCompleted = true;
+                        }
+                        else {
+                            failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, 'Build follow-up did not return valid Open Questions metadata');
+                        }
+                    }
+                    terminalizeAgentRunsForExecutionRun(executionContext.runId, completionStatus, null);
+                    transaction.transitionExecutionRun({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        status: completionStatus === 'stopped' ? 'cancelled' : 'completed',
+                        domainStatus: completionStatus,
+                        eventType: completionStatus === 'stopped' ? 'build_follow_up_cancelled' : 'build_follow_up_completed',
+                    });
+                    return { assistantMessageId, batchCompleted };
+                }, asGenericEmitter(io));
+                const assistantMessageId = authoritativeResult.assistantMessageId;
+                buildOpenQuestionBatchCompleted = authoritativeResult.batchCompleted;
                 if (assistantMessageId) {
                     bindTicketThinkingMessage(ticket.id, assistantMessageId);
                 }
-            }
-            if (transcriptRuns) {
-                clearAndEmitAgentRunsForParent(io, 'ticket', ticket.id);
-            }
-            const completedTicket = getTicket(ticket.id) ?? ticket;
-            if (options.buildOpenQuestionBatchId && completedTicket.agent_status === 'stopped') {
-                failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, 'Build open question follow-up was stopped');
-                if (ticket.project_id && ticket.worktree_bundle_id) {
-                    recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', 'Build open question follow-up was stopped');
+                emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', ticket.id);
+                const completedTicket = getTicket(ticket.id) ?? ticket;
+                if (options.buildOpenQuestionBatchId && completedTicket.agent_status === 'stopped') {
+                    if (ticket.project_id && ticket.worktree_bundle_id && ownedProgressionRunId) {
+                        waitAutomationProgression({
+                            projectId: ticket.project_id,
+                            bundleId: ticket.worktree_bundle_id,
+                            progressionRunId: ownedProgressionRunId,
+                            pauseCode: 'open_questions',
+                            pauseReason: 'Build open question follow-up was stopped',
+                            reasonCode: 'stage_failed',
+                            pausedStageRunId: executionContext.runId,
+                            broadcaster: asGenericEmitter(io),
+                        });
+                    }
                 }
-            }
-            if (isBuildTicket && !isPlanMode && completedTicket.agent_status === 'done' && parsedResponse.hasOpenQuestionsMetadata) {
-                db.prepare('UPDATE tickets SET planning_context_json = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(JSON.stringify(createTicketOpenQuestionsContext(completedTicket, openQuestions)), ticket.id);
-                if (ticket.project_id && ticket.worktree_bundle_id) {
-                    reconcileBuildOpenQuestions({
+                if (completedTicket.agent_status === 'stopped'
+                    && ticket.project_id
+                    && ticket.worktree_bundle_id
+                    && ownedReviewFixRunId
+                    && ownedReviewProgressionRunId) {
+                    const reason = 'Automation review fix follow-up was stopped';
+                    finishAutomationReviewFix({
+                        projectId: ticket.project_id,
+                        reviewFixRunId: ownedReviewFixRunId,
+                        failedMessage: reason,
+                        broadcaster: asGenericEmitter(io),
+                    });
+                    waitReviewFixProgression({
                         projectId: ticket.project_id,
                         bundleId: ticket.worktree_bundle_id,
-                        ticketId: ticket.id,
-                        questions: openQuestions,
-                        sourceKey: `follow-up:${ticket.id}:${assistantMessageId ?? completedTicket.updated_at}`,
+                        progressionRunId: ownedReviewProgressionRunId,
+                        pauseCode: 'review',
+                        pauseReason: reason,
+                        reasonCode: 'stage_failed',
+                        pausedStageRunId: executionContext.runId,
+                        broadcaster: asGenericEmitter(io),
                     });
-                    const bundleOpenQuestions = listBuildOpenQuestionsForBundle(ticket.project_id, ticket.worktree_bundle_id);
-                    const automationConfig = resolveAutomationConfig(completedTicket.bundle ?? null, project);
-                    const bundleState = getBundleAutomationState(ticket.project_id, ticket.worktree_bundle_id);
-                    const shouldPauseForOpenQuestions = (bundleOpenQuestions.length > 0
-                        && automationConfig.pauseOnOpenQuestions
-                        && depthAtLeast(automationConfig.depth, 'auto_review'));
-                    if (shouldPauseForOpenQuestions) {
-                        recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', `${bundleOpenQuestions.length} unresolved Build open question${bundleOpenQuestions.length === 1 ? '' : 's'}`);
-                    }
-                    else if (bundleState?.automation_paused_code === 'open_questions') {
-                        clearAutomationPause(ticket.project_id, ticket.worktree_bundle_id);
-                    }
-                    emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
                 }
-            }
-            if (project.memory_enabled && parsedResponse.suggestions.length > 0) {
-                persistProjectMemorySuggestions(project.id, ticket.id, 'follow_up', parsedResponse.suggestions);
-            }
-            clearTicketStreamingResponse(ticket.id);
-            const completedWithMessage = getTicket(ticket.id);
-            if (completedWithMessage) {
-                io.emit('ticket:updated', completedWithMessage);
-            }
-            if (!isPlanMode) {
-                const updated = getTicket(ticket.id);
-                if (isBuildTicket && updated?.agent_status === 'done') {
-                    markBuildCompleted(ticket.id);
-                    captureStageSuccess(ticket.id, 'build');
-                    const completed = autoParkTicketIfStale(ticket.id);
-                    if (completed) {
-                        io.emit('ticket:updated', completed);
-                    }
+                if (isBuildTicket && !isPlanMode && completedTicket.agent_status === 'done' && parsedResponse.hasOpenQuestionsMetadata) {
                     if (ticket.project_id && ticket.worktree_bundle_id) {
-                        if (options.buildOpenQuestionBatchId) {
-                            if (!parsedResponse.hasOpenQuestionsMetadata) {
-                                failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, 'Build follow-up did not return valid Open Questions metadata');
-                                recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', 'Build follow-up did not return valid Open Questions metadata');
+                        const bundleOpenQuestions = listBuildOpenQuestionsForBundle(ticket.project_id, ticket.worktree_bundle_id);
+                        const automationConfig = resolveAutomationConfig(completedTicket.bundle ?? null, project);
+                        const bundleState = getBundleAutomationState(ticket.project_id, ticket.worktree_bundle_id);
+                        const shouldPauseForOpenQuestions = (bundleOpenQuestions.length > 0
+                            && automationConfig.pauseOnOpenQuestions
+                            && depthAtLeast(automationConfig.depth, 'auto_review'));
+                        if (shouldPauseForOpenQuestions) {
+                            recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', `${bundleOpenQuestions.length} unresolved Build open question${bundleOpenQuestions.length === 1 ? '' : 's'}`);
+                        }
+                        else if (bundleState?.automation_paused_code === 'open_questions') {
+                            if (bundleState.automation_progression_run_id) {
+                                runAutomationProgression({
+                                    projectId: ticket.project_id,
+                                    bundleId: ticket.worktree_bundle_id,
+                                    progressionRunId: bundleState.automation_progression_run_id,
+                                    broadcaster: asGenericEmitter(io),
+                                });
                             }
                             else {
-                                setBuildOpenQuestionBatchStatus(options.buildOpenQuestionBatchId, 'done');
-                                buildOpenQuestionBatchCompleted = true;
-                            }
-                        }
-                        const automationConfig = resolveAutomationConfig(updated.bundle ?? null, project);
-                        const bundleState = getBundleAutomationState(ticket.project_id, ticket.worktree_bundle_id);
-                        const bundleOpenQuestions = listBuildOpenQuestionsForBundle(ticket.project_id, ticket.worktree_bundle_id);
-                        if (options.buildOpenQuestionBatchId) {
-                            const shouldPauseForOpenQuestions = parsedResponse.hasOpenQuestionsMetadata
-                                && bundleOpenQuestions.length > 0
-                                && automationConfig.pauseOnOpenQuestions
-                                && depthAtLeast(automationConfig.depth, 'auto_review');
-                            if (parsedResponse.hasOpenQuestionsMetadata && !shouldPauseForOpenQuestions) {
                                 clearAutomationPause(ticket.project_id, ticket.worktree_bundle_id);
-                                if (depthAtLeast(automationConfig.depth, 'auto_review')) {
-                                    const reviewResult = transitionBundleToReview(ticket.project_id, ticket.worktree_bundle_id, io, { automatic: true });
-                                    if (!reviewResult.ok) {
-                                        recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'review', reviewResult.error);
-                                    }
-                                }
                             }
-                            else if (shouldPauseForOpenQuestions) {
-                                recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', `${bundleOpenQuestions.length} unresolved Build open question${bundleOpenQuestions.length === 1 ? '' : 's'}`);
-                            }
-                        }
-                        else if (depthAtLeast(automationConfig.depth, 'auto_review')
-                            && (!bundleState?.automation_paused_reason || bundleState.automation_paused_code === 'open_questions')
-                            && !(bundleOpenQuestions.length > 0 && automationConfig.pauseOnOpenQuestions)) {
-                            transitionBundleToReview(ticket.project_id, ticket.worktree_bundle_id, io, { automatic: true });
                         }
                         emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
                     }
                 }
-                else if (!isBuildTicket && updated?.agent_status === 'done') {
-                    captureStageSuccess(ticket.id, 'review');
-                    const handled = runReviewFollowUpCompletionAutomation(updated, project, io);
-                    if (!handled) {
+                if (project.memory_enabled && parsedResponse.suggestions.length > 0) {
+                    persistProjectMemorySuggestions(project.id, ticket.id, 'follow_up', parsedResponse.suggestions);
+                }
+                clearTicketStreamingResponse(ticket.id);
+                const completedWithMessage = getTicket(ticket.id);
+                if (completedWithMessage) {
+                    io.emit('ticket:updated', completedWithMessage);
+                }
+                if (!isPlanMode) {
+                    const updated = getTicket(ticket.id);
+                    if (isBuildTicket && updated?.agent_status === 'done') {
+                        captureStageSuccess(ticket.id, 'build');
                         const completed = autoParkTicketIfStale(ticket.id);
                         if (completed) {
                             io.emit('ticket:updated', completed);
                         }
+                        if (ticket.project_id && ticket.worktree_bundle_id) {
+                            if (options.buildOpenQuestionBatchId) {
+                                if (!parsedResponse.hasOpenQuestionsMetadata) {
+                                    if (ownedProgressionRunId) {
+                                        waitAutomationProgression({
+                                            projectId: ticket.project_id,
+                                            bundleId: ticket.worktree_bundle_id,
+                                            progressionRunId: ownedProgressionRunId,
+                                            pauseCode: 'open_questions',
+                                            pauseReason: 'Build follow-up did not return valid Open Questions metadata',
+                                            reasonCode: 'stage_failed',
+                                            pausedStageRunId: executionContext.runId,
+                                            broadcaster: asGenericEmitter(io),
+                                        });
+                                    }
+                                }
+                            }
+                            const automationConfig = resolveAutomationConfig(updated.bundle ?? null, project);
+                            const bundleState = getBundleAutomationState(ticket.project_id, ticket.worktree_bundle_id);
+                            const bundleOpenQuestions = listBuildOpenQuestionsForBundle(ticket.project_id, ticket.worktree_bundle_id);
+                            if (options.buildOpenQuestionBatchId) {
+                                const shouldPauseForOpenQuestions = parsedResponse.hasOpenQuestionsMetadata
+                                    && bundleOpenQuestions.length > 0
+                                    && automationConfig.pauseOnOpenQuestions
+                                    && depthAtLeast(automationConfig.depth, 'auto_review');
+                                if (parsedResponse.hasOpenQuestionsMetadata && !shouldPauseForOpenQuestions) {
+                                    if (!ownedProgressionRunId) {
+                                        clearAutomationPause(ticket.project_id, ticket.worktree_bundle_id);
+                                    }
+                                    if (depthAtLeast(automationConfig.depth, 'auto_review')) {
+                                        const reviewResult = transitionBundleToReview(ticket.project_id, ticket.worktree_bundle_id, io, {
+                                            automatic: true,
+                                            initiation: {
+                                                causalParentRunId: ownedProgressionRunId ?? executionContext.runId,
+                                                workflowContext: options.initiation?.workflowContext ?? null,
+                                            },
+                                        });
+                                        if (!reviewResult.ok) {
+                                            if (ownedProgressionRunId) {
+                                                waitAutomationProgression({
+                                                    projectId: ticket.project_id,
+                                                    bundleId: ticket.worktree_bundle_id,
+                                                    progressionRunId: ownedProgressionRunId,
+                                                    pauseCode: 'review',
+                                                    pauseReason: reviewResult.error,
+                                                    reasonCode: 'stage_failed',
+                                                    pausedStageRunId: executionContext.runId,
+                                                    broadcaster: asGenericEmitter(io),
+                                                });
+                                            }
+                                            else {
+                                                recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'review', reviewResult.error);
+                                            }
+                                        }
+                                    }
+                                    else if (ownedProgressionRunId) {
+                                        completeAutomationProgression({
+                                            projectId: ticket.project_id,
+                                            bundleId: ticket.worktree_bundle_id,
+                                            progressionRunId: ownedProgressionRunId,
+                                            broadcaster: asGenericEmitter(io),
+                                        });
+                                    }
+                                }
+                                else if (shouldPauseForOpenQuestions) {
+                                    if (ownedProgressionRunId) {
+                                        waitAutomationProgression({
+                                            projectId: ticket.project_id,
+                                            bundleId: ticket.worktree_bundle_id,
+                                            progressionRunId: ownedProgressionRunId,
+                                            pauseCode: 'open_questions',
+                                            pauseReason: `${bundleOpenQuestions.length} unresolved Build open question${bundleOpenQuestions.length === 1 ? '' : 's'}`,
+                                            reasonCode: 'precondition_failed',
+                                            pausedStageRunId: null,
+                                            broadcaster: asGenericEmitter(io),
+                                        });
+                                    }
+                                }
+                            }
+                            else if (depthAtLeast(automationConfig.depth, 'auto_review')
+                                && (!bundleState?.automation_paused_reason || bundleState.automation_paused_code === 'open_questions')
+                                && !(bundleOpenQuestions.length > 0 && automationConfig.pauseOnOpenQuestions)) {
+                                const progression = ensureAutomationProgression({
+                                    projectId: ticket.project_id,
+                                    bundleId: ticket.worktree_bundle_id,
+                                    ticketId: ticket.id,
+                                    ticketTitle: ticket.title,
+                                    parentRunId: executionContext.runId,
+                                    workflowContext: options.initiation?.workflowContext ?? null,
+                                    broadcaster: asGenericEmitter(io),
+                                });
+                                const reviewResult = transitionBundleToReview(ticket.project_id, ticket.worktree_bundle_id, io, {
+                                    automatic: true,
+                                    initiation: {
+                                        causalParentRunId: progression.runId,
+                                        workflowContext: options.initiation?.workflowContext ?? null,
+                                    },
+                                });
+                                if (!reviewResult.ok) {
+                                    waitAutomationProgression({
+                                        projectId: ticket.project_id,
+                                        bundleId: ticket.worktree_bundle_id,
+                                        progressionRunId: progression.runId,
+                                        pauseCode: 'review',
+                                        pauseReason: reviewResult.error,
+                                        reasonCode: 'stage_failed',
+                                        pausedStageRunId: executionContext.runId,
+                                        broadcaster: asGenericEmitter(io),
+                                    });
+                                }
+                            }
+                            emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
+                        }
+                    }
+                    else if (!isBuildTicket && updated?.agent_status === 'done') {
+                        captureStageSuccess(ticket.id, 'review');
+                        const handled = runReviewFollowUpCompletionAutomation(updated, project, io, executionContext, options.initiation);
+                        if (!handled) {
+                            const completed = autoParkTicketIfStale(ticket.id);
+                            if (completed) {
+                                io.emit('ticket:updated', completed);
+                            }
+                        }
                     }
                 }
             }
-        }
-        catch (error) {
-            if (options.buildOpenQuestionBatchId) {
-                if (ticket.project_id && ticket.worktree_bundle_id) {
-                    if (buildOpenQuestionBatchCompleted) {
-                        recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'review', `Build open question follow-up completed but automation could not continue: ${getErrorMessage(error)}`);
+            catch (error) {
+                const executionRun = getExecutionRun(executionContext.projectId, executionContext.runId);
+                if (executionRun && !['queued', 'running', 'waiting'].includes(executionRun.status)) {
+                    if (ticket.project_id && ticket.worktree_bundle_id) {
+                        if (ownedProgressionRunId) {
+                            waitAutomationProgression({
+                                projectId: ticket.project_id,
+                                bundleId: ticket.worktree_bundle_id,
+                                progressionRunId: ownedProgressionRunId,
+                                pauseCode: 'review',
+                                pauseReason: `Follow-up completed but automation could not continue: ${getErrorMessage(error)}`,
+                                reasonCode: 'stage_failed',
+                                pausedStageRunId: executionContext.runId,
+                                broadcaster: asGenericEmitter(io),
+                            });
+                        }
+                        else if (ownedReviewProgressionRunId) {
+                            waitReviewFixProgression({
+                                projectId: ticket.project_id,
+                                bundleId: ticket.worktree_bundle_id,
+                                progressionRunId: ownedReviewProgressionRunId,
+                                pauseCode: 'review',
+                                pauseReason: `Follow-up completed but automation could not continue: ${getErrorMessage(error)}`,
+                                reasonCode: 'stage_failed',
+                                pausedStageRunId: executionContext.runId,
+                                broadcaster: asGenericEmitter(io),
+                            });
+                        }
+                        else {
+                            recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'review', `Follow-up completed but automation could not continue: ${getErrorMessage(error)}`);
+                        }
+                        emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
                     }
-                    else {
+                    return;
+                }
+                if (options.buildOpenQuestionBatchId) {
+                    if (ticket.project_id && ticket.worktree_bundle_id) {
+                        if (buildOpenQuestionBatchCompleted) {
+                            if (ownedProgressionRunId) {
+                                waitAutomationProgression({
+                                    projectId: ticket.project_id,
+                                    bundleId: ticket.worktree_bundle_id,
+                                    progressionRunId: ownedProgressionRunId,
+                                    pauseCode: 'review',
+                                    pauseReason: `Build open question follow-up completed but automation could not continue: ${getErrorMessage(error)}`,
+                                    reasonCode: 'stage_failed',
+                                    pausedStageRunId: executionContext.runId,
+                                    broadcaster: asGenericEmitter(io),
+                                });
+                            }
+                        }
+                        else {
+                            failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, getErrorMessage(error));
+                            if (ownedProgressionRunId) {
+                                waitAutomationProgression({
+                                    projectId: ticket.project_id,
+                                    bundleId: ticket.worktree_bundle_id,
+                                    progressionRunId: ownedProgressionRunId,
+                                    pauseCode: 'open_questions',
+                                    pauseReason: `Build open question follow-up failed: ${getErrorMessage(error)}`,
+                                    reasonCode: 'stage_failed',
+                                    pausedStageRunId: executionContext.runId,
+                                    broadcaster: asGenericEmitter(io),
+                                });
+                            }
+                        }
+                        emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
+                    }
+                    else if (!buildOpenQuestionBatchCompleted) {
                         failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, getErrorMessage(error));
-                        recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', `Build open question follow-up failed: ${getErrorMessage(error)}`);
                     }
-                    emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
                 }
-                else if (!buildOpenQuestionBatchCompleted) {
-                    failBuildOpenQuestionBatch(options.buildOpenQuestionBatchId, getErrorMessage(error));
+                const transcriptRuns = getAgentErrorTranscriptRuns(error);
+                const errorContent = formatAgentErrorForTranscript(error);
+                const message = getErrorMessage(error);
+                withExecutionRunTransaction(transaction => {
+                    if (errorContent) {
+                        const messageId = createTicketMessage({
+                            ticketId: ticket.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: ticket.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, ticket.id, executionContext.projectId);
+                    terminalizeAgentRunsForExecutionRun(executionContext.runId, 'error', message);
+                    transaction.transitionExecutionRun({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        status: 'failed',
+                        domainStatus: 'error',
+                        failure: { code: 'build_follow_up_failed', message },
+                        eventType: 'build_follow_up_failed',
+                    });
+                }, asGenericEmitter(io));
+                if (ownedReviewFixRunId && ownedReviewProgressionRunId && ticket.project_id && ticket.worktree_bundle_id) {
+                    finishAutomationReviewFix({
+                        projectId: ticket.project_id,
+                        reviewFixRunId: ownedReviewFixRunId,
+                        failedMessage: message,
+                        broadcaster: asGenericEmitter(io),
+                    });
+                    waitReviewFixProgression({
+                        projectId: ticket.project_id,
+                        bundleId: ticket.worktree_bundle_id,
+                        progressionRunId: ownedReviewProgressionRunId,
+                        pauseCode: 'review',
+                        pauseReason: `Automation review fix follow-up failed: ${message}`,
+                        reasonCode: 'stage_failed',
+                        pausedStageRunId: executionContext.runId,
+                        broadcaster: asGenericEmitter(io),
+                    });
                 }
+                emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', ticket.id);
+                updateStatus(ticket.id, 'error', message, io);
             }
-            const transcriptRuns = getAgentErrorTranscriptRuns(error);
-            const errorContent = formatAgentErrorForTranscript(error);
-            if (errorContent) {
-                createTicketMessage({
-                    ticketId: ticket.id,
-                    role: 'assistant',
-                    kind: 'error',
-                    content: errorContent,
-                    transcriptRuns,
-                });
-            }
-            if (transcriptRuns) {
-                clearAndEmitAgentRunsForParent(io, 'ticket', ticket.id);
+            finally {
+                unregisterBundleActivity(ticket, activityKind);
             }
-            updateStatus(ticket.id, 'error', getErrorMessage(error), io);
-        }
-        finally {
-            unregisterBundleActivity(ticket, activityKind);
-        }
+        });
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        withExecutionRunTransaction(transaction => {
+            options.compensate?.();
+            transaction.transitionExecutionRun({
+                projectId: executionContext.projectId,
+                runId: executionContext.runId,
+                status: 'failed',
+                domainStatus: options.compensationDomainStatus ?? ticket.agent_status ?? 'idle',
+                failure: { code: 'queue_failed', message },
+                eventType: 'build_follow_up_failed',
+            });
+        }, asGenericEmitter(io));
+        return reject('queue_failed', message);
+    }
+    queuedJob.catch(() => {
+        // The queued callback owns domain and execution failure finalization.
     });
-    return true;
-};
+    return structuredResult ? { accepted: true, executionContext } : true;
+}
 //# sourceMappingURL=followUp.js.map