@straiffi/archon 1.7.2 → 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, stopAllReviewAgents } 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, 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;
+            }
+        }
+        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) };
         }
-        movedTickets.push(buildTransition.ticket);
+        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,35 +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. Treat every submitted decision as authoritative and do not return an answered or dismissed batch question as open.',
-        formatBuildOpenQuestionAnswersPrompt(answeredQuestions),
-    ].join('\n\n');
-    setBuildOpenQuestionBatchStatus(created.batch.id, 'running');
-    clearAutomationPause(result.project.id, bundle.id);
-    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) => {
@@ -3652,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));
@@ -3667,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) {
@@ -3689,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' });
@@ -3707,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' });
     }
@@ -3723,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' });
@@ -3751,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 });
@@ -3772,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);
     }
@@ -4415,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 });
         }
@@ -4636,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);
@@ -4670,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({
@@ -4686,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);
         }
@@ -5987,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) => {
@@ -6260,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;
@@ -6274,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) => {
@@ -6287,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);
@@ -6336,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);
+        }
+        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 });
         }
-        startBuild(updated, io);
+        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);
@@ -6664,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) {
@@ -6766,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' });
     }
@@ -6919,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);
@@ -6937,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);
@@ -6969,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);
@@ -6986,38 +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,
-        stopAllReviewAgents,
-        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) => {