@straiffi/archon 1.8.8 → 1.8.9

package/dist/server/workers/followUp.js

@@ -1,7 +1,8 @@
 import db from '../db.js';
-import { formatAgentErrorForTranscript, getAgentErrorTranscriptRuns, runAgent } from '../lib/agent.js';
+import { formatAgentErrorForTranscript, getAgentErrorTranscriptRuns, isAgentContinuationRejectedError, registerBuildProcessPlaceholder, runAgent, untrackBuildProcessById } from '../lib/agent.js';
+import { acquireAgentSpawnPermit } from '../lib/agentSpawnPermits.js';
 import { createAgentRun, emitAgentRunsUpdated, getAgentRun, terminalizeAgentRunsForExecutionRun } from '../lib/agentRuns.js';
-import { getExecutionRun, withExecutionRunTransaction } from '../lib/executionRuns.js';
+import { appendLifecycleEvent, getExecutionRun, withExecutionRunTransaction } from '../lib/executionRuns.js';
 import config from '../lib/config.js';
 import { failBuildOpenQuestionBatch, filterResolvedBuildOpenQuestionsForBatch, listBuildOpenQuestionsForBundle, reconcileBuildOpenQuestions, setBuildOpenQuestionBatchStatus, } from '../lib/buildOpenQuestions.js';
 import { advanceBuildChain } from '../lib/buildChains.js';
@@ -24,6 +25,7 @@ import { getRequiredCheckPolicyPromptBlock } from '../lib/requiredCheckPolicyPro
 import { clearTicketStreamingResponse, createTicketMessage, markTicketDescriptionVisibleInBundle, } from '../lib/ticketMessages.js';
 import { captureStageSuccess } from '../lib/ticketUndo.js';
 import { runPostBuildChecks } from '../lib/postBuildChecks.js';
+import { finalizePostBuildCheckTicket, markPostBuildCheckFinalizationComplete, persistPendingPostBuildFinalization } from '../lib/postBuildCheckRuns.js';
 import { beginTicketThinkingRun, bindTicketThinkingMessage } from '../lib/thinkingState.js';
 import { autoParkTicketIfStale, getTicket, listTickets, resolveTicketBranch, resolveTicketContextKey, resolveTicketTool, resolveTicketWorkerKey } from '../lib/tickets.js';
 import { decideReviewFollowUpAutomation, clearAutomationPause, depthAtLeast, getBundleAutomationState, resolveAutomationConfig, } from '../lib/ticketAutomation.js';
@@ -67,9 +69,6 @@ const updateStatus = (ticketId, status, log, io, operation) => {
 const clearBuildCompletion = (ticketId) => {
     db.prepare('UPDATE tickets SET build_completed_at = NULL, auto_park_dismissed_at = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(ticketId);
 };
-const markBuildCompleted = (ticketId) => {
-    db.prepare('UPDATE tickets SET build_completed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(ticketId);
-};
 const emitBundleTickets = (projectId, bundleId, io) => {
     for (const bundleTicket of listTickets(projectId).filter(ticket => ticket.worktree_bundle_id === bundleId)) {
         const refreshed = getTicket(bundleTicket.id);
@@ -195,7 +194,7 @@ Use the review findings as the source of truth unless the follow-up instruction
 
 ${getProjectMemorySuggestionPromptRules(memoryEnabled, 'follow_up')}` : ''}`;
 };
-const runReviewFollowUpCompletionAutomation = async (ticket, project, io, executionContext, initiation) => {
+const runReviewFollowUpCompletionAutomation = async (ticket, project, io, executionContext, initiation, releaseOwnerQueue) => {
     if (!ticket.worktree_bundle_id || !ticket.project_id) {
         return false;
     }
@@ -263,6 +262,7 @@ const runReviewFollowUpCompletionAutomation = async (ticket, project, io, execut
                     broadcaster: io,
                     initiation,
                     pausedStageRunId: executionContext.runId,
+                    releaseOwnerQueue,
                 });
                 return true;
             }
@@ -280,6 +280,7 @@ const runReviewFollowUpCompletionAutomation = async (ticket, project, io, execut
                 broadcaster: io,
                 initiation,
                 pausedStageRunId: executionContext.runId,
+                releaseOwnerQueue,
             });
             return true;
         }
@@ -287,6 +288,20 @@ const runReviewFollowUpCompletionAutomation = async (ticket, project, io, execut
             return false;
     }
 };
+export const completeSuccessfulReviewPostFinalization = async ({ ticket, project, executionContext, initiation, io, releaseOwnerQueue, memorySuggestions, }) => {
+    if (project.memory_enabled && memorySuggestions.length > 0) {
+        persistProjectMemorySuggestions(project.id, ticket.id, 'follow_up', memorySuggestions);
+    }
+    const completedTicket = getTicket(ticket.id) ?? ticket;
+    captureStageSuccess(ticket.id, 'review');
+    const handled = await runReviewFollowUpCompletionAutomation(completedTicket, project, io, executionContext, initiation, releaseOwnerQueue);
+    if (!handled) {
+        const completed = autoParkTicketIfStale(ticket.id);
+        if (completed) {
+            io.emit('ticket:updated', completed);
+        }
+    }
+};
 export const isFollowUpRunning = (ticket) => {
     const jobKey = resolveTicketWorkerKey(ticket, 'follow_up');
     return !jobKey || isRunning(jobKey);
@@ -399,11 +414,18 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
         updateStatus(ticket.id, 'running', null, io, operation);
     }
     const activityKind = ticket.state === 'build' ? 'build_follow_up' : 'review_follow_up';
+    const hasBuildCancellationHandle = mode !== 'plan' && (ticket.state === 'build' || ticket.state === 'review');
+    if (hasBuildCancellationHandle) {
+        registerBuildProcessPlaceholder(ticket.id);
+    }
     let queuedJob;
     try {
-        queuedJob = enqueue(jobKey, async () => {
+        queuedJob = enqueue(jobKey, async (releaseQueueOwnership) => {
             const scheduledRun = getExecutionRun(executionContext.projectId, executionContext.runId);
             if (!scheduledRun || !['queued', 'running', 'waiting'].includes(scheduledRun.status)) {
+                if (hasBuildCancellationHandle) {
+                    untrackBuildProcessById(ticket.id);
+                }
                 if (options.buildOpenQuestionBatchId
                     && scheduledRun
                     && ['failed', 'cancelled', 'interrupted'].includes(scheduledRun.status)) {
@@ -414,6 +436,7 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
             registerBundleActivity(ticket, activityKind);
             let buildOpenQuestionBatchCompleted = false;
             let sequenceHasNextBuild = false;
+            let postBuildContinuationHasNextBuild = false;
             try {
                 withExecutionRunTransaction(transaction => {
                     const operation = ticket.state === 'review' && mode !== 'plan' ? 'follow_up' : null;
@@ -438,6 +461,9 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                 }
                 const cwd = ticket.bundle?.kind === 'project_root' ? project.repo_path : resolveWorktreePath(branch, project);
                 await options.trustedOrchestration?.beforeStart(executionContext);
+                const spawnPermitId = options.trustedOrchestration
+                    ? acquireAgentSpawnPermit(executionContext.runId)
+                    : undefined;
                 const runTicket = { ...ticket, ...runConfig };
                 const tool = resolveTicketTool(runTicket, config.tool ?? 'opencode');
                 const isBuildTicket = ticket.state === 'build';
@@ -454,17 +480,21 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                     clearBuildCompletion(ticket.id);
                 }
                 const isReviewResume = isReviewTicket && !isPlanMode && Boolean(ticket.session_id) && hasPreviousReviewFollowUp(ticket);
-                const selectedPrompt = options.trustedOrchestration?.prompt ?? (isPlanMode
-                    ? questionFollowUpPrompt(runTicket, instruction, Boolean(project.memory_enabled))
-                    : isBuildTicket
-                        ? followUpPrompt(runTicket, project, instruction, Boolean(project.memory_enabled), !options.buildOpenQuestionBatchId)
-                        : prependSkillPromptBlock(reviewFindingsFollowUpPrompt(runTicket, project, latestReviewFindings, instruction, Boolean(project.memory_enabled)), runTicket.skills));
+                const selectedPrompt = options.trustedOrchestration
+                    ? prependSkillPromptBlock(options.trustedOrchestration.prompt, runTicket.skills)
+                    : (isPlanMode
+                        ? questionFollowUpPrompt(runTicket, instruction, Boolean(project.memory_enabled))
+                        : isBuildTicket
+                            ? followUpPrompt(runTicket, project, instruction, Boolean(project.memory_enabled), !options.buildOpenQuestionBatchId)
+                            : prependSkillPromptBlock(reviewFindingsFollowUpPrompt(runTicket, project, latestReviewFindings, instruction, Boolean(project.memory_enabled)), runTicket.skills));
                 const prompt = isBuildTicket && !isPlanMode
                     ? appendFigmaInspectionGuidance(selectedPrompt, runTicket.description || runTicket.title, 'implementation')
                     : selectedPrompt;
-                const resumeSessionId = options.providerContinuation === 'fresh' || isPlanMode
-                    ? null
-                    : (isBuildTicket || isReviewResume ? ticket.session_id : null);
+                const resumeSessionId = options.resumeSessionId !== undefined
+                    ? options.resumeSessionId
+                    : options.providerContinuation === 'fresh' || isPlanMode
+                        ? null
+                        : (isBuildTicket || isReviewResume ? ticket.session_id : null);
                 const mainRunId = createAgentRun({
                     executionRunId: executionContext.runId,
                     parentType: 'ticket',
@@ -477,29 +507,88 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                     throw new Error('Unable to create the follow-up agent run');
                 }
                 emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', ticket.id);
-                const { response: finalResponse, responseTiming, transcriptRuns } = await runAgent({
+                const launch = (run, sessionId, permitId) => runAgent({
                     ticketId: ticket.id,
                     tool,
                     prompt,
                     cwd,
                     model: runTicket.model,
                     variant: runTicket.variant,
-                    resumeSessionId,
+                    resumeSessionId: sessionId,
                     trackBuildProcess: !isPlanMode && (isBuildTicket || isReviewTicket),
                     emitSuccessUpdate: false,
                     persistSessionIdToTicket: !isPlanMode,
                     executionContext,
                     runStream: {
-                        runId: mainRun.id,
-                        label: mainRun.label,
-                        role: mainRun.role,
-                        runIndex: mainRun.run_index,
+                        runId: run.id,
+                        label: run.label,
+                        role: run.role,
+                        runIndex: run.run_index,
                     },
                     io,
                     opencodeAgentMode: isPlanMode ? mode : undefined,
+                    spawnPermitId: permitId,
                 });
-                const completedMainRun = getAgentRun(mainRun.id);
-                const completionStatus = completedMainRun?.agent_status === 'stopped' ? 'stopped' : 'done';
+                let agentResult;
+                let completedMainRun = mainRun;
+                if (options.trustedOrchestration && !resumeSessionId) {
+                    appendLifecycleEvent({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        domainStatus: 'running',
+                        eventType: 'provider_fresh_without_historical_session',
+                    }, asGenericEmitter(io));
+                }
+                try {
+                    agentResult = await launch(mainRun, resumeSessionId, spawnPermitId);
+                    if (options.trustedOrchestration && resumeSessionId) {
+                        appendLifecycleEvent({
+                            projectId: executionContext.projectId,
+                            runId: executionContext.runId,
+                            domainStatus: 'running',
+                            eventType: 'provider_continuation_resumed',
+                        }, asGenericEmitter(io));
+                    }
+                }
+                catch (error) {
+                    if (!options.trustedOrchestration || !resumeSessionId || !isAgentContinuationRejectedError(error)) {
+                        if (options.trustedOrchestration && resumeSessionId) {
+                            appendLifecycleEvent({
+                                projectId: executionContext.projectId,
+                                runId: executionContext.runId,
+                                domainStatus: 'continuation_unsafe_failure',
+                                eventType: 'provider_continuation_unsafe_failure',
+                            }, asGenericEmitter(io));
+                        }
+                        throw error;
+                    }
+                    withExecutionRunTransaction(transaction => transaction.appendLifecycleEvent({
+                        projectId: executionContext.projectId,
+                        runId: executionContext.runId,
+                        domainStatus: 'continuation_rejected_before_execution',
+                        eventType: 'provider_continuation_rejected_before_execution',
+                    }), asGenericEmitter(io));
+                    await options.trustedOrchestration.onContinuationFallback?.(executionContext);
+                    await options.trustedOrchestration.beforeStart(executionContext);
+                    const fallbackPermitId = acquireAgentSpawnPermit(executionContext.runId);
+                    const fallbackRunId = createAgentRun({
+                        executionRunId: executionContext.runId,
+                        parentType: 'ticket',
+                        parentId: ticket.id,
+                        label: `${mainRun.label} (fresh fallback)`,
+                        role: 'main',
+                    });
+                    const fallbackRun = getAgentRun(fallbackRunId);
+                    if (!fallbackRun) {
+                        throw new Error('Unable to create the fresh fallback AgentRun');
+                    }
+                    emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', ticket.id);
+                    completedMainRun = fallbackRun;
+                    agentResult = await launch(fallbackRun, null, fallbackPermitId);
+                }
+                const { response: finalResponse, responseTiming, transcriptRuns } = agentResult;
+                const persistedCompletedMainRun = getAgentRun(completedMainRun.id);
+                const completionStatus = persistedCompletedMainRun?.agent_status === 'stopped' ? 'stopped' : 'done';
                 const askQuestion = isPlanMode && completionStatus === 'done' && typeof finalResponse === 'string'
                     ? extractAskQuestionFromOutput(finalResponse)
                     : { questionSet: null, cleanedOutput: finalResponse ?? '', error: null };
@@ -559,6 +648,9 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                         openQuestions,
                     })
                     : parsedResponse.response.trim();
+                const shouldDeferPostBuildCompletion = !isPlanMode
+                    && completionStatus === 'done'
+                    && !options.trustedOrchestration;
                 const authoritativeResult = withExecutionRunTransaction(transaction => {
                     const assistantMessageId = assistantMessage
                         ? createTicketMessage({
@@ -570,11 +662,21 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                             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);
+                    db.prepare('UPDATE tickets SET agent_status = ?, agent_log = NULL, streaming_response = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND project_id = ?').run((shouldDeferPostBuildCompletion || (isBuildTicket
+                        && !isPlanMode
+                        && completionStatus === 'done'
+                        && options.trustedOrchestration?.preserveOwnerRunningOnCompletion))
+                        ? 'running'
+                        : completionStatus, ticket.id, executionContext.projectId);
                     const completedTicket = getTicket(ticket.id) ?? ticket;
-                    if (isBuildTicket && !isPlanMode && completionStatus === 'done' && !options.trustedOrchestration) {
-                        markBuildCompleted(ticket.id);
-                        if (parsedResponse.hasOpenQuestionsMetadata) {
+                    if (shouldDeferPostBuildCompletion) {
+                        if (isBuildTicket) {
+                            persistPendingPostBuildFinalization(executionContext.projectId, executionContext.runId, parsedResponse.suggestions);
+                        }
+                        else {
+                            persistPendingPostBuildFinalization(executionContext.projectId, executionContext.runId, parsedResponse.suggestions, 'review');
+                        }
+                        if (isBuildTicket && 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({
@@ -628,22 +730,36 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                     bindTicketThinkingMessage(ticket.id, assistantMessageId);
                 }
                 emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', ticket.id);
-                const completedTicket = getTicket(ticket.id) ?? ticket;
-                if (!isPlanMode && completedTicket.agent_status === 'done' && !options.trustedOrchestration) {
-                    await runPostBuildChecks({
+                let finalizedBuildTicket = null;
+                let buildPostBuildFinalized = false;
+                const completedBeforePostBuild = getTicket(ticket.id) ?? ticket;
+                if (shouldDeferPostBuildCompletion) {
+                    const postBuildResult = await runPostBuildChecks({
                         project,
                         sourceRunId: executionContext.runId,
-                        owner: { kind: 'ticket', ticket: completedTicket },
+                        owner: { kind: 'ticket', ticket: completedBeforePostBuild },
                         onStatusChange: () => emitUpdatedTickets([ticket.id], io),
                         emitter: asGenericEmitter(io),
+                        releaseOwnerQueue: releaseQueueOwnership,
+                    });
+                    const finalization = finalizePostBuildCheckTicket({
+                        projectId: executionContext.projectId,
+                        sourceRunId: executionContext.runId,
+                        batch: postBuildResult?.batch ?? null,
+                        error: postBuildResult?.error ?? null,
+                        getTicket,
+                        emitter: asGenericEmitter(io),
                     });
+                    finalizedBuildTicket = finalization.ticket;
+                    buildPostBuildFinalized = finalization.finalized;
                 }
+                const completedTicket = finalizedBuildTicket ?? getTicket(ticket.id) ?? ticket;
                 const bundleReadyForAutomaticReview = Boolean(ticket.project_id
                     && ticket.worktree_bundle_id
                     && areBundleTicketsReadyForAutomaticReview(listTickets(ticket.project_id), ticket.worktree_bundle_id));
                 const preserveAutomaticReviewOwner = bundleReadyForAutomaticReview
                     && depthAtLeast(resolveAutomationConfig(completedTicket.bundle ?? null, project).depth, 'auto_review');
-                if (isBuildTicket && !isPlanMode && completedTicket.agent_status === 'done' && !options.trustedOrchestration) {
+                if (isBuildTicket && !isPlanMode && buildPostBuildFinalized && completedTicket.agent_status === 'done' && !options.trustedOrchestration) {
                     captureStageSuccess(ticket.id, 'build');
                     if (!preserveAutomaticReviewOwner) {
                         const completed = autoParkTicketIfStale(ticket.id);
@@ -659,10 +775,12 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                             workflowContext: options.initiation?.workflowContext ?? null,
                             io,
                             emitUpdatedTickets: ticketIds => emitUpdatedTickets(ticketIds, io),
+                            releaseOwnerQueue: releaseQueueOwnership,
                         });
                         if (continuation.nextTicketId) {
                             sequenceHasNextBuild = true;
                         }
+                        postBuildContinuationHasNextBuild = Boolean(continuation.nextBuild);
                         if (continuation.nextBuild) {
                             const nextBuild = continuation.nextBuild;
                             const nextSequenceId = continuation.nextSequenceId;
@@ -704,6 +822,7 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                                     const stoppedSequence = stopBuildSequence(nextBuild.id);
                                     emitUpdatedTickets(stoppedSequence.affectedTicketIds, io);
                                 }
+                                markPostBuildCheckFinalizationComplete(executionContext.projectId, executionContext.runId);
                             };
                             if (resolveTicketContextKey(nextBuild) === resolveTicketContextKey(ticket)) {
                                 queuedJob.finally(scheduleNextBuild).catch(() => { });
@@ -764,6 +883,7 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                 }
                 if (isBuildTicket
                     && !isPlanMode
+                    && buildPostBuildFinalized
                     && completedTicket.agent_status === 'done'
                     && parsedResponse.hasOpenQuestionsMetadata
                     && !sequenceHasNextBuild) {
@@ -810,7 +930,9 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                         emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
                     }
                 }
-                if (project.memory_enabled && parsedResponse.suggestions.length > 0) {
+                if (project.memory_enabled
+                    && parsedResponse.suggestions.length > 0
+                    && (isPlanMode || isBuildTicket)) {
                     persistProjectMemorySuggestions(project.id, ticket.id, 'follow_up', parsedResponse.suggestions);
                 }
                 clearTicketStreamingResponse(ticket.id);
@@ -819,7 +941,7 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                     io.emit('ticket:updated', completedWithMessage);
                 }
                 if (options.trustedOrchestration) {
-                    if (completedTicket.agent_status === 'done') {
+                    if (completionStatus === 'done') {
                         await options.trustedOrchestration.onCompletion(executionContext);
                     }
                     else if (completedTicket.agent_status === 'stopped') {
@@ -828,7 +950,7 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                 }
                 else if (!isPlanMode) {
                     const updated = getTicket(ticket.id);
-                    if (isBuildTicket && updated?.agent_status === 'done') {
+                    if (isBuildTicket && buildPostBuildFinalized && updated?.agent_status === 'done') {
                         if (ticket.project_id && ticket.worktree_bundle_id && !sequenceHasNextBuild) {
                             if (options.buildOpenQuestionBatchId) {
                                 if (!parsedResponse.hasOpenQuestionsMetadata) {
@@ -875,6 +997,7 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                                             broadcaster: io,
                                             initiation: options.initiation,
                                             pausedStageRunId: executionContext.runId,
+                                            releaseOwnerQueue: releaseQueueOwnership,
                                         });
                                     }
                                     else if (ownedProgressionRunId) {
@@ -924,27 +1047,37 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                                         workflowContext: options.initiation?.workflowContext ?? null,
                                     },
                                     pausedStageRunId: executionContext.runId,
+                                    releaseOwnerQueue: releaseQueueOwnership,
                                 });
                             }
                             emitBundleTickets(ticket.project_id, ticket.worktree_bundle_id, io);
                         }
                     }
-                    else if (!isBuildTicket && updated?.agent_status === 'done') {
-                        captureStageSuccess(ticket.id, 'review');
-                        const handled = await runReviewFollowUpCompletionAutomation(updated, project, io, executionContext, options.initiation);
-                        if (!handled) {
-                            const completed = autoParkTicketIfStale(ticket.id);
-                            if (completed) {
-                                io.emit('ticket:updated', completed);
-                            }
-                        }
+                    else if (!isBuildTicket
+                        && updated?.agent_status === 'done'
+                        && (!shouldDeferPostBuildCompletion || buildPostBuildFinalized)) {
+                        await completeSuccessfulReviewPostFinalization({
+                            ticket: updated,
+                            project,
+                            executionContext,
+                            initiation: options.initiation,
+                            io,
+                            releaseOwnerQueue: releaseQueueOwnership,
+                            memorySuggestions: parsedResponse.suggestions,
+                        });
                     }
                 }
+                if (!isPlanMode
+                    && buildPostBuildFinalized
+                    && (!isBuildTicket || !postBuildContinuationHasNextBuild)) {
+                    markPostBuildCheckFinalizationComplete(executionContext.projectId, executionContext.runId);
+                }
             }
             catch (error) {
                 const executionRun = getExecutionRun(executionContext.projectId, executionContext.runId);
                 if (executionRun && !['queued', 'running', 'waiting'].includes(executionRun.status)) {
                     if (options.trustedOrchestration) {
+                        releaseQueueOwnership();
                         await options.trustedOrchestration.onCancellation(executionContext);
                         return;
                     }
@@ -1049,8 +1182,20 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                             },
                         });
                     }
-                    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);
+                    const ownerProjection = options.trustedOrchestration?.preserveOwnerOnFailure
+                        ? options.trustedOrchestration.ownerProjectionBeforeRun
+                        : null;
+                    if (ownerProjection) {
+                        db.prepare(`
+            UPDATE tickets SET agent_status = ?, agent_operation = ?, agent_log = ?, streaming_response = ?,
+              updated_at = CURRENT_TIMESTAMP
+            WHERE id = ? AND project_id = ? AND agent_status = 'running'
+          `).run(ownerProjection.agentStatus, ownerProjection.agentOperation, ownerProjection.agentLog, ownerProjection.streamingResponse, ticket.id, executionContext.projectId);
+                    }
+                    else {
+                        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);
+                    }
                     if (ticket.state === 'build' && mode !== 'plan' && !options.trustedOrchestration) {
                         affectedTicketIds = advanceBuildChain(ticket.id, 'error').affectedTicketIds;
                     }
@@ -1064,7 +1209,10 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                         eventType: 'build_follow_up_failed',
                     });
                 }, asGenericEmitter(io));
-                await options.trustedOrchestration?.onFailure(executionContext, message);
+                if (options.trustedOrchestration) {
+                    releaseQueueOwnership();
+                    await options.trustedOrchestration.onFailure(executionContext, message);
+                }
                 emitUpdatedTickets(affectedTicketIds, io);
                 if (ownedReviewFixRunId && ownedReviewProgressionRunId && ticket.project_id && ticket.worktree_bundle_id) {
                     finishAutomationReviewFix({
@@ -1085,14 +1233,28 @@ export function startFollowUp(ticket, io, instruction, mode = 'build', options =
                     });
                 }
                 emitAgentRunsUpdated(asGenericEmitter(io), 'ticket', ticket.id);
-                updateStatus(ticket.id, 'error', message, io);
+                if (options.trustedOrchestration?.preserveOwnerOnFailure) {
+                    const restoredTicket = getTicket(ticket.id);
+                    if (restoredTicket) {
+                        io.emit('ticket:updated', restoredTicket);
+                    }
+                }
+                else {
+                    updateStatus(ticket.id, 'error', message, io);
+                }
             }
             finally {
                 unregisterBundleActivity(ticket, activityKind);
+                if (hasBuildCancellationHandle) {
+                    untrackBuildProcessById(ticket.id);
+                }
             }
         });
     }
     catch (error) {
+        if (hasBuildCancellationHandle) {
+            untrackBuildProcessById(ticket.id);
+        }
         const message = getErrorMessage(error);
         withExecutionRunTransaction(transaction => {
             options.compensate?.();