@straiffi/archon 1.7.1 → 1.7.3

package/dist/server/index.js

@@ -4,7 +4,7 @@ import { existsSync } from 'fs';
 import { createServer } from 'http';
 import { fileURLToPath } from 'url';
 import { Server } from 'socket.io';
-import { randomUUID } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import cors from 'cors';
 import { adjectives, animals, uniqueNamesGenerator } from 'unique-names-generator';
 import db from './db.js';
@@ -26,10 +26,10 @@ import { browseRepoPath } from './lib/directoryPicker.js';
 import { resolveDesktopServerHost } from './lib/desktopServerHost.js';
 import { emitMobileRealtime, getMobileAccessStatus, regenerateMobilePairingChallenge, revokeMobileSession, setMobileAccessStatusChangeListener, startMobileAccess, stopMobileAccess, } from './lib/mobileAccess.js';
 import { validateDesktopMobileAccessRequest } from './lib/mobileAccessSecurity.js';
-import { refreshChatSessionUsageSnapshot, refreshSpecSessionUsageSnapshot, stopAllBuildAgents } from './lib/agent.js';
+import { refreshChatSessionUsageSnapshot, refreshSpecSessionUsageSnapshot, stopAllBuildAgents, stopAllReviewAgents, stopBuildAgent, stopReviewAgent } from './lib/agent.js';
 import { runLightweightPrompt } from './lib/lightweightPrompt.js';
 import { startBuildChain, stopBuildChain } from './lib/buildChains.js';
-import { enqueueBundledBuild, getDependencyOrderedBundleTicketIds, removeTicketFromBuildSequence, stopAllActiveBuildSequences, } from './lib/buildSequences.js';
+import { activateQueuedBuildSequenceTicket, compensateBuildSequenceAcceptance, enqueueBundledBuild, getDependencyOrderedBundleTicketIds, hasActiveSequenceForBundle, removeTicketFromBuildSequence, stopBuildSequence, } from './lib/buildSequences.js';
 import { prepareTicketForBuild } from './lib/buildFlow.js';
 import { getBundlePlanMutationBlockerById, shouldBlockPlanForBundleMutationById, } from './lib/bundleActivity.js';
 import { getDiscoveredModels, normalizeModelId, normalizeTicketModelId } from './lib/models.js';
@@ -45,11 +45,17 @@ import { getProjectFileManifest, ProjectFileContentError, ProjectFileTargetUnava
 import { updateProjectTargetSelection } from './lib/projectTargets.js';
 import { exportProjectMemoryArchive, importProjectMemoryArchive } from './lib/projectMemoryTransfer.js';
 import { buildReviewFindingsResponse, computeDiffSignature, getLatestReviewRunForContext, listReviewFindings } from './lib/reviewFindings.js';
-import { createBuildOpenQuestionResolutionBatch, failBuildOpenQuestionBatch, formatBuildOpenQuestionAnswersPrompt, getLatestBuildOpenQuestionBatchStatus, hasActiveBuildOpenQuestionBatch, listAnsweredBuildOpenQuestionsForBatch, listBuildOpenQuestionsForBundle, loadBuildOpenQuestionsByBundleIds, setBuildOpenQuestionBatchStatus, } from './lib/buildOpenQuestions.js';
-import { clearAutomationPause, countBlockingFindings, depthAtLeast, getBundleAutomationState, isAutomationDepth, recordAutomationPause, resolveAutomationConfig, } from './lib/ticketAutomation.js';
+import { formatBuildOpenQuestionAnswersPrompt, getLatestBuildOpenQuestionBatchStatus, hasActiveBuildOpenQuestionBatch, listBuildOpenQuestionsForBundle, loadBuildOpenQuestionsByBundleIds, } from './lib/buildOpenQuestions.js';
+import { acceptBuildOpenQuestionResolution } from './lib/buildOpenQuestionOperations.js';
+import { completeAutomationProgression, createAutomationReviewFix, finishAutomationReviewFix, getAutomationProgression, recoverLegacyAutomationProgression, recoverStoppedSideEffectProgression, runAutomationProgression, stopAutomationProgression, waitAutomationProgression } from './lib/automationProgression.js';
+import { reconcileAutomationStage } from './lib/automationReconciliation.js';
+import { getAutomationStageDetails, } from './lib/automationStageDetails.js';
+import { clearAutomationPause, countBlockingFindings, depthAtLeast, getBundleAutomationState, isAutomationDepth, recordAutomationPause, resolveAutomationConfig, upsertBundleAutomationState, } from './lib/ticketAutomation.js';
 import { runAutomationCommitChain } from './lib/ticketAutomationCommit.js';
 import { getDiscoveredSkills, normalizeSkillNames } from './lib/skills.js';
 import { clearAllPreviewProxies } from './lib/previewProxy.js';
+import { createExecutionRun, addExecutionRunLink, addExecutionRunLinks, getExecutionRun, hasActiveBuildExecutionRunForTicket, getGitHubActionsExecutionDetails, hasDirectRetryChild, getTestExecutionDetails, GitHubActionsDispatchConflictError, listExecutionRunLinks, listExecutionRuns, listProjectLifecycleEvents, toCanonicalLifecycleEvent, transitionExecutionRun, withExecutionRunTransaction, } from './lib/executionRuns.js';
+import { cleanupAllExecutionEvidence, EXECUTION_EVIDENCE_CLEANUP_INTERVAL_MS, resolveExecutionEvidenceRetentionDays, } from './lib/executionRunRetention.js';
 import { shutdownRealtimeServer } from './lib/shutdown.js';
 import { resolveClientBuildPaths, shouldServeClientApp, STATIC_CLIENT_DIRECTORY_OPTIONS, STATIC_CLIENT_INDEX_OPTIONS, } from './lib/staticClient.js';
 import { deleteIntegrationConnection, getGitHubConnectionConfig, getJiraConnectionConfig, listIntegrationConnections, upsertIntegrationConnection, } from './lib/integrations/index.js';
@@ -58,24 +64,25 @@ import { importJiraIssue, JiraApiError, prepareJiraIssueImport, validateJiraConn
 import { importGitHubIssue, prepareGitHubIssueImport } from './lib/integrations/github-issues.js';
 import { buildImportedIssueSessionTitle, importProviderHostedIssueImages } from './lib/integrations/importedIssueImages.js';
 import { dispatchGitHubWorkflow, getGitHubWorkflowDispatchConfig, getGitHubWorkflowRun, getGitHubWorkflowRunJobs, listGitHubWorkflows, listGitHubWorkflowRuns, } from './lib/integrations/githubActions.js';
-import { clearAllGitHubActionsSessions, getActiveTrackedRunCount, getTrackedGitHubActionsRuns, trackGitHubActionsRun, } from './lib/integrations/githubActionsSessions.js';
+import { clearAllGitHubActionsSessions, getActiveTrackedRunCount, getTrackedGitHubActionsRuns, startGitHubActionsPolling, trackGitHubActionsRun, } from './lib/integrations/githubActionsSessions.js';
+import { reconcileStartupExecutions } from './lib/executionReconciliation.js';
 import { PlanningReferenceError, resolveExternalPlanningDescription } from './lib/integrations/planning.js';
 import { refreshIfNeeded as refreshAssignedIssues, clearCachedAssignedIssues } from './lib/integrations/assignedIssuesCache.js';
 import { buildCommitMessagePrompt, normalizeGeneratedCommitMessage } from './lib/commitMessage.js';
 import { BUNDLE_PULL_REQUEST_SYNC_TTL_MS, getBundlePullRequestRecord, hasOpenBundlePullRequest, serializeBundlePullRequest, shouldSyncBundlePullRequest, syncTrackedBundlePullRequestIfNeeded, upsertBundlePullRequest, upsertBundlePullRequestFromGitHub, } from './lib/bundlePullRequests.js';
 import { countInboundProjectLinks, getEffectiveProject, getProjectById, getProjectTicketStats, hasProjectRunIde, listProjects, replaceProjectLinks, serializeProject, updateProjectActiveTarget, validateProjectPayload, } from './lib/projects.js';
 import { getActiveRunStatus, getActiveRunStatusForProject, getPreviewStatusForProject, hasRunConfig, isRunning, openIde, openTicketIdeInWorkspace, resolveProjectRunContextKey, runSetupCommandsInWorkspace, runTicketInWorkspace, stopAllTickets, stopTicket } from './lib/run.js';
-import { clearAllTestSessions, createTestSession, deleteTestSession, discoverTestsForSession, doesTestFileExistForSession, findProjectTestCommand, getTestSession, isTestSelectionSupported, startTestSessionRun, stopTestSessionRun } from './lib/testSessions.js';
+import { clearAllTestSessions, createTestSession, deleteTestSession, discoverTestsForSession, doesTestFileExist, doesTestFileExistForSession, findProjectTestCommand, getTestSession, isTestSelectionSupported, startTestSessionRun, stopTestSessionRun } from './lib/testSessions.js';
 import { getBundleBuildBlockerResponse, shouldStartBundleBuildNow, transitionTicketState, } from './lib/ticketWorkflowOperations.js';
 import { submitPlanTicketFollowUp, submitTicketFollowUp, } from './lib/ticketFollowUpOperations.js';
-import { canUseBuildControls, formatActiveRunConflict, getTicketRunReadinessError, resumeBuildTicketRun, runProjectTarget, runTicketRun, stopBuildTicketRun, stopProjectTargetRun, stopTicketRun, } from './lib/ticketRunOperations.js';
+import { canUseBuildControls, formatActiveRunConflict, getTicketRunReadinessError, resumeBuildTicketRun, runProjectTarget, runTicketRun, stopBuildTicketRun, stopReviewTicketRun, stopProjectTargetRun, stopTicketRun, } from './lib/ticketRunOperations.js';
 import { isTicketAgentSettingsPayload, updateTicketAgentSettings, } from './lib/ticketSettingsOperations.js';
-import { resolveBundleReviewOwner, transitionBundleToReview } from './lib/bundleReviewOperations.js';
-import { getActiveBundleStageChangeHead, undoTicketStage } from './lib/ticketUndo.js';
+import { rerunTicketReviewOperation, resolveBundleReviewOwner, transitionBundleToReview } from './lib/bundleReviewOperations.js';
+import { clearTicketStageSnapshots, getActiveBundleStageChangeHead, reconcileStageSnapshots, undoTicketStage } from './lib/ticketUndo.js';
 import { closeAllTerminalSessions, createProjectTerminalSession, createTerminalSessionForWorkspace, destroyTerminalSessionById, registerTerminalSocketHandlers, } from './lib/terminal.js';
 import { countBundleTickets, createTicketRecord, createBundle, deleteBundle, ensureProjectRootBundle, autoParkTicketIfStale, autoParkSettledBundleTicket, isBundleSettledForAutoPark, clearAutoParkDismissalIfNeeded, assignTicketDoneOrder, assignTicketLaneOrder, getBundle, getBundleByName, getBundleByBranch, getBundleRepresentativeTicketContext, isProjectRootBundle, getTicket, isBundledTicket, listTicketsInRunContext, listBundles, listBoardTicketEnrichment, listTickets, resolveTicketBranch, resolveTicketTool, updateBundleAutomationConfig, updateBundleIdentity, } from './lib/tickets.js';
 import { createTicketMessage, upsertTicketDescriptionMessage } from './lib/ticketMessages.js';
-import { listAgentRunsForParent } from './lib/agentRuns.js';
+import { listAgentRunsForExecutionRun, listAgentRunsForParent, terminalizeAgentRunsForExecutionRun } from './lib/agentRuns.js';
 import { HttpError } from './lib/httpError.js';
 import { parseIncomingExternalSource } from './lib/externalSource.js';
 import { materializeTicketsWithDependencies } from './lib/ticketBatch.js';
@@ -84,9 +91,8 @@ import { buildSpecImplementationDraft, buildVisualizationAppendix } from './lib/
 import { exportSpecToDocs, checkSpecExportCollision } from './lib/specExport.js';
 import { createTicketDependency, deleteTicketDependenciesForTicket, deleteTicketDependency, getTicketDependency, isTicketRunSetupReady, listTicketDependencies, validateCreateTicketDependency, } from './lib/ticketDependencies.js';
 import { startBuild } from './workers/build.js';
-import { startFollowUp } from './workers/followUp.js';
-import { expandPlanningTicketOutline, generatePlanningTicketOutline, generatePlanText, prepareLinkedPlanningResearch, startPlan, } from './workers/plan.js';
-import { startReview } from './workers/review.js';
+import { expandPlanningTicketOutline, generatePlanningTicketOutline, generatePlanText, prepareLinkedPlanningResearch, startPlan, stopAllPlanAgents, } from './workers/plan.js';
+import { EXECUTION_RUN_KINDS, validateWorkflowContext } from './lib/types.js';
 const getErrorMessage = (error) => {
     return error instanceof Error ? error.message : String(error);
 };
@@ -134,6 +140,87 @@ const parseMultiValueQuery = (value, allowedValues, fieldName) => {
         values: entries.filter((entry, index, values) => values.indexOf(entry) === index),
     };
 };
+const EXECUTION_RUN_STATUSES = ['queued', 'running', 'waiting', 'completed', 'failed', 'cancelled', 'interrupted'];
+const parseLifecycleListQuery = (query) => {
+    const kind = parseMultiValueQuery(query.kind, EXECUTION_RUN_KINDS, 'kind');
+    if ('error' in kind) {
+        return kind;
+    }
+    if (kind.values.length > 1) {
+        return { error: 'kind must include at most one value' };
+    }
+    const status = parseMultiValueQuery(query.status, EXECUTION_RUN_STATUSES, 'status');
+    if ('error' in status) {
+        return status;
+    }
+    if (query.cursor != null && typeof query.cursor !== 'string') {
+        return { error: 'cursor must be a string' };
+    }
+    const limit = query.limit == null || query.limit === '' ? 50 : Number(query.limit);
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200) {
+        return { error: 'limit must be an integer between 1 and 200' };
+    }
+    return {
+        kind: kind.values[0],
+        statuses: status.values,
+        cursor: typeof query.cursor === 'string' && query.cursor !== '' ? query.cursor : null,
+        limit,
+    };
+};
+const serializeTestExecutionDetail = (details, retryEligibility) => {
+    if (!details) {
+        return { kind: 'test', available: false, retry_eligibility: retryEligibility };
+    }
+    return {
+        kind: 'test',
+        available: true,
+        command_id: details.command_id,
+        command_name: details.command_name,
+        command_runner: details.command_runner,
+        target_kind: details.target_kind,
+        target_bundle_id: details.target_bundle_id,
+        target_label: details.target_label,
+        ticket_id: details.ticket_id,
+        selection: details.selection,
+        summary: details.summary,
+        exit_code: details.exit_code,
+        duration_ms: details.duration_ms,
+        output: details.output,
+        output_truncated: details.output_truncated,
+        output_retention_state: details.output_retention_state,
+        output_expired_at: details.output_expired_at,
+        output_byte_count: details.output_byte_count,
+        retry_eligibility: retryEligibility,
+    };
+};
+const serializeGitHubActionsExecutionDetail = (details) => {
+    if (!details) {
+        return { kind: 'github_actions', available: false };
+    }
+    return {
+        kind: 'github_actions',
+        available: true,
+        workflow_id: details.workflow_id,
+        workflow_name: details.workflow_name,
+        ref: details.ref,
+        input_names: details.input_names,
+        provider_run_id: details.provider_run_id,
+        provider_status: details.provider_status,
+        conclusion: details.conclusion,
+        html_url: details.html_url,
+        head_sha: details.head_sha,
+        head_branch: details.head_branch,
+        provider_created_at: details.provider_created_at,
+        provider_updated_at: details.provider_updated_at,
+        provider_started_at: details.provider_started_at,
+        dispatched_at: details.dispatched_at,
+        last_synced_at: details.last_synced_at,
+        jobs: details.jobs,
+        jobs_retention_state: details.jobs_retention_state,
+        jobs_expired_at: details.jobs_expired_at,
+        jobs_count: details.jobs_count,
+    };
+};
 const formatWorktreeDeleteError = (target, branch, error) => {
     return `Unable to delete the ${target} worktree for branch "${branch}": ${getErrorMessage(error)}`;
 };
@@ -183,21 +270,13 @@ const getBundlePlanBlockerError = () => {
     return 'AI planning is blocked because this bundle worktree is currently being modified.';
 };
 const deleteTicketRecord = async (ticket) => {
-    if (ticket.agent_status === 'running') {
+    if (ticket.agent_status === 'running'
+        || (ticket.project_id && hasActiveBuildExecutionRunForTicket(ticket.project_id, ticket.id))) {
         return { ok: false, status: 409, error: 'Cannot delete a ticket while the agent is running' };
     }
     if (isRunning(ticket)) {
         await stopTicket(ticket);
     }
-    let nextBuildTicketId = null;
-    let affectedTicketIds = [];
-    if (ticket.state === 'build') {
-        const sequenceRemoval = removeTicketFromBuildSequence(ticket.id);
-        if (sequenceRemoval.ok) {
-            nextBuildTicketId = sequenceRemoval.nextTicketId;
-            affectedTicketIds = sequenceRemoval.affectedTicketIds;
-        }
-    }
     const branch = resolveTicketBranch(ticket);
     if (!isBundledTicket(ticket) && branch) {
         const project = getEffectiveProject(ticket);
@@ -216,7 +295,24 @@ const deleteTicketRecord = async (ticket) => {
     }
     const bundledProject = isBundledTicket(ticket) ? getEffectiveProject(ticket) : null;
     const deletedBundleId = ticket.worktree_bundle_id;
+    let nextBuildTicketId = null;
+    let nextBuildSequenceId = null;
+    let affectedTicketIds = [];
+    if (ticket.state === 'build') {
+        const sequenceRemoval = removeTicketFromBuildSequence(ticket.id);
+        if (sequenceRemoval.ok) {
+            nextBuildTicketId = sequenceRemoval.nextTicketId;
+            nextBuildSequenceId = sequenceRemoval.sequenceId;
+            affectedTicketIds = sequenceRemoval.affectedTicketIds;
+        }
+    }
     db.prepare('DELETE FROM tickets WHERE id = ?').run(ticket.id);
+    try {
+        clearTicketStageSnapshots(ticket.id);
+    }
+    catch (error) {
+        console.warn(`[ticket-delete] Unable to remove stage snapshots for ticket ${ticket.id}`, error);
+    }
     if (bundledProject && deletedBundleId) {
         try {
             cleanupBundleIfEmpty(deletedBundleId, bundledProject);
@@ -230,7 +326,7 @@ const deleteTicketRecord = async (ticket) => {
         }
     }
     io.emit('ticket:deleted', { id: ticket.id });
-    return { ok: true, nextBuildTicketId, affectedTicketIds };
+    return { ok: true, nextBuildTicketId, nextBuildSequenceId, affectedTicketIds };
 };
 const emitUpdatedTickets = (ticketIds) => {
     for (const ticketId of ticketIds) {
@@ -240,6 +336,41 @@ const emitUpdatedTickets = (ticketIds) => {
         }
     }
 };
+const scheduleBuildAfterTicketDeletion = (result) => {
+    if (!result.nextBuildTicketId || !result.nextBuildSequenceId) {
+        return;
+    }
+    const nextTicket = getTicket(result.nextBuildTicketId);
+    if (!nextTicket) {
+        stopBuildSequence(result.nextBuildTicketId);
+        return;
+    }
+    const scheduling = startBuild(nextTicket, io, {
+        sequenceId: result.nextBuildSequenceId,
+        initiation: { initiator: 'automation' },
+        accept: () => {
+            const transition = prepareTicketForBuild(nextTicket.id);
+            if (!transition.ok) {
+                throw new Error(transition.error);
+            }
+            activateQueuedBuildSequenceTicket(result.nextBuildSequenceId, transition.ticket.id);
+            return {
+                ticket: transition.ticket,
+                sequenceId: result.nextBuildSequenceId,
+                compensate: () => {
+                    db.prepare(`
+            UPDATE build_sequence_tickets SET status = 'queued', started_at = NULL
+            WHERE build_sequence_id = ? AND ticket_id = ? AND status = 'active'
+          `).run(result.nextBuildSequenceId, transition.ticket.id);
+                },
+            };
+        },
+    });
+    if (!scheduling.accepted) {
+        const stopped = stopBuildSequence(nextTicket.id);
+        emitUpdatedTickets(stopped.affectedTicketIds);
+    }
+};
 const CORS_ORIGINS = parseCorsOrigins(process.env.CORS_ORIGIN);
 const CORS_ORIGIN_RESOLVER = createCorsOriginResolver(CORS_ORIGINS);
 const app = express();
@@ -523,16 +654,15 @@ const asProjectPayload = (body) => {
 const isWorktreeReady = (branch, project) => {
     return existsSync(resolveWorktreePath(branch, project));
 };
-// Any ticket left in 'running' on startup had its job lost when the server stopped
-db.prepare("UPDATE tickets SET agent_status = 'error' WHERE agent_status = 'running'").run();
-// Same recovery for spec and chat sessions: the in-memory process maps are wiped
-// on restart, so any session still marked 'running' is orphaned and would
-// otherwise be permanently uninterruptible (the stop endpoint returns 409).
-db.prepare("UPDATE spec_sessions SET agent_status = 'error' WHERE agent_status = 'running'").run();
-db.prepare("UPDATE chat_sessions SET agent_status = 'error' WHERE agent_status = 'running'").run();
-// Live run rows belong to in-memory child processes and are never resumable after restart.
-db.prepare('DELETE FROM agent_runs').run();
-stopAllActiveBuildSequences();
+try {
+    const reconciliation = reconcileStageSnapshots();
+    if (reconciliation.removedRecords > 0 || reconciliation.removedDirectories > 0) {
+        console.info('[stage-snapshots] Reconciled stale undo data', reconciliation);
+    }
+}
+catch (error) {
+    console.warn('[stage-snapshots] Unable to reconcile stale undo data', error);
+}
 const getRequestedProjectId = (req) => {
     if (typeof req.query.project_id === 'string' && req.query.project_id !== '') {
         return req.query.project_id;
@@ -586,6 +716,9 @@ const resolveTicketDiffWorkspace = (ticket) => {
         return { error: 'Ticket project no longer exists', status: 400 };
     }
     const bundle = ticket.worktree_bundle_id ? getBundle(ticket.worktree_bundle_id, project.id) : null;
+    if (ticket.worktree_bundle_id && !bundle) {
+        return { error: 'Selected bundle target no longer exists', status: 409 };
+    }
     if (bundle && isProjectRootBundle(bundle)) {
         const branchState = getProjectBranch(project, { includeDiffStats: false });
         if (branchState.status !== 'ready' || !branchState.branch) {
@@ -598,7 +731,7 @@ const resolveTicketDiffWorkspace = (ticket) => {
             kind: 'project_root',
         };
     }
-    const branch = resolveTicketBranch(ticket);
+    const branch = bundle?.branch ?? resolveTicketBranch(ticket);
     if (!branch || !isWorktreeReady(branch, project)) {
         return { error: 'Worktree not ready yet', status: 400 };
     }
@@ -620,6 +753,9 @@ const resolveTicketDiffWorkspaceFromContext = (ticket) => {
     if (!project) {
         return { error: 'Ticket project no longer exists', status: 400 };
     }
+    if (ticket.worktree_bundle_id && !ticket.bundle_kind) {
+        return { error: 'Selected bundle target no longer exists', status: 409 };
+    }
     if (ticket.bundle_kind === 'project_root') {
         const branchState = getProjectBranch(project, { includeDiffStats: false });
         if (branchState.status !== 'ready' || !branchState.branch) {
@@ -632,7 +768,7 @@ const resolveTicketDiffWorkspaceFromContext = (ticket) => {
             kind: 'project_root',
         };
     }
-    const branch = resolveTicketRouteBranch(ticket);
+    const branch = ticket.worktree_bundle_id ? ticket.bundle_branch : ticket.branch;
     if (!branch || !isWorktreeReady(branch, project)) {
         return { error: 'Worktree not ready yet', status: 400 };
     }
@@ -811,6 +947,63 @@ const parseTestTargetSelection = (value) => {
     }
     return null;
 };
+const unavailableTestRetry = (reason, status, message) => ({
+    eligibility: { eligible: false, reason },
+    error: { status, message },
+});
+const resolveTestRetry = (project, executionRun, details) => {
+    if (!executionRun || executionRun.kind !== 'test' || !details) {
+        return unavailableTestRetry('details_unavailable', 404, 'Test execution run not found');
+    }
+    if (!['failed', 'cancelled', 'interrupted'].includes(executionRun.status)) {
+        return unavailableTestRetry('run_not_terminal', 409, 'Only failed, cancelled, or interrupted test runs can be retried.');
+    }
+    if (hasDirectRetryChild(executionRun.id)) {
+        return unavailableTestRetry('retry_already_created', 409, 'A retry has already been created for this test run.');
+    }
+    if (!details.command_id) {
+        return unavailableTestRetry('command_unidentifiable', 409, 'The original test command is no longer identifiable.');
+    }
+    const command = findProjectTestCommand(project, details.command_id);
+    if (!command) {
+        return unavailableTestRetry('command_missing', 404, 'Test command not found');
+    }
+    const selection = parseTestTargetSelection(details.selection);
+    if (!selection) {
+        return unavailableTestRetry('selection_invalid', 409, 'The original test selection is no longer valid.');
+    }
+    let workspace;
+    if (details.ticket_id) {
+        const ticket = getTicket(details.ticket_id);
+        if (!ticket || ticket.project_id !== project.id) {
+            return unavailableTestRetry('target_missing', 404, 'Ticket not found');
+        }
+        workspace = resolveTicketTestWorkspace(ticket);
+    }
+    else if (details.target_kind === 'repo_root' || details.target_kind === 'bundle') {
+        workspace = resolveExplicitProjectTestWorkspace(project, details.target_kind, details.target_bundle_id);
+    }
+    else {
+        return unavailableTestRetry('target_invalid', 409, 'The original test target is no longer valid.');
+    }
+    if ('error' in workspace) {
+        return unavailableTestRetry('target_unavailable', workspace.status, workspace.error);
+    }
+    if (!isTestSelectionSupported(command, selection, workspace.cwd)) {
+        return unavailableTestRetry('selection_unsupported', 409, 'The selected test command only supports running the full suite.');
+    }
+    if (selection.kind !== 'all' && !doesTestFileExist(workspace.cwd, selection.path, command)) {
+        return unavailableTestRetry('test_file_missing', 404, 'Selected test file no longer exists in this target workspace.');
+    }
+    return {
+        eligibility: { eligible: true, reason: null },
+        details,
+        executionRun,
+        command,
+        selection,
+        workspace,
+    };
+};
 const resolveProjectFileSuggestionWorkspace = (project, options = {}) => {
     const ticketId = options.ticketId?.trim() || null;
     if (ticketId) {
@@ -1421,25 +1614,15 @@ const submitBundleFollowUpResponse = (projectId, bundleId, payload, broadcaster)
     if (!targetTicket) {
         return { ok: false, status: 409, error: 'No non-plan tickets are available for follow-up in this bundle' };
     }
-    const effectiveProject = getEffectiveProject(targetTicket);
-    if (!effectiveProject) {
-        return { ok: false, status: 400, error: 'Ticket project no longer exists' };
-    }
-    const branch = resolveTicketBranch(targetTicket);
-    if (!branch || targetTicket.has_worktree === false || !isWorktreeReady(branch, effectiveProject)) {
-        return { ok: false, status: 400, error: 'Worktree not ready yet' };
-    }
-    const started = startFollowUp(targetTicket, broadcaster, instruction, mode);
-    if (!started) {
-        return { ok: false, status: 409, error: 'Ticket is already running' };
-    }
-    createTicketMessage({
+    const submitted = submitTicketFollowUp({
         ticketId: targetTicket.id,
-        role: 'user',
-        kind: 'follow_up',
-        content: instruction,
-        origin: payload?.origin === 'changes' ? 'changes' : null,
+        requestedProjectId: project.id,
+        payload: { ...payload, instruction, mode },
+        broadcaster: broadcaster,
     });
+    if (!submitted.ok) {
+        return submitted;
+    }
     return {
         ok: true,
         status: 200,
@@ -1462,8 +1645,11 @@ const rerunTicketReview = (ticketId) => {
     if (!ticket.can_re_review) {
         return { ok: false, status: 409, error: 'Review can only be re-run after a follow-up finishes' };
     }
-    startReview(ticket, io);
-    return { ok: true, ticket: getTicket(ticket.id) ?? ticket };
+    const scheduling = rerunTicketReviewOperation(ticket, io);
+    if (!scheduling.ok) {
+        return { ok: false, status: scheduling.status, error: scheduling.error };
+    }
+    return { ok: true, ticket: scheduling.value ?? ticket };
 };
 const reviewBundleTickets = (projectId, bundleId) => {
     const project = getProjectById(projectId);
@@ -1534,19 +1720,81 @@ const buildBundleTickets = (projectId, bundleId, broadcaster) => {
         }
     }
     const movedTickets = [];
-    for (const planTicket of orderedPlanTickets) {
-        const buildTransition = prepareTicketForBuild(planTicket.id, {
-            ignoredBlockerTicketIds: bundleTicketIds,
-        });
-        if (!buildTransition.ok) {
-            return {
-                ok: false,
-                status: buildTransition.status,
-                error: buildTransition.error,
-                ...(buildTransition.blockers ? { details: { blockers: buildTransition.blockers } } : {}),
-            };
+    const ticketSnapshots = orderedPlanTickets.map(ticket => db.prepare(`
+    SELECT id, project_id, 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, project.id));
+    const firstPlanTicket = orderedPlanTickets[0];
+    if (!firstPlanTicket) {
+        return { ok: false, status: 409, error: 'No plan tickets are available to build in this bundle' };
+    }
+    const acceptBundleBuild = () => {
+        let activeSequenceId = null;
+        for (const [index, planTicket] of orderedPlanTickets.entries()) {
+            const buildTransition = prepareTicketForBuild(planTicket.id, {
+                ignoredBlockerTicketIds: bundleTicketIds,
+            });
+            if (!buildTransition.ok) {
+                throw new Error(buildTransition.error);
+            }
+            movedTickets.push(buildTransition.ticket);
+            const queuedBuild = enqueueBundledBuild({
+                ticketId: buildTransition.ticket.id,
+                projectId: project.id,
+                worktreeBundleId: bundle.id,
+                activate: index === 0,
+            });
+            if (index === 0) {
+                activeSequenceId = queuedBuild.sequenceId;
+            }
         }
-        movedTickets.push(buildTransition.ticket);
+        return {
+            ticket: movedTickets[0],
+            sequenceId: activeSequenceId,
+            ...(activeSequenceId
+                ? {
+                    compensate: () => {
+                        compensateBuildSequenceAcceptance(activeSequenceId, movedTickets.map(ticket => ticket.id));
+                        for (const snapshot of ticketSnapshots) {
+                            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(snapshot.state, snapshot.tool, snapshot.agent_status, snapshot.agent_log, snapshot.streaming_response, snapshot.branch, snapshot.build_completed_at, snapshot.run_setup_status, snapshot.auto_park_dismissed_at, snapshot.planning_context_json, snapshot.lane_order, snapshot.id, snapshot.project_id);
+                        }
+                    },
+                }
+                : {}),
+        };
+    };
+    if (hasActiveSequenceForBundle(project.id, bundle.id)) {
+        try {
+            db.transaction(acceptBundleBuild)();
+        }
+        catch (error) {
+            return { ok: false, status: 409, error: error instanceof Error ? error.message : String(error) };
+        }
+        emitUpdatedTickets(movedTickets.map(ticket => ticket.id));
+        return {
+            ok: true,
+            status: 200,
+            value: serializeBundleDetails(project, bundle, { target_ticket_id: movedTickets[0]?.id ?? null }),
+        };
+    }
+    const scheduling = startBuild(firstPlanTicket, broadcaster, { accept: acceptBundleBuild });
+    if (scheduling === undefined) {
+        acceptBundleBuild();
+    }
+    else if (!scheduling.accepted) {
+        return {
+            ok: false,
+            status: scheduling.reason === 'queue_failed' ? 503 : 409,
+            error: scheduling.error,
+        };
     }
     emitUpdatedTickets(movedTickets.map(ticket => ticket.id));
     const details = serializeBundleDetails(project, bundle, {
@@ -1556,22 +1804,6 @@ const buildBundleTickets = (projectId, bundleId, broadcaster) => {
         ok: true,
         status: 200,
         value: details,
-        afterResponse: () => {
-            for (const [index, movedTicket] of movedTickets.entries()) {
-                if (!movedTicket.project_id || !movedTicket.worktree_bundle_id) {
-                    continue;
-                }
-                const queuedBuild = enqueueBundledBuild({
-                    ticketId: movedTicket.id,
-                    projectId: movedTicket.project_id,
-                    worktreeBundleId: movedTicket.worktree_bundle_id,
-                    activate: index === 0 && shouldStartBundleBuildNow(movedTicket),
-                });
-                if (queuedBuild.shouldStartNow) {
-                    startBuild(movedTicket, broadcaster);
-                }
-            }
-        },
     };
 };
 const getCurrentReviewWorkspaceSignature = (ticket) => {
@@ -1912,14 +2144,14 @@ const validateExpandedPlanningAgentDraft = (outline, draft) => {
     }
     return draft;
 };
-const createPlanningAgentTickets = db.transaction(({ draft, initiativePrompt, projectId, model, variant, skills, tool, worktreeBundleId, }) => {
+const createPlanningAgentTickets = db.transaction(({ draft, initiativePrompt, projectId, model, variant, skills, worktreeBundleId, }) => {
     const { createdTickets, createdDependencies, ticketIdsByKey } = materializeTicketsWithDependencies({
         options: {
             projectId,
             model,
             variant,
             skills,
-            tool: tool ?? 'opencode',
+            tool: null,
             worktreeBundleId,
             agentStatus: 'done',
         },
@@ -2761,6 +2993,7 @@ app.post('/projects/:id/spec-sessions/:sessionId/snapshots/:snapshotId/review/st
         projectId: req.params.id,
         specSessionId: req.params.sessionId,
         snapshotId: req.params.snapshotId,
+        broadcaster: io,
     });
     if (!result.ok) {
         return res.status(result.status).json({ error: result.error });
@@ -3470,7 +3703,6 @@ app.post('/bundles/:id/build', (req, res) => {
         });
     }
     res.status(buildResult.status).json(buildResult.value);
-    buildResult.afterResponse?.();
 });
 app.post('/bundles/:id/review', (req, res) => {
     const result = getRequiredProject(req);
@@ -3512,33 +3744,51 @@ app.post('/bundles/:id/build-open-questions/resolve', (req, res) => {
     if (resolutions.some(resolution => resolution === null || !resolution.questionId)) {
         return res.status(400).json({ error: 'Each resolution requires a question_id' });
     }
-    const buildTickets = listBundleSliceTickets(result.project.id, bundle.id, 'build');
-    if (buildTickets.length === 0
-        || buildTickets.some(ticket => ticket.agent_status !== 'done' && ticket.agent_status !== 'stopped')) {
-        return res.status(409).json({ error: 'All build tickets in the bundle must be done or stopped before resolving questions' });
-    }
-    const created = createBuildOpenQuestionResolutionBatch({
+    const accepted = acceptBuildOpenQuestionResolution({
         projectId: result.project.id,
         bundleId: bundle.id,
         resolutions: resolutions.filter((resolution) => resolution !== null),
+        broadcaster: io,
     });
-    if (!created.ok) {
-        return res.status(409).json({
-            error: created.error,
-            ...(created.code ? { code: created.code } : {}),
+    if (!accepted.ok) {
+        return res.status(accepted.status).json({
+            error: accepted.error,
+            ...(accepted.code ? { code: accepted.code } : {}),
         });
     }
-    const answeredQuestions = listAnsweredBuildOpenQuestionsForBatch(created.batch.id);
-    if (answeredQuestions.length === 0) {
-        clearAutomationPause(result.project.id, bundle.id);
+    if (accepted.kind === 'dismissed') {
         const automationConfig = resolveAutomationConfig(bundle, result.project);
         const reviewResult = depthAtLeast(automationConfig.depth, 'auto_review')
-            ? transitionBundleToReview(result.project.id, bundle.id, io, { automatic: true })
+            ? transitionBundleToReview(result.project.id, bundle.id, io, {
+                automatic: true,
+                initiation: {
+                    causalParentRunId: accepted.progressionRunId,
+                    workflowContext: validateWorkflowContext({ build_open_question_batch_id: accepted.batchId }),
+                },
+            })
             : null;
+        if (!reviewResult) {
+            completeAutomationProgression({
+                projectId: result.project.id,
+                bundleId: bundle.id,
+                progressionRunId: accepted.progressionRunId,
+                broadcaster: io,
+            });
+        }
         for (const ticket of listDetailedBundleTickets(result.project.id, bundle.id)) {
             io.emit('ticket:updated', ticket);
         }
         if (reviewResult && !reviewResult.ok) {
+            waitAutomationProgression({
+                projectId: result.project.id,
+                bundleId: bundle.id,
+                progressionRunId: accepted.progressionRunId,
+                pauseCode: 'review',
+                pauseReason: reviewResult.error,
+                reasonCode: 'stage_failed',
+                pausedStageRunId: null,
+                broadcaster: io,
+            });
             return res.status(reviewResult.status).json({ error: reviewResult.error });
         }
         return res.json(serializeBundleDetails(result.project, bundle, {
@@ -3546,34 +3796,11 @@ app.post('/bundles/:id/build-open-questions/resolve', (req, res) => {
             target_ticket_id: reviewResult?.value?.id,
         }));
     }
-    const targetTicketSource = resolveBundleTargetTicket(buildTickets);
-    const targetTicket = targetTicketSource ? getTicket(targetTicketSource.id) : null;
-    if (!targetTicket) {
-        failBuildOpenQuestionBatch(created.batch.id, 'No completed Build ticket is available for the follow-up');
-        recordAutomationPause(result.project.id, bundle.id, 'open_questions', 'Build open question follow-up could not be started');
-        return res.status(409).json({ error: 'No completed Build ticket is available for the follow-up' });
-    }
-    const instruction = [
-        'Apply this complete batch of answered Build requirements in one bundle-scoped pass. Preserve the grouping by originating ticket and do not work on dismissed questions.',
-        formatBuildOpenQuestionAnswersPrompt(answeredQuestions),
-    ].join('\n\n');
-    setBuildOpenQuestionBatchStatus(created.batch.id, 'running');
-    const started = startFollowUp(targetTicket, io, instruction, 'build', {
-        buildOpenQuestionBatchId: created.batch.id,
-    });
-    if (!started) {
-        failBuildOpenQuestionBatch(created.batch.id, 'Build follow-up could not be started');
-        recordAutomationPause(result.project.id, bundle.id, 'open_questions', 'Build open question follow-up could not be started');
-        for (const ticket of listDetailedBundleTickets(result.project.id, bundle.id)) {
-            io.emit('ticket:updated', ticket);
-        }
-        return res.status(409).json({ error: 'Build follow-up could not be started' });
-    }
     for (const ticket of listDetailedBundleTickets(result.project.id, bundle.id)) {
         io.emit('ticket:updated', ticket);
     }
-    return res.status(202).json(serializeBundleDetails(result.project, bundle, {
-        target_ticket_id: targetTicket.id,
+    return res.status(accepted.status).json(serializeBundleDetails(result.project, bundle, {
+        target_ticket_id: accepted.targetTicket.id,
     }));
 });
 app.post('/bundles/:id/undo-review', (req, res) => {
@@ -3651,6 +3878,12 @@ app.post('/bundles/:id/stop', async (req, res) => {
     if (!targetTicket) {
         return res.status(404).json({ error: 'Bundle tickets not found' });
     }
+    await stopAutomationProgression({
+        projectId: result.project.id,
+        bundleId: bundle.id,
+        broadcaster: io,
+        stopLocalWorker: worker => (worker.kind === 'review' ? stopReviewAgent(worker.ticket_id) : stopBuildAgent(worker.ticket_id)),
+    });
     await stopTicket(targetTicket);
     emitRunStateForContext(targetTicket, false);
     return res.json(serializeBundleDetails(result.project, bundle));
@@ -3666,6 +3899,27 @@ app.post('/bundles/:id/follow-up', (req, res) => {
     }
     return res.status(response.status).json(response.value);
 });
+const AUTOMATION_SIDE_EFFECT_KINDS = new Set(['automation_commit', 'automation_push', 'automation_pull_request']);
+const AUTOMATION_WORKER_PAUSE_KINDS = new Set(['build', 'review', 'build_follow_up', 'automation_review_fix']);
+const pausedRunBelongsToProgression = (projectId, bundleId, progressionRunId, pausedRunId) => {
+    const pausedRun = getExecutionRun(projectId, pausedRunId);
+    const progression = getExecutionRun(projectId, progressionRunId);
+    if (!pausedRun || !progression || progression.kind !== 'automation_progression') {
+        return false;
+    }
+    const ownsBundle = listExecutionRunLinks(projectId, pausedRun.id).some(link => (link.entity_type === 'bundle'
+        && link.entity_id === bundleId
+        && (link.relationship === 'primary' || link.relationship === 'context')));
+    if (!ownsBundle) {
+        return false;
+    }
+    if (pausedRun.parent_run_id === progressionRunId) {
+        return true;
+    }
+    const parent = pausedRun.parent_run_id ? getExecutionRun(projectId, pausedRun.parent_run_id) : null;
+    return parent?.kind === 'automation_review_fix' && parent.parent_run_id === progressionRunId
+        || progression.parent_run_id === pausedRun.id;
+};
 app.post('/bundles/:id/resume-automation', async (req, res) => {
     const result = getRequiredProject(req);
     if ('error' in result) {
@@ -3688,11 +3942,124 @@ app.post('/bundles/:id/resume-automation', async (req, res) => {
         && listBuildOpenQuestionsForBundle(result.project.id, bundle.id).length > 0) {
         return res.status(409).json({ error: 'Resolve or dismiss all Build open questions before resuming automation' });
     }
+    let progressionRunId = bundleState.automation_progression_run_id;
+    if (!progressionRunId) {
+        try {
+            progressionRunId = (bundleState.automation_paused_stage_run_id
+                ? recoverStoppedSideEffectProgression({
+                    projectId: result.project.id,
+                    bundleId: bundle.id,
+                    broadcaster: io,
+                })
+                : recoverLegacyAutomationProgression({
+                    projectId: result.project.id,
+                    bundleId: bundle.id,
+                    broadcaster: io,
+                })).runId;
+        }
+        catch (error) {
+            return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    try {
+        if (getAutomationProgression(result.project.id, bundle.id)?.id !== progressionRunId) {
+            return res.status(409).json({ error: 'Automation progression ownership is invalid' });
+        }
+    }
+    catch (error) {
+        return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+    let sideEffectResume = null;
+    let pausedRunKind = null;
+    if (bundleState.automation_paused_stage_run_id) {
+        const stageRunId = bundleState.automation_paused_stage_run_id;
+        const stage = getExecutionRun(result.project.id, stageRunId);
+        pausedRunKind = stage?.kind ?? null;
+        if (!stage
+            || (!AUTOMATION_SIDE_EFFECT_KINDS.has(stage.kind) && !AUTOMATION_WORKER_PAUSE_KINDS.has(stage.kind))
+            || !pausedRunBelongsToProgression(result.project.id, bundle.id, progressionRunId, stageRunId)) {
+            return res.status(409).json({ error: 'The paused automation stage does not belong to the active progression' });
+        }
+        if (AUTOMATION_SIDE_EFFECT_KINDS.has(stage.kind)) {
+            let reconciled;
+            try {
+                reconciled = await reconcileAutomationStage({
+                    projectId: result.project.id,
+                    bundleId: bundle.id,
+                    progressionRunId,
+                    stageRunId,
+                });
+            }
+            catch (error) {
+                return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+            if (reconciled.domainStatus === 'ambiguous') {
+                return res.status(409).json({ error: 'The paused automation side effect is ambiguous and cannot be resumed safely.' });
+            }
+            const details = getAutomationStageDetails(result.project.id, stage.id);
+            if (!details || details.stage_kind !== stage.kind) {
+                return res.status(409).json({ error: 'The paused automation side effect has no complete persisted identity.' });
+            }
+            if (reconciled.status === 'completed' && reconciled.domainStatus === 'reconciled_completed') {
+                if (stage.kind === 'automation_commit') {
+                    const commitResult = details.result;
+                    const expectedHeadSha = commitResult && ('commitSha' in commitResult ? commitResult.commitSha : commitResult.headSha);
+                    if (!expectedHeadSha) {
+                        return res.status(409).json({ error: 'The reconciled commit has no persisted HEAD identity.' });
+                    }
+                    sideEffectResume = { stageKind: stage.kind, expectedHeadSha };
+                }
+                else if (stage.kind === 'automation_push') {
+                    const pushResult = details.result;
+                    if (!pushResult?.remoteSha) {
+                        return res.status(409).json({ error: 'The reconciled push has no persisted remote identity.' });
+                    }
+                    sideEffectResume = { stageKind: stage.kind, expectedHeadSha: pushResult.remoteSha };
+                }
+                else {
+                    sideEffectResume = { stageKind: stage.kind };
+                }
+            }
+            else if (reconciled.status === 'interrupted' && reconciled.domainStatus === 'reconciled_absent') {
+                if (stage.kind === 'automation_push') {
+                    const pushIntent = details.intent;
+                    sideEffectResume = { stageKind: stage.kind, retryOfRunId: stage.id, expectedHeadSha: pushIntent.targetLocalSha };
+                }
+                else if (stage.kind === 'automation_pull_request') {
+                    const pullRequestIntent = details.intent;
+                    sideEffectResume = { stageKind: stage.kind, retryOfRunId: stage.id, expectedHeadSha: pullRequestIntent.headSha };
+                }
+                else {
+                    sideEffectResume = { stageKind: stage.kind, retryOfRunId: stage.id };
+                }
+            }
+            else {
+                return res.status(409).json({ error: 'The paused automation side effect has no safely resumable outcome.' });
+            }
+        }
+    }
+    if (liveAutomationConfig.depth === 'manual') {
+        completeAutomationProgression({
+            projectId: result.project.id,
+            bundleId: bundle.id,
+            progressionRunId,
+            domainStatus: 'manual_boundary_reached',
+            broadcaster: io,
+        });
+        for (const ticket of listDetailedBundleTickets(result.project.id, bundle.id)) {
+            io.emit('ticket:updated', ticket);
+        }
+        return res.json(serializeBundleDetails(result.project, bundle));
+    }
     const reviewOwnerSource = bundleState.automation_paused_code === 'open_questions'
         ? listBundleSliceTickets(result.project.id, bundle.id, 'build')
             .find(ticket => ticket.agent_status === 'done') ?? null
         : resolveBundleReviewOwner(result.project.id, bundle.id)
             ?? listBundleSliceTickets(result.project.id, bundle.id, 'review')[0]
+            ?? (bundleState.automation_paused_code === 'review' && (pausedRunKind === 'build' || pausedRunKind === 'build_follow_up')
+                ? listBundleSliceTickets(result.project.id, bundle.id, 'build')
+                    .find(ticket => ticket.agent_status === 'done') ?? null
+                : null)
             ?? null;
     if (!reviewOwnerSource) {
         return res.status(409).json({ error: 'No review ticket to resume from' });
@@ -3706,6 +4073,49 @@ app.post('/bundles/:id/resume-automation', async (req, res) => {
         return res.status(400).json({ error: 'Ticket project no longer exists' });
     }
     const automationConfig = resolveAutomationConfig(owner.bundle ?? null, project);
+    const restoreWaitingProgression = () => {
+        waitAutomationProgression({
+            projectId: result.project.id,
+            bundleId: bundle.id,
+            progressionRunId,
+            pauseCode: bundleState.automation_paused_code ?? 'review',
+            pauseReason: bundleState.automation_paused_reason ?? 'Automation paused',
+            reasonCode: bundleState.automation_pause_reason_code ?? 'manual_transition',
+            pausedStageRunId: bundleState.automation_paused_stage_run_id,
+            broadcaster: io,
+        });
+    };
+    const acceptResumedReview = () => {
+        runAutomationProgression({
+            projectId: result.project.id,
+            bundleId: bundle.id,
+            progressionRunId,
+            broadcaster: io,
+        });
+        return {
+            ticket: owner,
+            compensate: restoreWaitingProgression,
+        };
+    };
+    if (sideEffectResume) {
+        try {
+            runAutomationProgression({
+                projectId: result.project.id,
+                bundleId: bundle.id,
+                progressionRunId,
+                broadcaster: io,
+            });
+            await runAutomationCommitChain(owner, project, owner.bundle ?? null, automationConfig, io, progressionRunId, sideEffectResume);
+        }
+        catch (error) {
+            return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+        const resumedOwner = getTicket(owner.id);
+        if (resumedOwner) {
+            io.emit('ticket:updated', resumedOwner);
+        }
+        return res.json(serializeBundleDetails(result.project, bundle));
+    }
     if (owner.state === 'review' && owner.agent_status === 'running') {
         return res.status(409).json({ error: 'Review already running' });
     }
@@ -3722,24 +4132,131 @@ app.post('/bundles/:id/resume-automation', async (req, res) => {
             && automationConfig.reviewFixEnabled
             && blockingCount > 0
             && iteration < automationConfig.reviewMaxIterations) {
-            clearAutomationPause(result.project.id, bundle.id);
-            startFollowUp(owner, io, `Fix the code review findings at or above "${automationConfig.reviewSeverity}" severity. Address each blocking finding directly and minimally. Do not introduce unrelated changes, reformatting, or refactors. Do not commit.`, 'build');
+            let reviewFixRunId = null;
+            let followUpResult;
+            const previousIteration = bundleState.review_iteration_count ?? 0;
+            const previousFixLoopActive = bundleState.fix_loop_active;
+            try {
+                const progression = getAutomationProgression(result.project.id, bundle.id);
+                if (!progression || progression.id !== progressionRunId) {
+                    return res.status(409).json({ error: 'Automation progression ownership is invalid' });
+                }
+                const workflowContext = validateWorkflowContext(progression.metadata);
+                runAutomationProgression({
+                    projectId: result.project.id,
+                    bundleId: bundle.id,
+                    progressionRunId,
+                    broadcaster: io,
+                });
+                upsertBundleAutomationState(result.project.id, bundle.id, {
+                    review_iteration_count: iteration + 1,
+                    fix_loop_active: 1,
+                });
+                const reviewFix = createAutomationReviewFix({
+                    projectId: result.project.id,
+                    bundleId: bundle.id,
+                    ticketId: owner.id,
+                    ticketTitle: owner.title,
+                    progressionRunId,
+                    workflowContext,
+                    broadcaster: io,
+                });
+                reviewFixRunId = reviewFix.runId;
+                followUpResult = submitTicketFollowUp({
+                    ticketId: owner.id,
+                    requestedProjectId: result.project.id,
+                    payload: {
+                        instruction: `Fix the code review findings at or above "${automationConfig.reviewSeverity}" severity. Address each blocking finding directly and minimally. Do not introduce unrelated changes, reformatting, or refactors. Do not commit.`,
+                        mode: 'build',
+                    },
+                    broadcaster: io,
+                    initiation: {
+                        initiator: 'automation',
+                        causalParentRunId: reviewFix.runId,
+                        workflowContext,
+                    },
+                });
+            }
+            catch (error) {
+                upsertBundleAutomationState(result.project.id, bundle.id, {
+                    review_iteration_count: previousIteration,
+                    fix_loop_active: previousFixLoopActive,
+                });
+                try {
+                    if (reviewFixRunId) {
+                        finishAutomationReviewFix({
+                            projectId: result.project.id,
+                            reviewFixRunId,
+                            failedMessage: error instanceof Error ? error.message : String(error),
+                            broadcaster: io,
+                        });
+                    }
+                }
+                finally {
+                    restoreWaitingProgression();
+                }
+                return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+            if (!followUpResult.ok) {
+                upsertBundleAutomationState(result.project.id, bundle.id, {
+                    review_iteration_count: previousIteration,
+                    fix_loop_active: previousFixLoopActive,
+                });
+                if (reviewFixRunId) {
+                    finishAutomationReviewFix({
+                        projectId: result.project.id,
+                        reviewFixRunId,
+                        failedMessage: followUpResult.error,
+                        broadcaster: io,
+                    });
+                    waitAutomationProgression({
+                        projectId: result.project.id,
+                        bundleId: bundle.id,
+                        progressionRunId,
+                        pauseCode: 'review',
+                        pauseReason: `fix follow-up could not start: ${followUpResult.error}`,
+                        reasonCode: 'stage_failed',
+                        pausedStageRunId: reviewFixRunId,
+                        broadcaster: io,
+                    });
+                }
+                return res.status(followUpResult.status).json({ error: followUpResult.error });
+            }
         }
         else if (depthAtLeast(automationConfig.depth, 'auto_commit')) {
-            clearAutomationPause(result.project.id, bundle.id);
-            await runAutomationCommitChain(owner, project, owner.bundle ?? null, automationConfig, io);
+            try {
+                runAutomationProgression({
+                    projectId: result.project.id,
+                    bundleId: bundle.id,
+                    progressionRunId,
+                    broadcaster: io,
+                });
+                await runAutomationCommitChain(owner, project, owner.bundle ?? null, automationConfig, io, progressionRunId);
+            }
+            catch (error) {
+                return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+            }
         }
         else {
-            clearAutomationPause(result.project.id, bundle.id);
-            startReview(owner, io);
+            const reviewResult = rerunTicketReviewOperation(owner, io, {
+                automatic: true,
+                initiation: { causalParentRunId: progressionRunId },
+                accept: acceptResumedReview,
+            });
+            if (!reviewResult.ok) {
+                return res.status(reviewResult.status).json({ error: reviewResult.error });
+            }
         }
     }
     else if (owner.state === 'build' && owner.agent_status === 'done') {
-        const reviewResult = reviewBundleTickets(result.project.id, bundle.id);
+        const reviewResult = transitionBundleToReview(result.project.id, bundle.id, io, {
+            automatic: true,
+            initiation: { causalParentRunId: progressionRunId },
+            accept: acceptResumedReview,
+        });
         if (!reviewResult.ok) {
             return res.status(reviewResult.status).json({ error: reviewResult.error });
         }
-        clearAutomationPause(result.project.id, bundle.id);
     }
     else {
         return res.status(409).json({ error: 'Ticket is not in a resumable state' });
@@ -3750,7 +4267,7 @@ app.post('/bundles/:id/resume-automation', async (req, res) => {
     }
     return res.json(serializeBundleDetails(result.project, bundle));
 });
-app.post('/bundles/:id/dismiss-automation-pause', (req, res) => {
+app.post('/bundles/:id/dismiss-automation-pause', async (req, res) => {
     const result = getRequiredProject(req);
     if ('error' in result) {
         return res.status(400).json({ error: result.error });
@@ -3771,7 +4288,68 @@ app.post('/bundles/:id/dismiss-automation-pause', (req, res) => {
         && listBuildOpenQuestionsForBundle(result.project.id, bundle.id).length > 0) {
         return res.status(409).json({ error: 'Resolve or dismiss all Build open questions before dismissing this pause' });
     }
-    clearAutomationPause(result.project.id, bundle.id);
+    let progressionRunId = bundleState.automation_progression_run_id;
+    if (!progressionRunId) {
+        try {
+            progressionRunId = (bundleState.automation_paused_stage_run_id
+                ? recoverStoppedSideEffectProgression({
+                    projectId: result.project.id,
+                    bundleId: bundle.id,
+                    broadcaster: io,
+                })
+                : recoverLegacyAutomationProgression({
+                    projectId: result.project.id,
+                    bundleId: bundle.id,
+                    broadcaster: io,
+                })).runId;
+        }
+        catch (error) {
+            return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    try {
+        if (getAutomationProgression(result.project.id, bundle.id)?.id !== progressionRunId) {
+            return res.status(409).json({ error: 'Automation progression ownership is invalid' });
+        }
+    }
+    catch (error) {
+        return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+    if (bundleState.automation_paused_stage_run_id) {
+        const stage = getExecutionRun(result.project.id, bundleState.automation_paused_stage_run_id);
+        if (!stage
+            || (!AUTOMATION_SIDE_EFFECT_KINDS.has(stage.kind) && !AUTOMATION_WORKER_PAUSE_KINDS.has(stage.kind))
+            || !pausedRunBelongsToProgression(result.project.id, bundle.id, progressionRunId, stage.id)) {
+            return res.status(409).json({ error: 'The paused automation stage does not belong to the active progression' });
+        }
+        if (AUTOMATION_SIDE_EFFECT_KINDS.has(stage.kind)) {
+            let reconciled;
+            try {
+                reconciled = await reconcileAutomationStage({
+                    projectId: result.project.id,
+                    bundleId: bundle.id,
+                    progressionRunId,
+                    stageRunId: stage.id,
+                });
+            }
+            catch (error) {
+                return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+            if (reconciled.domainStatus === 'ambiguous') {
+                return res.status(409).json({ error: 'The paused automation side effect is ambiguous and cannot be dismissed safely.' });
+            }
+            if (!(reconciled.status === 'completed' && reconciled.domainStatus === 'reconciled_completed')
+                && !(reconciled.status === 'interrupted' && reconciled.domainStatus === 'reconciled_absent')) {
+                return res.status(409).json({ error: 'The paused automation side effect has no safely dismissible outcome.' });
+            }
+        }
+    }
+    await stopAutomationProgression({
+        projectId: result.project.id,
+        bundleId: bundle.id,
+        broadcaster: io,
+        stopLocalWorker: worker => (worker.kind === 'review' ? stopReviewAgent(worker.ticket_id) : stopBuildAgent(worker.ticket_id)),
+    });
     for (const ticket of listDetailedBundleTickets(result.project.id, bundle.id)) {
         io.emit('ticket:updated', ticket);
     }
@@ -4414,20 +4992,84 @@ app.post('/integrations/github/actions/workflows/:id/dispatch', async (req, res)
         }
     }
     console.info(`[integrations] github actions dispatch project=${result.project.id} workflow=${workflowId} ref=${ref}`);
+    const inputNames = Object.keys(inputs).sort();
+    const inputFingerprint = inputNames.length > 0
+        ? createHash('sha256').update(JSON.stringify(inputNames.map(name => [name, inputs[name]]))).digest('hex')
+        : null;
+    const dispatchedAt = new Date().toISOString();
+    const workflowName = asTrimmedString(req.body?.workflowName)?.slice(0, 500) || `Workflow ${workflowId}`;
+    const workflowUrl = asTrimmedString(req.body?.workflowUrl)?.slice(0, 2_000) || null;
+    let executionRun;
+    try {
+        executionRun = createExecutionRun({
+            projectId: result.project.id,
+            kind: 'github_actions',
+            domainStatus: 'dispatching',
+            sourceReference: {
+                kind: 'github_workflow',
+                id: String(workflowId),
+                label: workflowName,
+                url: workflowUrl,
+            },
+            eventType: 'github_actions_dispatch_requested',
+            eventMessage: 'GitHub Actions workflow dispatch was requested.',
+            eventMetadata: { workflow_id: workflowId, ref, input_names: inputNames },
+            githubActionsDetails: {
+                workflowId,
+                workflowName,
+                ref,
+                inputNames,
+                inputFingerprint,
+                dispatchedAt,
+            },
+        }, io);
+    }
+    catch (error) {
+        if (error instanceof GitHubActionsDispatchConflictError) {
+            return res.status(409).json({
+                error: error.message,
+                execution_run_id: error.executionRunId,
+            });
+        }
+        throw error;
+    }
     try {
-        const dispatchedAt = Date.now();
         await dispatchGitHubWorkflow(githubConfig, workflowId, { ref, inputs });
+        transitionExecutionRun({
+            projectId: result.project.id,
+            runId: executionRun.id,
+            status: 'waiting',
+            domainStatus: 'resolving',
+            eventType: 'github_actions_dispatch_accepted',
+            eventMessage: 'GitHub accepted the workflow dispatch request.',
+            eventMetadata: { workflow_id: workflowId, ref },
+        }, io);
         const trackedRun = trackGitHubActionsRun({
             io,
+            executionRunId: executionRun.id,
             projectId: result.project.id,
-            workflowId,
             config: githubConfig,
-            dispatchedAt,
         });
-        return res.status(202).json({ tracking_key: trackedRun.tracking_key, dispatched: true });
+        return res.status(202).json({
+            tracking_key: trackedRun.tracking_key,
+            execution_run_id: executionRun.id,
+            dispatched: true,
+        });
     }
     catch (error) {
         console.warn(`[integrations] github actions dispatch failed project=${result.project.id} workflow=${workflowId}`, error);
+        transitionExecutionRun({
+            projectId: result.project.id,
+            runId: executionRun.id,
+            status: 'failed',
+            domainStatus: 'dispatch_failed',
+            failure: {
+                code: error instanceof GitHubApiError ? `github_actions_dispatch_http_${error.status}` : 'github_actions_dispatch_failed',
+                message: error instanceof GitHubApiError ? error.publicMessage : 'Unable to dispatch the workflow right now.',
+            },
+            eventType: 'github_actions_dispatch_failed',
+            eventMessage: error instanceof GitHubApiError ? error.publicMessage : 'Unable to dispatch the workflow right now.',
+        }, io);
         if (error instanceof GitHubApiError) {
             return res.status(error.status).json({ error: error.publicMessage });
         }
@@ -4635,6 +5277,8 @@ app.post('/planning-agent', async (req, res) => {
     ensureProjectRootBundle(project.id);
     const trimmedDescription = description.trim();
     let autoCreatedBundle = null;
+    let planningExecutionRun = null;
+    let materializationCommitted = false;
     try {
         const resolvedDescription = await resolveExternalPlanningDescription(project.id, trimmedDescription);
         const requestedBundleSelection = resolveRequestedBundleSelection(req.body, project.id);
@@ -4669,13 +5313,38 @@ app.post('/planning-agent', async (req, res) => {
                 });
             }
         }
-        const linkedResearch = await prepareLinkedPlanningResearch(resolvedDescription, plannerOptions);
-        const outline = normalizePlanningAgentOutline(await generatePlanningTicketOutline(resolvedDescription, {
+        planningExecutionRun = createExecutionRun({
+            projectId: project.id,
+            kind: 'planning_agent',
+            domainStatus: 'queued',
+            sourceReference: { kind: 'project', id: project.id, label: project.name },
+            eventType: 'planning_agent_created',
+        }, io);
+        const executionContext = {
+            runId: planningExecutionRun.id,
+            correlationId: planningExecutionRun.correlation_id,
+            projectId: planningExecutionRun.project_id,
+            kind: planningExecutionRun.kind,
+        };
+        const executionPlannerOptions = {
             ...plannerOptions,
+            executionContext,
+            agentRunParent: { parentType: 'planning', parentId: project.id, io },
+        };
+        transitionExecutionRun({
+            projectId: project.id,
+            runId: planningExecutionRun.id,
+            status: 'running',
+            domainStatus: 'running',
+            eventType: 'planning_agent_started',
+        }, io);
+        const linkedResearch = await prepareLinkedPlanningResearch(resolvedDescription, executionPlannerOptions);
+        const outline = normalizePlanningAgentOutline(await generatePlanningTicketOutline(resolvedDescription, {
+            ...executionPlannerOptions,
             linkedResearch,
         }));
         const draft = validateExpandedPlanningAgentDraft(outline, normalizePlanningAgentDraft(await expandPlanningTicketOutline(resolvedDescription, outline, {
-            ...plannerOptions,
+            ...executionPlannerOptions,
             linkedResearch,
         })));
         const created = createPlanningAgentTickets({
@@ -4685,18 +5354,57 @@ app.post('/planning-agent', async (req, res) => {
             model: tool === 'opencode' && typeof model === 'string' ? normalizeModelId(model) || null : null,
             variant: tool === 'opencode' && typeof variant === 'string' && variant.trim() ? variant.trim() : null,
             skills: resolveRequestedSkills(req.body?.skills),
-            tool,
             worktreeBundleId: bundleSelection.bundleId,
         });
+        materializationCommitted = true;
+        addExecutionRunLinks({
+            projectId: project.id,
+            runId: planningExecutionRun.id,
+            links: created.tickets.map(ticket => ({
+                entityType: 'ticket',
+                entityId: ticket.id,
+                relationship: 'result',
+            })),
+        });
         for (const ticket of created.tickets) {
             io.emit('ticket:created', ticket);
         }
         for (const dependency of created.dependencies) {
             io.emit('ticket-dependency:created', dependency);
         }
+        transitionExecutionRun({
+            projectId: project.id,
+            runId: planningExecutionRun.id,
+            status: 'completed',
+            domainStatus: 'done',
+            eventType: 'planning_agent_completed',
+        }, io);
         return res.status(201).json(created);
     }
     catch (error) {
+        if (planningExecutionRun) {
+            const rawFailureMessage = getErrorMessage(error) || 'Planning agent failed';
+            const failureMessage = (materializationCommitted
+                ? `Planning tickets were created, but execution result reconciliation failed. Reconcile run ${planningExecutionRun.id}: ${rawFailureMessage}`
+                : rawFailureMessage).slice(0, 4_000);
+            try {
+                terminalizeAgentRunsForExecutionRun(planningExecutionRun.id, 'error', failureMessage);
+            }
+            catch {
+                // Preserve the top-level execution failure when child detail finalization fails.
+            }
+            transitionExecutionRun({
+                projectId: project.id,
+                runId: planningExecutionRun.id,
+                status: 'failed',
+                domainStatus: 'error',
+                failure: {
+                    code: materializationCommitted ? 'planning_agent_result_reconciliation_failed' : 'planning_agent_failed',
+                    message: failureMessage,
+                },
+                eventType: 'planning_agent_failed',
+            }, io);
+        }
         if (autoCreatedBundle && countBundleTickets(autoCreatedBundle.id, project.id) === 0) {
             deleteBundle(autoCreatedBundle.id, project.id);
         }
@@ -5986,7 +6694,14 @@ app.delete('/projects/:id', (req, res) => {
             error: 'Cannot delete a project with existing tickets, bundles, or worktrees',
         });
     }
-    db.prepare('DELETE FROM projects WHERE id = ?').run(req.params.id);
+    db.transaction(() => {
+        db.prepare(`
+      UPDATE execution_runs
+      SET parent_run_id = NULL, retry_of_run_id = NULL
+      WHERE project_id = ?
+    `).run(req.params.id);
+        db.prepare('DELETE FROM projects WHERE id = ?').run(req.params.id);
+    })();
     res.status(204).end();
 });
 app.post('/tickets', (req, res) => {
@@ -6259,11 +6974,14 @@ app.post('/tickets/delete-parked', async (req, res) => {
         deleted_ticket_ids: [],
         failures: [],
     };
+    const sequenceContinuations = [];
     for (const ticket of parkedTickets) {
         const deleteResult = await deleteTicketRecord(ticket);
         if (deleteResult.ok) {
             summary.deleted_count += 1;
             summary.deleted_ticket_ids.push(ticket.id);
+            emitUpdatedTickets(deleteResult.affectedTicketIds ?? []);
+            sequenceContinuations.push(deleteResult);
             continue;
         }
         summary.failed_count += 1;
@@ -6273,6 +6991,11 @@ app.post('/tickets/delete-parked', async (req, res) => {
             error: deleteResult.error,
         });
     }
+    for (const continuation of sequenceContinuations) {
+        if (continuation.nextBuildTicketId && getTicket(continuation.nextBuildTicketId)) {
+            scheduleBuildAfterTicketDeletion(continuation);
+        }
+    }
     return res.json(summary);
 });
 app.post('/tickets/:id/build-chain', (req, res) => {
@@ -6286,22 +7009,43 @@ app.post('/tickets/:id/build-chain', (req, res) => {
     if (!existing.project_id) {
         return res.status(400).json({ error: 'Ticket project no longer exists' });
     }
-    const chainStart = startBuildChain(existing.id, existing.project_id);
-    if (!chainStart.ok) {
-        return res.status(chainStart.status).json({ error: chainStart.error });
-    }
-    const buildTransition = prepareTicketForBuild(chainStart.activeTicketId);
-    if (!buildTransition.ok) {
-        stopBuildChain(chainStart.activeTicketId);
-        return res.status(buildTransition.status).json({
-            error: buildTransition.error,
-            ...(buildTransition.blockers ? { blockers: buildTransition.blockers } : {}),
+    const validation = prepareTicketForBuild(existing.id, { updateState: false });
+    if (!validation.ok) {
+        return res.status(validation.status).json({
+            error: validation.error,
+            ...(validation.blockers ? { blockers: validation.blockers } : {}),
         });
     }
-    emitUpdatedTickets(chainStart.affectedTicketIds);
-    io.emit('ticket:updated', buildTransition.ticket);
-    res.json(buildTransition.ticket);
-    startBuild(buildTransition.ticket, io);
+    let affectedTicketIds = [];
+    let activeTicketId = existing.id;
+    const acceptChain = () => {
+        const chainStart = startBuildChain(existing.id, existing.project_id);
+        if (!chainStart.ok) {
+            throw new Error(chainStart.error);
+        }
+        affectedTicketIds = chainStart.affectedTicketIds;
+        activeTicketId = chainStart.activeTicketId;
+        const buildTransition = prepareTicketForBuild(chainStart.activeTicketId);
+        if (!buildTransition.ok) {
+            throw new Error(buildTransition.error);
+        }
+        return {
+            ticket: buildTransition.ticket,
+            sequenceId: chainStart.sequenceId,
+            compensate: () => compensateBuildSequenceAcceptance(chainStart.sequenceId, chainStart.affectedTicketIds),
+        };
+    };
+    const scheduling = startBuild(existing, io, { accept: acceptChain });
+    if (scheduling === undefined) {
+        acceptChain();
+    }
+    else if (!scheduling.accepted) {
+        return res.status(scheduling.reason === 'queue_failed' ? 503 : 409).json({ error: scheduling.error });
+    }
+    emitUpdatedTickets(affectedTicketIds);
+    const updated = getTicket(activeTicketId);
+    io.emit('ticket:updated', updated);
+    return res.json(updated);
 });
 app.post('/tickets/:id/stop-build-chain', (req, res) => {
     const existing = getTicket(req.params.id);
@@ -6335,31 +7079,152 @@ app.post('/tickets/:id/retry', (req, res) => {
         && hasActiveBuildOpenQuestionBatch(ticket.project_id, ticket.worktree_bundle_id)) {
         return res.status(409).json({ error: 'Build open question resolution is still in progress' });
     }
-    db.prepare('UPDATE tickets SET agent_status = NULL, agent_log = NULL, agent_message_id = NULL, previous_agent_log = NULL, previous_agent_message_id = NULL, streaming_response = NULL, build_completed_at = NULL, auto_park_dismissed_at = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(req.params.id);
-    const updated = getTicket(req.params.id);
-    io.emit('ticket:updated', updated);
-    res.json(updated);
-    if (ticket.state === 'build' && updated) {
-        if (updated.project_id && updated.worktree_bundle_id) {
-            const buildBlocker = getBundleBuildBlockerResponse(updated);
+    if (ticket.state === 'build') {
+        if (ticket.project_id && ticket.worktree_bundle_id) {
+            const buildBlocker = getBundleBuildBlockerResponse(ticket);
             if (buildBlocker) {
-                return;
+                return res.status(409).json({ error: buildBlocker.error, blocker_ticket_id: buildBlocker.blocker_ticket_id });
             }
-            const queuedBuild = enqueueBundledBuild({
-                ticketId: updated.id,
-                projectId: updated.project_id,
-                worktreeBundleId: updated.worktree_bundle_id,
-                activate: shouldStartBundleBuildNow(updated),
-            });
-            if (!queuedBuild.shouldStartNow) {
-                return;
+        }
+        const retrySource = ticket.project_id
+            ? db.prepare(`
+          SELECT er.id
+          FROM execution_runs er
+          INNER JOIN execution_run_links link
+            ON link.execution_run_id = er.id
+            AND link.project_id = er.project_id
+            AND link.relationship = 'primary'
+            AND link.entity_type = 'ticket'
+          WHERE er.project_id = ?
+            AND er.kind = 'build'
+            AND er.status IN ('failed', 'interrupted')
+            AND link.entity_id = ?
+          ORDER BY er.created_at DESC, er.id DESC
+          LIMIT 1
+        `).get(ticket.project_id, ticket.id)
+            : undefined;
+        const acceptRetry = () => {
+            db.prepare('UPDATE tickets SET agent_status = NULL, agent_log = NULL, agent_message_id = NULL, previous_agent_log = NULL, previous_agent_message_id = NULL, streaming_response = NULL, build_completed_at = NULL, auto_park_dismissed_at = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(req.params.id);
+            const updated = getTicket(req.params.id);
+            if (!updated) {
+                throw new Error('Not found');
+            }
+            let sequenceId = null;
+            if (updated.project_id && updated.worktree_bundle_id) {
+                sequenceId = enqueueBundledBuild({
+                    ticketId: updated.id,
+                    projectId: updated.project_id,
+                    worktreeBundleId: updated.worktree_bundle_id,
+                    activate: shouldStartBundleBuildNow(updated),
+                }).sequenceId;
+            }
+            return {
+                ticket: updated,
+                sequenceId,
+                ...(sequenceId ? { compensate: () => compensateBuildSequenceAcceptance(sequenceId, [updated.id]) } : {}),
+            };
+        };
+        if (ticket.project_id && ticket.worktree_bundle_id && hasActiveSequenceForBundle(ticket.project_id, ticket.worktree_bundle_id)) {
+            try {
+                withExecutionRunTransaction(transaction => {
+                    const acceptance = acceptRetry();
+                    if (!acceptance.sequenceId) {
+                        throw new Error('Build sequence no longer exists');
+                    }
+                    transaction.createExecutionRun({
+                        projectId: ticket.project_id,
+                        kind: 'build',
+                        domainStatus: 'queued',
+                        sourceReference: { kind: 'ticket', id: acceptance.ticket.id, label: acceptance.ticket.title },
+                        links: [
+                            { entityType: 'bundle', entityId: ticket.worktree_bundle_id, relationship: 'context' },
+                            { entityType: 'build_sequence', entityId: acceptance.sequenceId, relationship: 'context' },
+                        ],
+                        initiatedBy: 'user',
+                        retryOfRunId: retrySource?.id ?? null,
+                        eventType: 'build_created',
+                    });
+                }, io);
             }
+            catch (error) {
+                return res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+            }
+            const updated = getTicket(req.params.id);
+            io.emit('ticket:updated', updated);
+            return res.json(updated);
         }
-        startBuild(updated, io);
+        const scheduling = startBuild(ticket, io, {
+            initiation: { initiator: 'user', retrySourceRunId: retrySource?.id ?? null },
+            accept: acceptRetry,
+        });
+        if (scheduling === undefined) {
+            acceptRetry();
+        }
+        else if (!scheduling.accepted) {
+            return res.status(scheduling.reason === 'queue_failed' ? 503 : 409).json({ error: scheduling.error });
+        }
+        const updated = getTicket(req.params.id);
+        io.emit('ticket:updated', updated);
+        return res.json(updated);
     }
-    if (ticket.state === 'review' && updated) {
-        startReview(updated, io);
+    const reviewRetrySource = ticket.state === 'review' && ticket.project_id
+        ? db.prepare(`
+        SELECT er.id
+        FROM execution_runs er
+        JOIN execution_run_links link
+          ON link.execution_run_id = er.id
+          AND link.relationship = 'primary'
+          AND link.entity_type = 'ticket'
+        WHERE er.project_id = ?
+          AND er.kind = 'review'
+          AND er.status IN ('failed', 'interrupted')
+          AND link.entity_id = ?
+        ORDER BY er.created_at DESC, er.id DESC
+        LIMIT 1
+      `).get(ticket.project_id, ticket.id)
+        : undefined;
+    if (ticket.state === 'review') {
+        const reviewSnapshot = {
+            agent_status: ticket.agent_status,
+            agent_log: ticket.agent_log,
+            agent_message_id: ticket.agent_message_id,
+            previous_agent_log: ticket.previous_agent_log,
+            previous_agent_message_id: ticket.previous_agent_message_id,
+            streaming_response: ticket.streaming_response,
+            build_completed_at: ticket.build_completed_at,
+            auto_park_dismissed_at: ticket.auto_park_dismissed_at,
+        };
+        const reviewResult = rerunTicketReviewOperation(ticket, io, {
+            initiation: { retrySourceRunId: reviewRetrySource?.id ?? null },
+            accept: () => {
+                db.prepare('UPDATE tickets SET agent_status = NULL, agent_log = NULL, agent_message_id = NULL, previous_agent_log = NULL, previous_agent_message_id = NULL, streaming_response = NULL, build_completed_at = NULL, auto_park_dismissed_at = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(req.params.id);
+                const acceptedTicket = getTicket(req.params.id);
+                if (!acceptedTicket) {
+                    throw new Error('Not found');
+                }
+                return {
+                    ticket: acceptedTicket,
+                    compensate: () => {
+                        db.prepare(`
+              UPDATE tickets SET agent_status = ?, agent_log = ?, agent_message_id = ?, previous_agent_log = ?,
+                previous_agent_message_id = ?, streaming_response = ?, build_completed_at = ?, auto_park_dismissed_at = ?,
+                updated_at = CURRENT_TIMESTAMP WHERE id = ?
+            `).run(reviewSnapshot.agent_status, reviewSnapshot.agent_log, reviewSnapshot.agent_message_id, reviewSnapshot.previous_agent_log, reviewSnapshot.previous_agent_message_id, reviewSnapshot.streaming_response, reviewSnapshot.build_completed_at, reviewSnapshot.auto_park_dismissed_at, ticket.id);
+                    },
+                };
+            },
+        });
+        if (!reviewResult.ok) {
+            return res.status(reviewResult.status).json({ error: reviewResult.error });
+        }
+        const updated = getTicket(req.params.id);
+        io.emit('ticket:updated', updated);
+        return res.json(updated);
     }
+    db.prepare('UPDATE tickets SET agent_status = NULL, agent_log = NULL, agent_message_id = NULL, previous_agent_log = NULL, previous_agent_message_id = NULL, streaming_response = NULL, auto_park_dismissed_at = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(req.params.id);
+    const updated = getTicket(req.params.id);
+    io.emit('ticket:updated', updated);
+    return res.json(updated);
 });
 app.post('/tickets/:id/review', (req, res) => {
     const ticket = getTicket(req.params.id);
@@ -6663,6 +7528,111 @@ app.post('/projects/:id/test-sessions', (req, res) => {
         targetLabel: workspace.target_label,
     }));
 });
+app.get('/projects/:id/execution-runs', (req, res) => {
+    const project = getProjectById(req.params.id);
+    if (!project) {
+        return res.status(404).json({ error: 'Not found' });
+    }
+    const query = parseLifecycleListQuery(req.query);
+    if ('error' in query) {
+        return res.status(400).json({ error: query.error });
+    }
+    try {
+        return res.json(listExecutionRuns({
+            projectId: project.id,
+            kind: query.kind,
+            statuses: query.statuses,
+            cursor: query.cursor,
+            limit: query.limit,
+        }));
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'Invalid execution run cursor') {
+            return res.status(400).json({ error: 'cursor must be a valid execution run cursor' });
+        }
+        throw error;
+    }
+});
+app.get('/projects/:id/lifecycle-events', (req, res) => {
+    const project = getProjectById(req.params.id);
+    if (!project) {
+        return res.status(404).json({ error: 'Not found' });
+    }
+    const query = parseLifecycleListQuery(req.query);
+    if ('error' in query) {
+        return res.status(400).json({ error: query.error });
+    }
+    try {
+        const page = listProjectLifecycleEvents({
+            projectId: project.id,
+            kind: query.kind,
+            statuses: query.statuses,
+            cursor: query.cursor,
+            limit: query.limit,
+        });
+        return res.json({
+            ...page,
+            events: page.events.map(toCanonicalLifecycleEvent),
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'Invalid lifecycle event cursor') {
+            return res.status(400).json({ error: 'cursor must be a valid lifecycle event cursor' });
+        }
+        throw error;
+    }
+});
+app.get('/projects/:id/execution-runs/:runId', (req, res) => {
+    const project = getProjectById(req.params.id);
+    if (!project) {
+        return res.status(404).json({ error: 'Not found' });
+    }
+    const run = getExecutionRun(project.id, req.params.runId);
+    if (!run) {
+        return res.status(404).json({ error: 'Execution run not found' });
+    }
+    const testDetails = run.kind === 'test' ? getTestExecutionDetails(project.id, run.id) : null;
+    const details = run.kind === 'test'
+        ? serializeTestExecutionDetail(testDetails, resolveTestRetry(project, run, testDetails).eligibility)
+        : run.kind === 'github_actions'
+            ? serializeGitHubActionsExecutionDetail(getGitHubActionsExecutionDetails(project.id, run.id))
+            : { kind: run.kind, available: true };
+    const links = listExecutionRunLinks(project.id, run.id);
+    const agentRuns = listAgentRunsForExecutionRun(run.id);
+    return res.json({ run, links, details, agent_runs: agentRuns });
+});
+app.post('/projects/:id/execution-runs/:runId/retry', async (req, res) => {
+    const project = getProjectById(req.params.id);
+    if (!project) {
+        return res.status(404).json({ error: 'Not found' });
+    }
+    const executionRun = getExecutionRun(project.id, req.params.runId);
+    const details = getTestExecutionDetails(project.id, req.params.runId);
+    const retry = resolveTestRetry(project, executionRun, details);
+    if ('error' in retry) {
+        return res.status(retry.error.status).json({ error: retry.error.message });
+    }
+    const session = createTestSession({
+        projectId: project.id,
+        ticketId: retry.details.ticket_id,
+        targetKind: retry.workspace.target_kind,
+        targetBundleId: retry.workspace.target_bundle_id,
+        cwd: retry.workspace.cwd,
+        targetLabel: retry.workspace.target_label,
+    });
+    try {
+        return res.status(201).json(await startTestSessionRun(session.id, project, {
+            command: retry.command,
+            selection: retry.selection,
+            retryOfRunId: retry.executionRun.id,
+            deleteOnComplete: true,
+        }, io));
+    }
+    catch (error) {
+        await deleteTestSession(session.id, io).catch(() => undefined);
+        return res.status(409).json({ error: getErrorMessage(error) });
+    }
+});
 app.post('/tickets/:id/test-sessions', (req, res) => {
     const ticket = getTicket(req.params.id);
     if (!ticket) {
@@ -6765,7 +7735,7 @@ app.post('/test-sessions/:id/stop', async (req, res) => {
     }
 });
 app.delete('/test-sessions/:id', async (req, res) => {
-    const deleted = await deleteTestSession(req.params.id, io);
+    const deleted = await deleteTestSession(req.params.id, io, { purgeExecutionRun: true });
     if (!deleted) {
         return res.status(404).json({ error: 'Not found' });
     }
@@ -6846,6 +7816,16 @@ app.post('/tickets/:id/stop-build', async (req, res) => {
     }
     return res.status(result.status).json(result.value);
 });
+app.post('/tickets/:id/stop-review', async (req, res) => {
+    const result = await stopReviewTicketRun({
+        ticketId: req.params.id,
+        requestedProjectId: getRequestedProjectId(req),
+    });
+    if (!result.ok) {
+        return res.status(result.status).json({ error: result.error });
+    }
+    return res.status(result.status).json(result.value);
+});
 app.post('/tickets/:id/resume-build', (req, res) => {
     const result = resumeBuildTicketRun({
         ticketId: req.params.id,
@@ -6908,8 +7888,14 @@ app.post('/tickets/:id/plan', (req, res) => {
             });
         }
     }
-    startPlan(ticket, io, { branch });
-    res.status(202).json({ ok: true });
+    const scheduling = startPlan(ticket, io, {
+        branch,
+    });
+    if (!scheduling.accepted) {
+        const status = scheduling.reason === 'queue_failed' ? 503 : 409;
+        return res.status(status).json({ error: scheduling.error });
+    }
+    return res.status(202).json({ ok: true, execution_run_id: scheduling.executionContext.runId });
 });
 app.delete('/tickets/:id', async (req, res) => {
     const ticket = getTicket(req.params.id);
@@ -6926,12 +7912,7 @@ app.delete('/tickets/:id', async (req, res) => {
     if (result.affectedTicketIds) {
         emitUpdatedTickets(result.affectedTicketIds);
     }
-    if (result.nextBuildTicketId) {
-        const nextTicket = getTicket(result.nextBuildTicketId);
-        if (nextTicket) {
-            startBuild(nextTicket, io);
-        }
-    }
+    scheduleBuildAfterTicketDeletion(result);
     res.status(204).end();
 });
 const clientBuild = resolveClientBuildPaths(import.meta.url);
@@ -6958,6 +7939,33 @@ io.on('connection', (socket) => {
     registerTerminalSocketHandlers(io, socket);
 });
 const DEFAULT_PORT = 3001;
+let executionEvidenceCleanupTimer = null;
+let startServerPromise = null;
+let shutdownServerPromise = null;
+let shutdownRequested = false;
+const throwIfShutdownRequested = () => {
+    if (shutdownRequested) {
+        throw new Error('Server startup was cancelled by shutdown');
+    }
+};
+const runExecutionEvidenceCleanup = () => {
+    try {
+        const result = cleanupAllExecutionEvidence({ retentionDays: resolveExecutionEvidenceRetentionDays() });
+        if (result.total > 0) {
+            console.log(`Expired execution evidence for ${result.total} run(s): ${result.test_output} test output, ${result.github_jobs} GitHub job snapshot(s)`);
+        }
+    }
+    catch (error) {
+        console.error('Failed to clean up expired execution evidence', error);
+    }
+};
+const startExecutionEvidenceCleanupTimer = () => {
+    if (executionEvidenceCleanupTimer) {
+        return;
+    }
+    executionEvidenceCleanupTimer = setInterval(runExecutionEvidenceCleanup, EXECUTION_EVIDENCE_CLEANUP_INTERVAL_MS);
+    executionEvidenceCleanupTimer.unref();
+};
 const resolveStartResult = (host) => {
     const address = httpServer.address();
     const { displayHost } = resolveDesktopServerHost(host);
@@ -6975,37 +7983,83 @@ const resolveStartResult = (host) => {
     };
 };
 export const startServer = ({ port = DEFAULT_PORT, host } = {}) => {
-    return new Promise((resolve, reject) => {
-        if (httpServer.listening) {
-            resolve(resolveStartResult(host));
-            return;
+    if (shutdownRequested) {
+        return Promise.reject(new Error('Server startup was cancelled by shutdown'));
+    }
+    if (httpServer.listening) {
+        return Promise.resolve(resolveStartResult(host));
+    }
+    if (startServerPromise) {
+        return startServerPromise;
+    }
+    startServerPromise = (async () => {
+        await reconcileStartupExecutions({ getGitHubConfig: getGitHubConnectionConfig });
+        throwIfShutdownRequested();
+        startGitHubActionsPolling(io);
+        try {
+            throwIfShutdownRequested();
+            await new Promise((resolve, reject) => {
+                const handleError = (error) => {
+                    httpServer.off('error', handleError);
+                    reject(error);
+                };
+                const handleListening = () => {
+                    httpServer.off('error', handleError);
+                    resolve();
+                };
+                httpServer.once('error', handleError);
+                const { bindHost } = resolveDesktopServerHost(host);
+                httpServer.listen(port, bindHost, handleListening);
+            });
         }
-        const handleError = (error) => {
-            httpServer.off('error', handleError);
-            reject(error);
-        };
-        const handleListening = () => {
-            httpServer.off('error', handleError);
-            resolve(resolveStartResult(host));
-        };
-        httpServer.once('error', handleError);
-        const { bindHost } = resolveDesktopServerHost(host);
-        httpServer.listen(port, bindHost, handleListening);
+        catch (error) {
+            await clearAllGitHubActionsSessions();
+            throw error;
+        }
+        throwIfShutdownRequested();
+        runExecutionEvidenceCleanup();
+        throwIfShutdownRequested();
+        startExecutionEvidenceCleanupTimer();
+        return resolveStartResult(host);
+    })().finally(() => {
+        startServerPromise = null;
     });
+    return startServerPromise;
 };
 export const shutdownServer = async (signal) => {
-    await stopMobileAccess();
-    await clearAllTestSessions(io);
-    await clearAllGitHubActionsSessions();
-    await shutdownRealtimeServer({
-        signal,
-        io,
-        httpServer,
-        closeAllTerminalSessions,
-        clearAllPreviewProxies,
-        stopAllBuildAgents,
-        stopAllTickets,
+    if (shutdownServerPromise) {
+        return shutdownServerPromise;
+    }
+    shutdownRequested = true;
+    const pendingStartup = startServerPromise;
+    shutdownServerPromise = (async () => {
+        await Promise.all([
+            pendingStartup?.catch(() => undefined),
+            stopAllPlanAgents(),
+        ]);
+        if (executionEvidenceCleanupTimer) {
+            clearInterval(executionEvidenceCleanupTimer);
+            executionEvidenceCleanupTimer = null;
+        }
+        await stopMobileAccess();
+        await clearAllTestSessions(io);
+        await clearAllGitHubActionsSessions();
+        await shutdownRealtimeServer({
+            signal,
+            io,
+            httpServer,
+            closeAllTerminalSessions,
+            clearAllPreviewProxies,
+            stopAllBuildAgents,
+            stopAllReviewAgents,
+            stopAllPlanAgents,
+            stopAllTickets,
+        });
+    })().finally(() => {
+        shutdownRequested = false;
+        shutdownServerPromise = null;
     });
+    return shutdownServerPromise;
 };
 export const registerShutdownHandlers = () => {
     const createHandler = (signal) => {