@straiffi/archon 1.7.2 → 1.7.4

package/dist/server/workers/build.js

@@ -1,9 +1,9 @@
 import db from '../db.js';
 import { formatAgentErrorForTranscript, getAgentErrorTranscriptRuns, runAgent, storeTicketUsageSnapshot, storeTicketUsageSnapshotDirect } from '../lib/agent.js';
-import { clearAndEmitAgentRunsForParent } from '../lib/agentRuns.js';
+import { createAgentRun, emitAgentRunsUpdated, getAgentRun, terminalizeAgentRunsForExecutionRun } from '../lib/agentRuns.js';
 import { advanceBuildChain } from '../lib/buildChains.js';
 import { listBuildOpenQuestionsForBundle, reconcileBuildOpenQuestions } from '../lib/buildOpenQuestions.js';
-import { stopBuildSequence } from '../lib/buildSequences.js';
+import { activateQueuedBuildSequenceTicket, getActiveBuildSequenceId, getBuildSequenceIdForTicket, stopBuildSequence } from '../lib/buildSequences.js';
 import { prepareTicketForBuild } from '../lib/buildFlow.js';
 import { createWorktreeAsync, deleteWorktree, resolveWorktreePath, syncWorktreeFilesAsync, worktreeExists } from '../lib/git.js';
 import config from '../lib/config.js';
@@ -13,6 +13,7 @@ import { getProjectMemorySuggestionPromptRules } from '../lib/projectMemorySugge
 import { ensureInitialCommitForWorktrees } from '../lib/projectRepos.js';
 import { getEffectiveProject } from '../lib/projects.js';
 import { enqueue, isRunning } from '../lib/queue.js';
+import { getExecutionRun, getQueuedBuildExecutionRun, transitionExecutionRun, withExecutionRunTransaction } from '../lib/executionRuns.js';
 import { runSetupCommandsInWorkspace } from '../lib/run.js';
 import { registerBundleActivity, unregisterBundleActivity } from '../lib/bundleActivity.js';
 import { beginTicketThinkingRun, bindTicketThinkingMessage } from '../lib/thinkingState.js';
@@ -23,9 +24,23 @@ import { captureStageBaseline, captureStageSuccess, clearStageSnapshot } from '.
 import { autoParkTicketIfStale, getTicket, listTickets, resolveTicketBranch, resolveTicketTool, resolveTicketWorkerKey } from '../lib/tickets.js';
 import { clearAutomationPause, depthAtLeast, getBundleAutomationState, recordAutomationPause, resolveAutomationConfig } from '../lib/ticketAutomation.js';
 import { transitionBundleToReview } from '../lib/bundleReviewOperations.js';
+import { completeAutomationProgression, ensureAutomationProgression, runAutomationProgression, waitAutomationProgression } from '../lib/automationProgression.js';
 const getErrorMessage = (error) => {
     return error instanceof Error ? error.message : String(error);
 };
+const asGenericEmitter = (io) => io;
+const defaultInitiation = {
+    initiator: 'user',
+    causalParentRunId: null,
+    retrySourceRunId: null,
+    workflowContext: null,
+};
+const emitTicketUpdate = (ticketId, io) => {
+    const updated = getTicket(ticketId);
+    if (updated) {
+        io.emit('ticket:updated', updated);
+    }
+};
 const slugify = (text) => text.replace(/[^a-zA-Z0-9\s-]/g, '').trim().replace(/\s+/g, '-').slice(0, 60);
 const branchName = (ticket) => slugify(ticket.title);
 const clearBuildCompletion = (ticketId) => {
@@ -88,11 +103,6 @@ const resumeBuildPrompt = (ticket, projectPath, memoryEnabled) => {
     const openQuestionsBlock = getBuildOpenQuestionsBlock(ticket);
     return prependSkillPromptBlock(`Working directory: ${projectPath}\n\nContinue implementing this build-stage ticket from the current session and worktree state. Do not restart from scratch, and keep any existing partial work unless you intentionally need to change it.\n\n<ticket>\n${ticket.description || ticket.title}\n</ticket>\n\n${projectMemory ? `${projectMemory}\n\n` : ''}${openQuestionsBlock ? `${openQuestionsBlock}\n\n` : ''}Continue the build from where it stopped in the current project worktree only. If the ticket references linked projects or other repositories, treat them as read-only context and do not modify them. Do NOT commit your changes.\n\n${OPEN_QUESTIONS_RESPONSE_RULES}${getProjectMemorySuggestionPromptRules(memoryEnabled, 'build') ? `\n\n${getProjectMemorySuggestionPromptRules(memoryEnabled, 'build')}` : ''}`, ticket.skills);
 };
-const scheduleBuildStart = (ticket, io) => {
-    setTimeout(() => {
-        startBuild(ticket, io);
-    }, 0);
-};
 const resolveTicketWorkspace = (ticket, project, branch) => {
     const bundle = ticket.worktree_bundle_id ? getTicket(ticket.id)?.bundle ?? null : null;
     if (bundle?.kind === 'project_root') {
@@ -107,215 +117,617 @@ const resolveTicketWorkspace = (ticket, project, branch) => {
     };
 };
 const startBuildJob = (ticket, io, options = {}) => {
-    const jobKey = resolveTicketWorkerKey(ticket, 'build');
-    if (!jobKey || isRunning(jobKey)) {
-        return;
+    const initiation = { ...defaultInitiation, ...options.initiation };
+    let acceptedTicket = ticket;
+    let sequenceId = options.sequenceId ?? null;
+    let compensateAcceptance;
+    let executionContext;
+    let jobKey = '';
+    let project;
+    let branch = '';
+    let tool;
+    let rejectionReason = 'invalid_context';
+    let ticketSnapshot;
+    try {
+        executionContext = withExecutionRunTransaction(transaction => {
+            const originalTicketSnapshot = ticket.project_id
+                ? db.prepare(`
+            SELECT state, tool, agent_status, agent_log, streaming_response, branch,
+              build_completed_at, run_setup_status, auto_park_dismissed_at,
+              planning_context_json, lane_order
+            FROM tickets
+            WHERE id = ? AND project_id = ?
+          `).get(ticket.id, ticket.project_id)
+                : undefined;
+            const acceptance = options.accept?.();
+            if (acceptance) {
+                acceptedTicket = acceptance.ticket;
+                sequenceId = acceptance.sequenceId ?? options.sequenceId ?? getActiveBuildSequenceId(acceptedTicket.id);
+                compensateAcceptance = acceptance.compensate;
+            }
+            sequenceId ??= getActiveBuildSequenceId(acceptedTicket.id);
+            jobKey = resolveTicketWorkerKey(acceptedTicket, 'build') ?? '';
+            if (!jobKey || isRunning(jobKey)) {
+                rejectionReason = 'busy';
+                throw new Error('Ticket build is already scheduled or running');
+            }
+            const acceptedProject = getEffectiveProject(acceptedTicket);
+            if (!acceptedProject || !acceptedTicket.project_id || acceptedProject.id !== acceptedTicket.project_id) {
+                rejectionReason = 'project_unavailable';
+                throw new Error('Ticket project is unavailable');
+            }
+            project = acceptedProject;
+            branch = resolveTicketBranch(acceptedTicket) ?? branchName(acceptedTicket);
+            ticketSnapshot = acceptedTicket.id === ticket.id
+                ? originalTicketSnapshot
+                : db.prepare(`
+            SELECT state, tool, agent_status, agent_log, streaming_response, branch,
+              build_completed_at, run_setup_status, auto_park_dismissed_at,
+              planning_context_json, lane_order
+            FROM tickets
+            WHERE id = ? AND project_id = ?
+          `).get(acceptedTicket.id, project.id);
+            tool = resolveTicketTool(acceptedTicket, config.tool ?? 'opencode');
+            clearBuildCompletion(acceptedTicket.id);
+            if (!acceptedTicket.worktree_bundle_id) {
+                db.prepare('UPDATE tickets SET branch = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(branch, acceptedTicket.id);
+            }
+            const queuedExecutionRun = sequenceId
+                ? getQueuedBuildExecutionRun(project.id, acceptedTicket.id, sequenceId)
+                : null;
+            const executionRun = queuedExecutionRun ?? transaction.createExecutionRun({
+                projectId: project.id,
+                kind: 'build',
+                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' }]
+                        : []),
+                    ...(sequenceId
+                        ? [{ entityType: 'build_sequence', entityId: sequenceId, relationship: 'context' }]
+                        : []),
+                ],
+                initiatedBy: initiation.initiator,
+                parentRunId: initiation.causalParentRunId,
+                retryOfRunId: initiation.retrySourceRunId,
+                metadata: initiation.workflowContext,
+                eventType: initiation.retrySourceRunId ? 'retry_started' : 'build_created',
+            });
+            return {
+                runId: executionRun.id,
+                correlationId: executionRun.correlation_id,
+                projectId: executionRun.project_id,
+                kind: executionRun.kind,
+            };
+        }, io);
     }
-    clearBuildCompletion(ticket.id);
-    const branch = resolveTicketBranch(ticket) ?? branchName(ticket);
-    const tool = resolveTicketTool(ticket, config.tool ?? 'opencode');
-    if (!ticket.worktree_bundle_id) {
-        db.prepare('UPDATE tickets SET branch = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(branch, ticket.id);
+    catch (error) {
+        return { accepted: false, reason: rejectionReason, error: getErrorMessage(error) };
     }
-    enqueue(jobKey, async () => {
-        registerBundleActivity(ticket, 'build');
-        try {
-            beginTicketThinkingRun(ticket.id);
-            const project = getEffectiveProject(ticket);
-            if (!project) {
-                throw new Error('Ticket project no longer exists');
-            }
-            const workspace = resolveTicketWorkspace(ticket, project, branch);
-            const shouldCreateWorktree = workspace.shouldCreateWorktree;
-            updateStatus(ticket.id, 'running', shouldCreateWorktree ? 'Preparing worktree...' : 'Preparing build workspace...', io);
-            if (shouldCreateWorktree) {
-                let setupCompleted = false;
-                updateRunSetupStatus(ticket.id, 'preparing', io);
-                try {
-                    ensureInitialCommitForWorktrees(project.repo_path);
-                    await createWorktreeAsync(branch, project);
-                    updateStatus(ticket.id, 'running', 'Syncing worktree files...', io);
-                    await syncWorktreeFilesAsync(branch, project);
-                    updateStatus(ticket.id, 'running', 'Running setup commands...', io);
-                    await runSetupCommandsInWorkspace(project, workspace.cwd);
-                    updateRunSetupStatus(ticket.id, 'ready', io);
-                    setupCompleted = true;
+    let queuedJob;
+    try {
+        queuedJob = enqueue(jobKey, async () => {
+            let activityRegistered = false;
+            try {
+                registerBundleActivity(acceptedTicket, 'build');
+                activityRegistered = true;
+                withExecutionRunTransaction(transaction => {
+                    db.prepare('UPDATE tickets SET agent_status = ?, agent_log = ?, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND project_id = ?').run('running', 'Preparing build workspace...', acceptedTicket.id, executionContext.projectId);
+                    const currentTicket = getTicket(acceptedTicket.id);
+                    if (!currentTicket || currentTicket.project_id !== executionContext.projectId) {
+                        throw new Error('Ticket no longer exists in the execution project');
+                    }
+                    transaction.transitionExecutionRun({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        status: 'running',
+                        domainStatus: 'running',
+                        eventType: 'build_started',
+                    });
+                }, io);
+                if (acceptedTicket.worktree_bundle_id) {
+                    markTicketDescriptionVisibleInBundle(acceptedTicket.id);
                 }
-                finally {
-                    if (!setupCompleted) {
-                        updateRunSetupStatus(ticket.id, null, io);
-                        deleteWorktree(branch, project);
+                emitTicketUpdate(acceptedTicket.id, io);
+                beginTicketThinkingRun(acceptedTicket.id);
+                const mainRunId = createAgentRun({
+                    executionRunId: executionContext.runId,
+                    parentType: 'ticket',
+                    parentId: acceptedTicket.id,
+                    label: options.resume ? 'Build continuation' : 'Build',
+                    role: 'main',
+                });
+                const mainRun = getAgentRun(mainRunId);
+                if (!mainRun) {
+                    throw new Error('Unable to create the Build agent run');
+                }
+                emitAgentRunsUpdated(io, 'ticket', acceptedTicket.id);
+                const currentProject = getEffectiveProject(acceptedTicket);
+                if (!currentProject || currentProject.id !== executionContext.projectId) {
+                    throw new Error('Ticket project no longer exists');
+                }
+                const workspace = resolveTicketWorkspace(acceptedTicket, currentProject, branch);
+                const shouldCreateWorktree = workspace.shouldCreateWorktree;
+                updateStatus(acceptedTicket.id, 'running', shouldCreateWorktree ? 'Preparing worktree...' : 'Preparing build workspace...', io);
+                if (shouldCreateWorktree) {
+                    let setupCompleted = false;
+                    updateRunSetupStatus(acceptedTicket.id, 'preparing', io);
+                    try {
+                        ensureInitialCommitForWorktrees(currentProject.repo_path);
+                        await createWorktreeAsync(branch, currentProject);
+                        updateStatus(acceptedTicket.id, 'running', 'Syncing worktree files...', io);
+                        await syncWorktreeFilesAsync(branch, currentProject);
+                        updateStatus(acceptedTicket.id, 'running', 'Running setup commands...', io);
+                        await runSetupCommandsInWorkspace(currentProject, workspace.cwd);
+                        updateRunSetupStatus(acceptedTicket.id, 'ready', io);
+                        setupCompleted = true;
+                    }
+                    finally {
+                        if (!setupCompleted) {
+                            updateRunSetupStatus(acceptedTicket.id, null, io);
+                            deleteWorktree(branch, currentProject);
+                        }
                     }
                 }
-            }
-            else {
-                updateRunSetupStatus(ticket.id, 'ready', io);
-            }
-            updateStatus(ticket.id, 'running', 'Saving build baseline...', io);
-            await captureStageBaseline(ticket.id, 'build');
-            const cwd = workspace.cwd;
-            const { response: finalResponse, responseTiming, usageSnapshot, transcriptRuns } = await runAgent({
-                ticketId: ticket.id,
-                tool,
-                prompt: options.resume ? resumeBuildPrompt(ticket, cwd, Boolean(project.memory_enabled)) : buildPrompt(ticket, cwd, Boolean(project.memory_enabled)),
-                cwd,
-                model: ticket.model,
-                variant: ticket.variant,
-                resumeSessionId: options.resume ? ticket.session_id : null,
-                trackBuildProcess: true,
-                emitSuccessUpdate: false,
-                io,
-            });
-            const parsedBuildOutput = typeof finalResponse === 'string'
-                ? parseAgentResponseWithOpenQuestions(finalResponse)
-                : { response: '', openQuestions: [], hasOpenQuestionsMetadata: false, suggestions: [] };
-            const assistantMessage = formatAssistantMessageWithOpenQuestions({
-                response: parsedBuildOutput.response,
-                openQuestions: parsedBuildOutput.openQuestions,
-            });
-            let assistantMessageId = null;
-            if (assistantMessage) {
-                assistantMessageId = createTicketMessage({
-                    ticketId: ticket.id,
-                    role: 'assistant',
-                    kind: 'final_response',
-                    content: assistantMessage,
-                    responseTiming,
-                    transcriptRuns,
+                else {
+                    updateRunSetupStatus(acceptedTicket.id, 'ready', io);
+                }
+                updateStatus(acceptedTicket.id, 'running', 'Saving build baseline...', io);
+                await captureStageBaseline(acceptedTicket.id, 'build');
+                const cwd = workspace.cwd;
+                const { response: finalResponse, responseTiming, usageSnapshot, transcriptRuns } = await runAgent({
+                    ticketId: acceptedTicket.id,
+                    tool,
+                    prompt: options.resume ? resumeBuildPrompt(acceptedTicket, cwd, Boolean(currentProject.memory_enabled)) : buildPrompt(acceptedTicket, cwd, Boolean(currentProject.memory_enabled)),
+                    cwd,
+                    model: acceptedTicket.model,
+                    variant: acceptedTicket.variant,
+                    resumeSessionId: options.resume ? acceptedTicket.session_id : null,
+                    trackBuildProcess: true,
+                    emitSuccessUpdate: false,
+                    executionContext,
+                    persistSessionIdToTicket: true,
+                    runStream: {
+                        runId: mainRun.id,
+                        label: mainRun.label,
+                        role: mainRun.role,
+                        runIndex: mainRun.run_index,
+                    },
+                    io,
+                });
+                const completedMainRun = getAgentRun(mainRun.id);
+                const completionStatus = completedMainRun?.agent_status === 'stopped' ? 'stopped' : 'done';
+                const parsedBuildOutput = typeof finalResponse === 'string'
+                    ? parseAgentResponseWithOpenQuestions(finalResponse)
+                    : { response: '', openQuestions: [], hasOpenQuestionsMetadata: false, suggestions: [] };
+                const assistantMessage = formatAssistantMessageWithOpenQuestions({
+                    response: parsedBuildOutput.response,
+                    openQuestions: parsedBuildOutput.openQuestions,
                 });
+                const assistantMessageId = withExecutionRunTransaction(transaction => {
+                    const messageId = assistantMessage
+                        ? createTicketMessage({
+                            ticketId: acceptedTicket.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, acceptedTicket.id, executionContext.projectId);
+                    const completedTicket = getTicket(acceptedTicket.id) ?? acceptedTicket;
+                    if (completionStatus === 'done') {
+                        markBuildCompleted(acceptedTicket.id);
+                        if (parsedBuildOutput.hasOpenQuestionsMetadata) {
+                            db.prepare('UPDATE tickets SET planning_context_json = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(JSON.stringify(createTicketOpenQuestionsContext(completedTicket, parsedBuildOutput.openQuestions)), acceptedTicket.id);
+                            if (acceptedTicket.project_id && acceptedTicket.worktree_bundle_id) {
+                                reconcileBuildOpenQuestions({
+                                    projectId: acceptedTicket.project_id,
+                                    bundleId: acceptedTicket.worktree_bundle_id,
+                                    ticketId: acceptedTicket.id,
+                                    questions: parsedBuildOutput.openQuestions,
+                                    sourceKey: `build:${acceptedTicket.id}:${messageId ?? completedTicket.updated_at}`,
+                                });
+                            }
+                        }
+                    }
+                    if (messageId) {
+                        transaction.addExecutionRunLink({
+                            projectId: executionContext.projectId,
+                            runId: executionContext.runId,
+                            link: {
+                                entityType: 'ticket_message',
+                                entityId: messageId,
+                                relationship: 'result',
+                                expectedParent: { entityType: 'ticket', entityId: acceptedTicket.id },
+                            },
+                        });
+                    }
+                    terminalizeAgentRunsForExecutionRun(executionContext.runId, completionStatus, null);
+                    transaction.transitionExecutionRun({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        status: completionStatus === 'stopped' ? 'cancelled' : 'completed',
+                        domainStatus: completionStatus,
+                        eventType: completionStatus === 'stopped' ? 'build_cancelled' : 'build_completed',
+                    });
+                    return messageId;
+                }, io);
                 if (assistantMessageId) {
-                    bindTicketThinkingMessage(ticket.id, assistantMessageId);
+                    bindTicketThinkingMessage(acceptedTicket.id, assistantMessageId);
                 }
-            }
-            if (transcriptRuns) {
-                clearAndEmitAgentRunsForParent(io, 'ticket', ticket.id);
-            }
-            const completedTicket = getTicket(ticket.id) ?? ticket;
-            if (completedTicket.agent_status === 'done' && parsedBuildOutput.hasOpenQuestionsMetadata) {
-                db.prepare('UPDATE tickets SET planning_context_json = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(JSON.stringify(createTicketOpenQuestionsContext(completedTicket, parsedBuildOutput.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: parsedBuildOutput.openQuestions,
-                        sourceKey: `build:${ticket.id}:${assistantMessageId ?? completedTicket.updated_at}`,
-                    });
-                    const openQuestions = 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);
+                emitTicketUpdate(acceptedTicket.id, io);
+                const completedTicket = getTicket(acceptedTicket.id) ?? acceptedTicket;
+                if (completionStatus === 'done'
+                    && parsedBuildOutput.hasOpenQuestionsMetadata
+                    && acceptedTicket.project_id
+                    && acceptedTicket.worktree_bundle_id) {
+                    const openQuestions = listBuildOpenQuestionsForBundle(acceptedTicket.project_id, acceptedTicket.worktree_bundle_id);
+                    const liveProject = getEffectiveProject(completedTicket) ?? project;
+                    const automationConfig = resolveAutomationConfig(completedTicket.bundle ?? null, liveProject);
+                    const bundleState = getBundleAutomationState(acceptedTicket.project_id, acceptedTicket.worktree_bundle_id);
                     const shouldPauseForOpenQuestions = (openQuestions.length > 0
                         && automationConfig.pauseOnOpenQuestions
                         && depthAtLeast(automationConfig.depth, 'auto_review'));
                     if (shouldPauseForOpenQuestions) {
-                        recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', `${openQuestions.length} unresolved Build open question${openQuestions.length === 1 ? '' : 's'}`);
+                        const progression = ensureAutomationProgression({
+                            projectId: acceptedTicket.project_id,
+                            bundleId: acceptedTicket.worktree_bundle_id,
+                            ticketId: acceptedTicket.id,
+                            ticketTitle: acceptedTicket.title,
+                            parentRunId: executionContext.runId,
+                            workflowContext: initiation.workflowContext,
+                            broadcaster: asGenericEmitter(io),
+                        });
+                        waitAutomationProgression({
+                            projectId: acceptedTicket.project_id,
+                            bundleId: acceptedTicket.worktree_bundle_id,
+                            progressionRunId: progression.runId,
+                            pauseCode: 'open_questions',
+                            pauseReason: `${openQuestions.length} unresolved Build open question${openQuestions.length === 1 ? '' : 's'}`,
+                            reasonCode: 'precondition_failed',
+                            pausedStageRunId: executionContext.runId,
+                            broadcaster: asGenericEmitter(io),
+                        });
                     }
                     else if (bundleState?.automation_paused_code === 'open_questions') {
-                        clearAutomationPause(ticket.project_id, ticket.worktree_bundle_id);
+                        if (!depthAtLeast(automationConfig.depth, 'auto_review') && bundleState.automation_progression_run_id) {
+                            completeAutomationProgression({
+                                projectId: acceptedTicket.project_id,
+                                bundleId: acceptedTicket.worktree_bundle_id,
+                                progressionRunId: bundleState.automation_progression_run_id,
+                                domainStatus: 'manual_boundary_reached',
+                                broadcaster: asGenericEmitter(io),
+                            });
+                        }
+                        else if (bundleState.automation_progression_run_id) {
+                            runAutomationProgression({
+                                projectId: acceptedTicket.project_id,
+                                bundleId: acceptedTicket.worktree_bundle_id,
+                                progressionRunId: bundleState.automation_progression_run_id,
+                                broadcaster: asGenericEmitter(io),
+                            });
+                        }
+                        else {
+                            clearAutomationPause(acceptedTicket.project_id, acceptedTicket.worktree_bundle_id);
+                        }
                     }
-                    emitUpdatedTickets(listTickets(ticket.project_id)
-                        .filter(bundleTicket => bundleTicket.worktree_bundle_id === ticket.worktree_bundle_id)
+                    emitUpdatedTickets(listTickets(acceptedTicket.project_id)
+                        .filter(bundleTicket => bundleTicket.worktree_bundle_id === acceptedTicket.worktree_bundle_id)
                         .map(bundleTicket => bundleTicket.id), io);
                 }
-            }
-            clearTicketStreamingResponse(ticket.id);
-            const freshTicket = getTicket(ticket.id);
-            if (freshTicket?.tool === 'opencode' && freshTicket.session_id) {
-                storeTicketUsageSnapshot(freshTicket.id, freshTicket.session_id);
-            }
-            else if (freshTicket?.tool === 'claude' && usageSnapshot) {
-                storeTicketUsageSnapshotDirect(freshTicket.id, usageSnapshot);
-            }
-            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 && parsedBuildOutput.suggestions.length > 0) {
-                    persistProjectMemorySuggestions(project.id, ticket.id, 'build', parsedBuildOutput.suggestions);
+                const freshTicket = getTicket(acceptedTicket.id);
+                if (freshTicket?.tool === 'opencode' && freshTicket.session_id) {
+                    storeTicketUsageSnapshot(freshTicket.id, freshTicket.session_id);
                 }
-                markBuildCompleted(ticket.id);
-                clearStageSnapshot(ticket.id, 'review');
-                captureStageSuccess(ticket.id, 'build');
-                const completed = autoParkTicketIfStale(ticket.id);
-                if (completed) {
-                    io.emit('ticket:updated', completed);
+                else if (freshTicket?.tool === 'claude' && usageSnapshot) {
+                    storeTicketUsageSnapshotDirect(freshTicket.id, usageSnapshot);
                 }
-            }
-            const nextAgentStatus = getTicket(ticket.id)?.agent_status ?? updated?.agent_status ?? null;
-            if (nextAgentStatus !== 'stopped') {
-                const buildChainAdvance = advanceBuildChain(ticket.id, nextAgentStatus);
-                emitUpdatedTickets(buildChainAdvance.affectedTicketIds, io);
-                if (buildChainAdvance.nextTicketId) {
-                    const nextBuild = prepareTicketForBuild(buildChainAdvance.nextTicketId, {
-                        ignoredBlockerTicketIds: buildChainAdvance.ignoredBlockerTicketIds,
-                    });
-                    if (!nextBuild.ok) {
-                        const stoppedChain = stopBuildSequence(buildChainAdvance.nextTicketId);
-                        emitUpdatedTickets(stoppedChain.affectedTicketIds, io);
-                        return;
+                const completedWithMessage = getTicket(acceptedTicket.id);
+                if (completedWithMessage) {
+                    io.emit('ticket:updated', completedWithMessage);
+                }
+                const updated = getTicket(acceptedTicket.id);
+                if (updated?.agent_status === 'done') {
+                    if (project.memory_enabled && parsedBuildOutput.suggestions.length > 0) {
+                        persistProjectMemorySuggestions(project.id, acceptedTicket.id, 'build', parsedBuildOutput.suggestions);
                     }
-                    io.emit('ticket:updated', nextBuild.ticket);
-                    if (resolveTicketWorkerKey(nextBuild.ticket, 'build') === jobKey) {
-                        scheduleBuildStart(nextBuild.ticket, io);
-                        return;
+                    clearStageSnapshot(acceptedTicket.id, 'review');
+                    captureStageSuccess(acceptedTicket.id, 'build');
+                    const completed = autoParkTicketIfStale(acceptedTicket.id);
+                    if (completed) {
+                        io.emit('ticket:updated', completed);
                     }
-                    startBuild(nextBuild.ticket, io);
                 }
-                else if (updated?.agent_status === 'done' && ticket.project_id && ticket.worktree_bundle_id) {
-                    const automationConfig = resolveAutomationConfig(updated?.bundle ?? null, project);
-                    const autoReviewEnabled = depthAtLeast(automationConfig.depth, 'auto_review');
-                    const bundleState = getBundleAutomationState(ticket.project_id, ticket.worktree_bundle_id);
-                    const openQuestions = listBuildOpenQuestionsForBundle(ticket.project_id, ticket.worktree_bundle_id);
-                    const shouldPauseForOpenQuestions = autoReviewEnabled
-                        && automationConfig.pauseOnOpenQuestions
-                        && openQuestions.length > 0;
-                    if (shouldPauseForOpenQuestions) {
-                        recordAutomationPause(ticket.project_id, ticket.worktree_bundle_id, 'open_questions', `${openQuestions.length} unresolved Build open question${openQuestions.length === 1 ? '' : 's'}`);
-                        emitUpdatedTickets(listTickets(ticket.project_id)
-                            .filter(bundleTicket => bundleTicket.worktree_bundle_id === ticket.worktree_bundle_id)
-                            .map(bundleTicket => bundleTicket.id), io);
+                const nextAgentStatus = getTicket(acceptedTicket.id)?.agent_status ?? updated?.agent_status ?? null;
+                let nextBuild = null;
+                let nextBuildIgnoredBlockerTicketIds = [];
+                if (nextAgentStatus !== 'stopped') {
+                    const buildChainAdvance = advanceBuildChain(acceptedTicket.id, nextAgentStatus);
+                    emitUpdatedTickets(buildChainAdvance.affectedTicketIds, io);
+                    if (buildChainAdvance.nextTicketId) {
+                        const nextBuildValidation = prepareTicketForBuild(buildChainAdvance.nextTicketId, {
+                            ignoredBlockerTicketIds: buildChainAdvance.ignoredBlockerTicketIds,
+                            updateState: false,
+                        });
+                        if (!nextBuildValidation.ok) {
+                            const stoppedChain = stopBuildSequence(buildChainAdvance.nextTicketId);
+                            emitUpdatedTickets(stoppedChain.affectedTicketIds, io);
+                        }
+                        else {
+                            nextBuild = nextBuildValidation.ticket;
+                            nextBuildIgnoredBlockerTicketIds = buildChainAdvance.ignoredBlockerTicketIds;
+                        }
                     }
-                    else {
-                        if (bundleState?.automation_paused_code === 'open_questions') {
-                            clearAutomationPause(ticket.project_id, ticket.worktree_bundle_id);
+                    else if (updated?.agent_status === 'done' && acceptedTicket.project_id && acceptedTicket.worktree_bundle_id) {
+                        const liveProject = getEffectiveProject(updated) ?? project;
+                        const automationConfig = resolveAutomationConfig(updated?.bundle ?? null, liveProject);
+                        const autoReviewEnabled = depthAtLeast(automationConfig.depth, 'auto_review');
+                        const bundleState = getBundleAutomationState(acceptedTicket.project_id, acceptedTicket.worktree_bundle_id);
+                        const openQuestions = listBuildOpenQuestionsForBundle(acceptedTicket.project_id, acceptedTicket.worktree_bundle_id);
+                        const shouldPauseForOpenQuestions = autoReviewEnabled
+                            && automationConfig.pauseOnOpenQuestions
+                            && openQuestions.length > 0;
+                        if (shouldPauseForOpenQuestions) {
+                            const progression = ensureAutomationProgression({
+                                projectId: acceptedTicket.project_id,
+                                bundleId: acceptedTicket.worktree_bundle_id,
+                                ticketId: acceptedTicket.id,
+                                ticketTitle: acceptedTicket.title,
+                                parentRunId: executionContext.runId,
+                                workflowContext: initiation.workflowContext,
+                                broadcaster: asGenericEmitter(io),
+                            });
+                            waitAutomationProgression({
+                                projectId: acceptedTicket.project_id,
+                                bundleId: acceptedTicket.worktree_bundle_id,
+                                progressionRunId: progression.runId,
+                                pauseCode: 'open_questions',
+                                pauseReason: `${openQuestions.length} unresolved Build open question${openQuestions.length === 1 ? '' : 's'}`,
+                                reasonCode: 'precondition_failed',
+                                pausedStageRunId: executionContext.runId,
+                                broadcaster: asGenericEmitter(io),
+                            });
+                            emitUpdatedTickets(listTickets(acceptedTicket.project_id)
+                                .filter(bundleTicket => bundleTicket.worktree_bundle_id === acceptedTicket.worktree_bundle_id)
+                                .map(bundleTicket => bundleTicket.id), io);
                         }
-                        if (autoReviewEnabled && (!bundleState?.automation_paused_reason || bundleState.automation_paused_code === 'open_questions')) {
-                            transitionBundleToReview(ticket.project_id, ticket.worktree_bundle_id, io, { automatic: true });
+                        else {
+                            if (bundleState?.automation_paused_code === 'open_questions') {
+                                if (!autoReviewEnabled && bundleState.automation_progression_run_id) {
+                                    completeAutomationProgression({
+                                        projectId: acceptedTicket.project_id,
+                                        bundleId: acceptedTicket.worktree_bundle_id,
+                                        progressionRunId: bundleState.automation_progression_run_id,
+                                        domainStatus: 'manual_boundary_reached',
+                                        broadcaster: asGenericEmitter(io),
+                                    });
+                                }
+                                else if (bundleState.automation_progression_run_id) {
+                                    runAutomationProgression({
+                                        projectId: acceptedTicket.project_id,
+                                        bundleId: acceptedTicket.worktree_bundle_id,
+                                        progressionRunId: bundleState.automation_progression_run_id,
+                                        broadcaster: asGenericEmitter(io),
+                                    });
+                                }
+                                else {
+                                    clearAutomationPause(acceptedTicket.project_id, acceptedTicket.worktree_bundle_id);
+                                }
+                            }
+                            if (autoReviewEnabled && (!bundleState?.automation_paused_reason || bundleState.automation_paused_code === 'open_questions')) {
+                                const progression = ensureAutomationProgression({
+                                    projectId: acceptedTicket.project_id,
+                                    bundleId: acceptedTicket.worktree_bundle_id,
+                                    ticketId: acceptedTicket.id,
+                                    ticketTitle: acceptedTicket.title,
+                                    parentRunId: executionContext.runId,
+                                    workflowContext: initiation.workflowContext,
+                                    broadcaster: asGenericEmitter(io),
+                                });
+                                if (getBundleAutomationState(acceptedTicket.project_id, acceptedTicket.worktree_bundle_id)?.automation_paused_code === 'open_questions') {
+                                    runAutomationProgression({
+                                        projectId: acceptedTicket.project_id,
+                                        bundleId: acceptedTicket.worktree_bundle_id,
+                                        progressionRunId: progression.runId,
+                                        broadcaster: asGenericEmitter(io),
+                                    });
+                                }
+                                const reviewResult = transitionBundleToReview(acceptedTicket.project_id, acceptedTicket.worktree_bundle_id, io, {
+                                    automatic: true,
+                                    initiation: {
+                                        causalParentRunId: progression.runId,
+                                        workflowContext: initiation.workflowContext,
+                                    },
+                                });
+                                if (!reviewResult.ok) {
+                                    waitAutomationProgression({
+                                        projectId: acceptedTicket.project_id,
+                                        bundleId: acceptedTicket.worktree_bundle_id,
+                                        progressionRunId: progression.runId,
+                                        pauseCode: 'review',
+                                        pauseReason: reviewResult.error,
+                                        reasonCode: 'stage_failed',
+                                        pausedStageRunId: executionContext.runId,
+                                        broadcaster: asGenericEmitter(io),
+                                    });
+                                }
+                            }
                         }
                     }
                 }
+                if (nextBuild) {
+                    const nextSequenceId = sequenceId ?? getBuildSequenceIdForTicket(nextBuild.id);
+                    const nextOptions = {
+                        initiation: {
+                            initiator: 'automation',
+                            causalParentRunId: executionContext.runId,
+                            workflowContext: initiation.workflowContext,
+                        },
+                        sequenceId: nextSequenceId,
+                        accept: () => {
+                            const transition = prepareTicketForBuild(nextBuild.id, {
+                                ignoredBlockerTicketIds: nextBuildIgnoredBlockerTicketIds,
+                            });
+                            if (!transition.ok) {
+                                throw new Error(transition.error);
+                            }
+                            if (!nextSequenceId) {
+                                throw new Error('Build sequence no longer exists');
+                            }
+                            activateQueuedBuildSequenceTicket(nextSequenceId, transition.ticket.id);
+                            return {
+                                ticket: transition.ticket,
+                                sequenceId: nextSequenceId,
+                                compensate: () => {
+                                    db.prepare(`
+                  UPDATE build_sequence_tickets SET status = 'queued', started_at = NULL
+                  WHERE build_sequence_id = ? AND ticket_id = ? AND status = 'active'
+                `).run(nextSequenceId, transition.ticket.id);
+                                },
+                            };
+                        },
+                    };
+                    const scheduleNextBuild = () => {
+                        const scheduling = startBuild(nextBuild, io, nextOptions);
+                        if (!scheduling.accepted) {
+                            if (scheduling.reason === 'busy') {
+                                setTimeout(scheduleNextBuild, 0);
+                                return;
+                            }
+                            const stoppedSequence = stopBuildSequence(nextBuild.id);
+                            emitUpdatedTickets(stoppedSequence.affectedTicketIds, io);
+                        }
+                    };
+                    if (resolveTicketWorkerKey(nextBuild, 'build') === jobKey) {
+                        queuedJob.finally(scheduleNextBuild).catch(() => { });
+                    }
+                    else {
+                        scheduleNextBuild();
+                    }
+                }
             }
-        }
-        catch (err) {
-            const transcriptRuns = getAgentErrorTranscriptRuns(err);
-            const errorContent = formatAgentErrorForTranscript(err);
-            if (errorContent) {
-                createTicketMessage({
-                    ticketId: ticket.id,
-                    role: 'assistant',
-                    kind: 'error',
-                    content: errorContent,
-                    transcriptRuns,
-                });
-            }
-            if (transcriptRuns) {
-                clearAndEmitAgentRunsForParent(io, 'ticket', ticket.id);
+            catch (err) {
+                const executionRun = getExecutionRun(executionContext.projectId, executionContext.runId);
+                if (executionRun && !['queued', 'running', 'waiting'].includes(executionRun.status)) {
+                    if (acceptedTicket.project_id && acceptedTicket.worktree_bundle_id) {
+                        recordAutomationPause(acceptedTicket.project_id, acceptedTicket.worktree_bundle_id, 'review', `Build completed but automation could not continue: ${getErrorMessage(err)}`);
+                        emitUpdatedTickets(listTickets(acceptedTicket.project_id)
+                            .filter(bundleTicket => bundleTicket.worktree_bundle_id === acceptedTicket.worktree_bundle_id)
+                            .map(bundleTicket => bundleTicket.id), io);
+                    }
+                    return;
+                }
+                const transcriptRuns = getAgentErrorTranscriptRuns(err);
+                const errorContent = formatAgentErrorForTranscript(err);
+                const message = getErrorMessage(err);
+                let affectedTicketIds = [];
+                try {
+                    withExecutionRunTransaction(transaction => {
+                        if (errorContent) {
+                            const messageId = createTicketMessage({
+                                ticketId: acceptedTicket.id,
+                                role: 'assistant',
+                                kind: 'error',
+                                content: errorContent,
+                                transcriptRuns,
+                            });
+                            if (messageId) {
+                                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);
+                        const buildChainAdvance = advanceBuildChain(acceptedTicket.id, 'error');
+                        affectedTicketIds = buildChainAdvance.affectedTicketIds;
+                        transaction.transitionExecutionRun({
+                            projectId: executionContext.projectId,
+                            runId: executionContext.runId,
+                            status: 'failed',
+                            domainStatus: 'error',
+                            failure: { code: 'build_failed', message },
+                            eventType: 'build_failed',
+                        });
+                    }, io);
+                }
+                catch {
+                    terminalizeAgentRunsForExecutionRun(executionContext.runId, 'error', message);
+                    transitionExecutionRun({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        status: 'failed',
+                        domainStatus: 'error',
+                        failure: { code: 'build_failed', message },
+                        eventType: 'build_failed',
+                    }, io);
+                }
+                const updated = getTicket(acceptedTicket.id);
+                if (updated) {
+                    io.emit('ticket:updated', updated);
+                }
+                emitUpdatedTickets(affectedTicketIds, io);
             }
-            db.prepare('UPDATE tickets SET agent_status = ?, agent_log = ?, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run('error', getErrorMessage(err), ticket.id);
-            const updated = getTicket(ticket.id);
-            if (updated) {
-                io.emit('ticket:updated', updated);
+            finally {
+                if (activityRegistered) {
+                    unregisterBundleActivity(acceptedTicket, 'build');
+                }
             }
-            const buildChainAdvance = advanceBuildChain(ticket.id, 'error');
-            emitUpdatedTickets(buildChainAdvance.affectedTicketIds, io);
+        });
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        try {
+            withExecutionRunTransaction(transaction => {
+                if (ticketSnapshot) {
+                    db.prepare(`
+            UPDATE tickets
+            SET state = ?, tool = ?, agent_status = ?, agent_log = ?, streaming_response = ?, branch = ?,
+              build_completed_at = ?, run_setup_status = ?, auto_park_dismissed_at = ?,
+              planning_context_json = ?, lane_order = ?, updated_at = CURRENT_TIMESTAMP
+            WHERE id = ? AND project_id = ?
+          `).run(ticketSnapshot.state, ticketSnapshot.tool, ticketSnapshot.agent_status, ticketSnapshot.agent_log, ticketSnapshot.streaming_response, ticketSnapshot.branch, ticketSnapshot.build_completed_at, ticketSnapshot.run_setup_status, ticketSnapshot.auto_park_dismissed_at, ticketSnapshot.planning_context_json, ticketSnapshot.lane_order, acceptedTicket.id, project.id);
+                }
+                compensateAcceptance?.();
+                options.compensate?.();
+                transaction.transitionExecutionRun({
+                    projectId: executionContext.projectId,
+                    runId: executionContext.runId,
+                    status: 'failed',
+                    domainStatus: acceptedTicket.agent_status ?? 'idle',
+                    failure: { code: 'queue_failed', message },
+                    eventType: 'build_failed',
+                });
+            }, io);
         }
-        finally {
-            unregisterBundleActivity(ticket, 'build');
+        catch {
+            // Keep the durable failed attempt even when domain compensation can no longer apply.
+            transitionExecutionRun({
+                projectId: executionContext.projectId,
+                runId: executionContext.runId,
+                status: 'failed',
+                domainStatus: acceptedTicket.agent_status ?? 'idle',
+                failure: { code: 'queue_failed', message },
+                eventType: 'build_failed',
+            }, io);
         }
+        return { accepted: false, reason: 'queue_failed', error: message };
+    }
+    queuedJob.catch(() => {
+        // The queued callback owns domain and execution failure finalization.
     });
+    return { accepted: true, executionContext };
 };
-export const startBuild = (ticket, io) => startBuildJob(ticket, io);
-export const resumeBuild = (ticket, io) => startBuildJob(ticket, io, { resume: true });
+export const startBuild = (ticket, io, options = {}) => startBuildJob(ticket, io, options);
+export const resumeBuild = (ticket, io, options = {}) => startBuildJob(ticket, io, { ...options, resume: true });
 //# sourceMappingURL=build.js.map