@straiffi/archon 1.7.3 → 1.7.5

package/dist/server/index.js

@@ -10,7 +10,7 @@ import { adjectives, animals, uniqueNamesGenerator } from 'unique-names-generato
 import db from './db.js';
 import { deleteChatSession, getChatSession, listChatSessions, updateChatSessionMode } from './lib/chats.js';
 import { deleteSpecSession, getCreatedTicketIdsForSnapshot, getSpecSession, getSpecSnapshot, listSpecSessions } from './lib/specs.js';
-import { createChatAttachment, createSpecAttachment, getAttachmentById, deleteChatAttachment, deleteSpecSessionAttachment, getChatAttachmentForSession, getChatAttachmentLinkedMessageId, getSpecAttachmentForSession, getSpecAttachmentLinkedMessageId, MAX_CHAT_ATTACHMENTS_PER_TURN, MAX_CHAT_ATTACHMENT_SIZE_BYTES, MAX_SPEC_ATTACHMENTS_PER_TURN, MAX_SPEC_ATTACHMENT_SIZE_BYTES, readChatAttachmentContent, readSpecAttachmentContent, validateImageAttachment, } from './lib/attachments.js';
+import { createChatAttachment, createSpecAttachment, getAttachmentById, deleteChatAttachment, deleteProjectAttachments, deleteSpecSessionAttachment, getChatAttachmentForSession, getChatAttachmentLinkedMessageId, getSpecAttachmentForSession, getSpecAttachmentLinkedMessageId, MAX_CHAT_ATTACHMENTS_PER_TURN, MAX_CHAT_ATTACHMENT_SIZE_BYTES, MAX_SPEC_ATTACHMENTS_PER_TURN, MAX_SPEC_ATTACHMENT_SIZE_BYTES, readChatAttachmentContent, readSpecAttachmentContent, validateImageAttachment, } from './lib/attachments.js';
 import { createProjectChatSession, resolveChatMode, resolveChatTool, stopProjectChatSessionResponse, submitProjectChatSessionMessage, } from './lib/chatOperations.js';
 import { createProjectSpecSession, deleteProjectSpecSession, stopProjectSpecSessionResponse, submitProjectSpecSessionMessage, updateProjectSpecSessionMode, } from './lib/specOperations.js';
 import { buildProjectSpecReviewRevisionDraft, getProjectSpecReviewFindings, startProjectSpecReview, stopProjectSpecReview, } from './lib/specReviewOperations.js';
@@ -54,8 +54,12 @@ import { clearAutomationPause, countBlockingFindings, depthAtLeast, getBundleAut
 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 { createExecutionRun, addExecutionRunLink, addExecutionRunLinks, getExecutionRun, hasActiveBuildExecutionRunForTicket, getGitHubActionsExecutionDetails, getTestExecutionDetails, GitHubActionsDispatchConflictError, listExecutionRunLinks, listExecutionRuns, listLifecycleEvents, listProjectLifecycleEvents, toCanonicalLifecycleEvent, transitionExecutionRun, withExecutionRunTransaction, } from './lib/executionRuns.js';
+import { dispatchExecutionRetry, getExecutionRetryEligibility, resolveExecutionRetry } from './lib/executionRetry.js';
+import { listExecutionTimeline } from './lib/executionTimeline.js';
+import { loadExecutionArtifactSummariesForRuns, openExecutionArtifactForRetrieval, } from './lib/executionArtifacts.js';
 import { cleanupAllExecutionEvidence, EXECUTION_EVIDENCE_CLEANUP_INTERVAL_MS, resolveExecutionEvidenceRetentionDays, } from './lib/executionRunRetention.js';
+import { ExecutionArtifactCleanupError, reconcileExecutionArtifactRegistrationIntents, reconcileFinalizedExecutionArtifacts, reconcileProjectExecutionArtifacts, resolveArtifactCleanupIntervalMs, } from './lib/executionArtifactRetention.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';
@@ -70,9 +74,9 @@ import { PlanningReferenceError, resolveExternalPlanningDescription } from './li
 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 { countInboundProjectLinks, getEffectiveProject, getProjectById, getProjectTicketStats, hasProjectRunIde, listInterruptedProjectDeletions, listProjects, releaseInterruptedProjectDeletionClaims, 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, doesTestFileExist, doesTestFileExistForSession, findProjectTestCommand, getTestSession, isTestSelectionSupported, startTestSessionRun, stopTestSessionRun } from './lib/testSessions.js';
+import { clearAllTestSessions, createTestSession, deleteTestSession, discoverTestsForSession, 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';
@@ -92,7 +96,30 @@ 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 { expandPlanningTicketOutline, generatePlanningTicketOutline, generatePlanText, prepareLinkedPlanningResearch, startPlan, stopAllPlanAgents, } from './workers/plan.js';
-import { EXECUTION_RUN_KINDS, validateWorkflowContext } from './lib/types.js';
+import { EXECUTION_RUN_KINDS, MAX_ARTIFACTS_PER_RUN, validateWorkflowContext } from './lib/types.js';
+class ProjectDeletionError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = 'ProjectDeletionError';
+        this.status = status;
+    }
+}
+let executionArtifactMaintenanceTail = Promise.resolve();
+const runExclusiveExecutionArtifactMaintenance = async (task) => {
+    const previous = executionArtifactMaintenanceTail;
+    let release = () => undefined;
+    executionArtifactMaintenanceTail = new Promise(resolve => {
+        release = resolve;
+    });
+    await previous;
+    try {
+        return await task();
+    }
+    finally {
+        release();
+    }
+};
 const getErrorMessage = (error) => {
     return error instanceof Error ? error.message : String(error);
 };
@@ -110,6 +137,9 @@ const requireExistingProject = (projectId) => {
     if (!project) {
         return { status: 404, error: 'Not found' };
     }
+    if (project.deletion_started_at) {
+        return { status: 409, error: 'Project deletion is in progress' };
+    }
     return { project };
 };
 const requireProjectMemoryProject = (projectId) => {
@@ -167,6 +197,44 @@ const parseLifecycleListQuery = (query) => {
         limit,
     };
 };
+const parseExecutionTimelineScope = (projectId, query) => {
+    const hasScopeType = query.scope_type != null && query.scope_type !== '';
+    const hasScopeId = query.scope_id != null && query.scope_id !== '';
+    if (hasScopeType !== hasScopeId) {
+        return { error: 'scope_type and scope_id must be provided together' };
+    }
+    if (!hasScopeType) {
+        return { scopeEntity: undefined };
+    }
+    if (typeof query.scope_type !== 'string' || typeof query.scope_id !== 'string') {
+        return { error: 'scope_type and scope_id must be strings' };
+    }
+    const scopeType = query.scope_type;
+    const scopeId = query.scope_id.trim();
+    if (!['ticket', 'bundle', 'chat_session', 'spec_session'].includes(scopeType)) {
+        return { error: 'scope_type must be ticket, bundle, chat_session, or spec_session' };
+    }
+    if (!scopeId) {
+        return { error: 'scope_id must not be empty' };
+    }
+    const table = scopeType === 'ticket'
+        ? 'tickets'
+        : scopeType === 'bundle'
+            ? 'worktree_bundles'
+            : scopeType === 'chat_session'
+                ? 'chat_sessions'
+                : 'spec_sessions';
+    const exists = db.prepare(`SELECT 1 FROM ${table} WHERE id = ? AND project_id = ?`).get(scopeId, projectId);
+    if (!exists) {
+        return { error: 'Scope not found', status: 404 };
+    }
+    return {
+        scopeEntity: {
+            type: scopeType,
+            id: scopeId,
+        },
+    };
+};
 const serializeTestExecutionDetail = (details, retryEligibility) => {
     if (!details) {
         return { kind: 'test', available: false, retry_eligibility: retryEligibility };
@@ -221,6 +289,26 @@ const serializeGitHubActionsExecutionDetail = (details) => {
         jobs_count: details.jobs_count,
     };
 };
+const buildExecutionRunDetailResponse = (project, run) => {
+    const retryEligibility = getExecutionRetryEligibility(project.id, run.id);
+    const details = run.kind === 'test'
+        ? serializeTestExecutionDetail(getTestExecutionDetails(project.id, run.id), retryEligibility)
+        : run.kind === 'github_actions'
+            ? { ...serializeGitHubActionsExecutionDetail(getGitHubActionsExecutionDetails(project.id, run.id)), retry_eligibility: retryEligibility }
+            : ['automation_commit', 'automation_push', 'automation_pull_request'].includes(run.kind)
+                ? { kind: run.kind, available: true, automation_stage: getAutomationStageDetails(project.id, run.id), retry_eligibility: retryEligibility }
+                : { kind: run.kind, available: true, retry_eligibility: retryEligibility };
+    const artifacts = loadExecutionArtifactSummariesForRuns(project.id, [run.id], MAX_ARTIFACTS_PER_RUN).get(run.id)
+        ?? { artifacts: [], artifact_count: 0 };
+    return {
+        run,
+        links: listExecutionRunLinks(project.id, run.id),
+        events: listLifecycleEvents(project.id, run.id).map(toCanonicalLifecycleEvent),
+        details,
+        agent_runs: listAgentRunsForExecutionRun(run.id),
+        ...artifacts,
+    };
+};
 const formatWorktreeDeleteError = (target, branch, error) => {
     return `Unable to delete the ${target} worktree for branch "${branch}": ${getErrorMessage(error)}`;
 };
@@ -947,63 +1035,6 @@ 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) {
@@ -2417,6 +2448,17 @@ app.post('/projects/:id/chat-sessions/:sessionId/attachments', (req, res) => {
         if (error) {
             return res.status(400).json({ error: getChatAttachmentUploadErrorMessage(error) });
         }
+        const currentProject = getProjectById(req.params.id);
+        if (!currentProject) {
+            return res.status(404).json({ error: 'Not found' });
+        }
+        const currentChatSession = getProjectChatSession(currentProject.id, req.params.sessionId);
+        if (!currentChatSession) {
+            return res.status(404).json({ error: 'Not found' });
+        }
+        if (currentChatSession.agent_status === 'running') {
+            return res.status(409).json({ error: 'Wait for the current chat response to finish before uploading images.' });
+        }
         const files = (req.files ?? []);
         if (files.length === 0) {
             return res.status(400).json({ error: 'At least one image is required.' });
@@ -2434,11 +2476,11 @@ app.post('/projects/:id/chat-sessions/:sessionId/attachments', (req, res) => {
         try {
             const attachments = files.map(file => {
                 const attachment = createChatAttachment({
-                    chatSessionId: chatSession.id,
+                    chatSessionId: currentChatSession.id,
                     originalName: file.originalname,
                     mimeType: file.mimetype,
                     buffer: file.buffer,
-                    projectId: project.id,
+                    projectId: currentProject.id,
                 });
                 createdAttachmentIds.push(attachment.id);
                 return attachment;
@@ -2709,6 +2751,17 @@ app.post('/projects/:id/spec-sessions/:sessionId/attachments', (req, res) => {
         if (error) {
             return res.status(400).json({ error: getSpecAttachmentUploadErrorMessage(error) });
         }
+        const currentProject = getProjectById(req.params.id);
+        if (!currentProject) {
+            return res.status(404).json({ error: 'Not found' });
+        }
+        const currentSpecSession = getProjectSpecSession(currentProject.id, req.params.sessionId);
+        if (!currentSpecSession) {
+            return res.status(404).json({ error: 'Not found' });
+        }
+        if (currentSpecSession.agent_status === 'running') {
+            return res.status(409).json({ error: 'Wait for the current spec response to finish before uploading images.' });
+        }
         const files = (req.files ?? []);
         if (files.length === 0) {
             return res.status(400).json({ error: 'At least one image is required.' });
@@ -2726,11 +2779,11 @@ app.post('/projects/:id/spec-sessions/:sessionId/attachments', (req, res) => {
         try {
             const attachments = files.map(file => {
                 const attachment = createSpecAttachment({
-                    specSessionId: specSession.id,
+                    specSessionId: currentSpecSession.id,
                     originalName: file.originalname,
                     mimeType: file.mimetype,
                     buffer: file.buffer,
-                    projectId: project.id,
+                    projectId: currentProject.id,
                 });
                 createdAttachmentIds.push(attachment.id);
                 return attachment;
@@ -6676,32 +6729,114 @@ app.patch('/projects/:id', (req, res) => {
     const updated = db.prepare('SELECT * FROM projects WHERE id = ?').get(req.params.id);
     res.json(serializeProject(updated ?? null));
 });
-app.delete('/projects/:id', (req, res) => {
-    const project = getProjectById(req.params.id);
+const assertProjectDeletionEligible = (projectId, claimId) => {
+    const project = db.prepare('SELECT * FROM projects WHERE id = ?').get(projectId);
     if (!project) {
-        return res.status(404).json({ error: 'Not found' });
+        throw new ProjectDeletionError(404, 'Not found');
     }
-    const projectCount = Number(db.prepare('SELECT COUNT(*) AS count FROM projects').get()?.count ?? 0);
+    if (claimId ? project.deletion_claim_id !== claimId : Boolean(project.deletion_started_at)) {
+        throw new ProjectDeletionError(409, 'Project deletion is already in progress');
+    }
+    const projectCount = Number(db.prepare(`
+    SELECT COUNT(*) AS count FROM projects
+    WHERE deletion_started_at IS NULL OR id = ?
+  `).get(projectId)?.count ?? 0);
     if (projectCount <= 1) {
-        return res.status(409).json({ error: 'Cannot delete the last remaining project' });
+        throw new ProjectDeletionError(409, 'Cannot delete the last remaining project');
     }
-    if (countInboundProjectLinks(project.id) > 0) {
-        return res.status(409).json({ error: 'Cannot delete a project that is linked from another project' });
+    if (countInboundProjectLinks(projectId) > 0) {
+        throw new ProjectDeletionError(409, 'Cannot delete a project that is linked from another project');
     }
-    const stats = getProjectTicketStats(project.id);
+    const stats = getProjectTicketStats(projectId);
     if (stats.ticketCount > 0 || stats.worktreeCount > 0 || stats.bundleCount > 0) {
-        return res.status(409).json({
-            error: 'Cannot delete a project with existing tickets, bundles, or worktrees',
-        });
+        throw new ProjectDeletionError(409, 'Cannot delete a project with existing tickets, bundles, or worktrees');
     }
-    db.transaction(() => {
+};
+const completeClaimedProjectDeletion = async (projectId, claimId) => {
+    await runExclusiveExecutionArtifactMaintenance(() => reconcileProjectExecutionArtifacts(projectId, {
+        emitter: io,
+        beginCleanup: () => {
+            const marked = db.prepare(`
+        UPDATE projects
+        SET deletion_cleanup_started_at = COALESCE(deletion_cleanup_started_at, CURRENT_TIMESTAMP)
+        WHERE id = ? AND deletion_claim_id = ?
+      `).run(projectId, claimId);
+            if (marked.changes !== 1) {
+                throw new ProjectDeletionError(409, 'Project deletion ownership was lost');
+            }
+        },
+        finalize: () => {
+            db.transaction(() => {
+                assertProjectDeletionEligible(projectId, claimId);
+                if (db.prepare('SELECT 1 FROM execution_artifact_registration_intents WHERE project_id = ? LIMIT 1').get(projectId)) {
+                    throw new ExecutionArtifactCleanupError('active_registration', 'Cannot delete project while an artifact registration is active');
+                }
+                if (db.prepare("SELECT 1 FROM execution_artifacts WHERE project_id = ? AND availability <> 'deleted' LIMIT 1").get(projectId)) {
+                    throw new ExecutionArtifactCleanupError('cleanup_failed', 'Cannot delete project because artifact file cleanup failed');
+                }
+                db.prepare("DELETE FROM execution_artifacts WHERE project_id = ? AND availability = 'deleted'").run(projectId);
+                deleteProjectAttachments(projectId);
+                db.prepare(`
+          UPDATE execution_runs
+          SET parent_run_id = NULL, retry_of_run_id = NULL
+          WHERE project_id = ?
+        `).run(projectId);
+                const deleted = db.prepare('DELETE FROM projects WHERE id = ? AND deletion_claim_id = ?').run(projectId, claimId);
+                if (deleted.changes !== 1) {
+                    throw new ProjectDeletionError(409, 'Project deletion ownership was lost');
+                }
+            })();
+        },
+    }));
+};
+export const resumeInterruptedProjectDeletions = async () => {
+    for (const project of listInterruptedProjectDeletions()) {
+        try {
+            await completeClaimedProjectDeletion(project.id, project.deletion_claim_id);
+        }
+        catch (error) {
+            console.error(`Failed to resume deletion for project ${project.id}`, error);
+        }
+    }
+};
+app.delete('/projects/:id', async (req, res) => {
+    const claimId = randomUUID();
+    try {
+        db.transaction(() => {
+            assertProjectDeletionEligible(req.params.id);
+            const claimed = db.prepare(`
+        UPDATE projects
+        SET deletion_started_at = CURRENT_TIMESTAMP, deletion_claim_id = ?
+        WHERE id = ? AND deletion_started_at IS NULL
+      `).run(claimId, req.params.id);
+            if (claimed.changes !== 1) {
+                throw new ProjectDeletionError(409, 'Project deletion is already in progress');
+            }
+        })();
+    }
+    catch (error) {
+        if (error instanceof ProjectDeletionError) {
+            return res.status(error.status).json({ error: error.message });
+        }
+        throw error;
+    }
+    try {
+        await completeClaimedProjectDeletion(req.params.id, claimId);
+    }
+    catch (error) {
         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);
-    })();
+      UPDATE projects
+      SET deletion_started_at = NULL, deletion_claim_id = NULL, deletion_cleanup_started_at = NULL
+      WHERE id = ? AND deletion_claim_id = ? AND deletion_cleanup_started_at IS NULL
+    `).run(req.params.id, claimId);
+        if (error instanceof ExecutionArtifactCleanupError) {
+            return res.status(409).json({ error: error.message });
+        }
+        if (error instanceof ProjectDeletionError) {
+            return res.status(error.status).json({ error: error.message });
+        }
+        throw error;
+    }
     res.status(204).end();
 });
 app.post('/tickets', (req, res) => {
@@ -7582,56 +7717,139 @@ app.get('/projects/:id/lifecycle-events', (req, res) => {
         throw error;
     }
 });
-app.get('/projects/:id/execution-runs/:runId', (req, res) => {
+app.get('/projects/:id/execution-timeline', (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 });
+    }
+    const scope = parseExecutionTimelineScope(project.id, req.query);
+    if ('error' in scope) {
+        return res.status(scope.status ?? 400).json({ error: scope.error });
+    }
+    try {
+        return res.json(listExecutionTimeline({
+            project,
+            kind: query.kind,
+            statuses: query.statuses,
+            cursor: query.cursor,
+            limit: query.limit,
+            scope: scope.scopeEntity,
+        }));
+    }
+    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/execution-timeline/:runId', (req, res) => {
+    const project = getProjectById(req.params.id);
+    if (!project) {
+        return res.status(404).json({ error: 'Not found' });
+    }
+    const scope = parseExecutionTimelineScope(project.id, req.query);
+    if ('error' in scope) {
+        return res.status(scope.status ?? 400).json({ error: scope.error });
+    }
     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 });
+    if (scope.scopeEntity && !links.some(link => link.entity_type === scope.scopeEntity?.type && link.entity_id === scope.scopeEntity.id)) {
+        return res.status(404).json({ error: 'Execution run not found' });
+    }
+    return res.json(buildExecutionRunDetailResponse(project, run));
 });
-app.post('/projects/:id/execution-runs/:runId/retry', async (req, res) => {
+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 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 run = getExecutionRun(project.id, req.params.runId);
+    if (!run) {
+        return res.status(404).json({ error: 'Execution run not found' });
     }
-    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,
+    return res.json(buildExecutionRunDetailResponse(project, run));
+});
+app.get('/projects/:id/execution-runs/:runId/artifacts/:artifactId', async (req, res) => {
+    const project = getProjectById(req.params.id);
+    if (!project || !getExecutionRun(project.id, req.params.runId)) {
+        return res.status(404).json({ error: 'Not found' });
+    }
+    const retrieval = await openExecutionArtifactForRetrieval(project.id, req.params.runId, req.params.artifactId, io);
+    if (retrieval.kind === 'not_found') {
+        return res.status(404).json({ error: 'Not found' });
+    }
+    if (retrieval.kind === 'unavailable') {
+        return res.status(410).json({ error: 'Artifact unavailable' });
+    }
+    if (retrieval.kind === 'external') {
+        res.setHeader('Referrer-Policy', 'no-referrer');
+        res.setHeader('Location', retrieval.url);
+        return res.status(303).end();
+    }
+    res.setHeader('Content-Type', retrieval.mediaType);
+    res.setHeader('Content-Length', retrieval.byteSize);
+    res.setHeader('Content-Disposition', `attachment; filename="${retrieval.filename}"`);
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    const stream = retrieval.handle.createReadStream({ autoClose: true });
+    stream.on('error', () => {
+        console.error('Execution artifact stream failed', {
+            project_id: project.id,
+            execution_run_id: req.params.runId,
+            artifact_id: req.params.artifactId,
+        });
+        res.destroy();
     });
-    try {
-        return res.status(201).json(await startTestSessionRun(session.id, project, {
-            command: retry.command,
-            selection: retry.selection,
-            retryOfRunId: retry.executionRun.id,
-            deleteOnComplete: true,
-        }, io));
+    res.on('close', () => {
+        if (!stream.destroyed) {
+            stream.destroy();
+        }
+    });
+    return stream.pipe(res);
+});
+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' });
     }
-    catch (error) {
-        await deleteTestSession(session.id, io).catch(() => undefined);
-        return res.status(409).json({ error: getErrorMessage(error) });
+    const resolution = resolveExecutionRetry(project.id, req.params.runId);
+    const result = await dispatchExecutionRetry(resolution, io, async (retry) => {
+        const session = createTestSession({
+            projectId: project.id,
+            ticketId: retry.ticketId,
+            targetKind: retry.workspace.target_kind,
+            targetBundleId: retry.workspace.target_bundle_id,
+            cwd: retry.workspace.cwd,
+            targetLabel: retry.workspace.target_label,
+        });
+        try {
+            const started = await startTestSessionRun(session.id, project, {
+                command: retry.command,
+                selection: retry.selection,
+                retryOfRunId: req.params.runId,
+                deleteOnComplete: true,
+            }, io);
+            if (!started.run_id) {
+                throw new Error('Test retry did not create a replacement execution');
+            }
+            return started.run_id;
+        }
+        catch (error) {
+            await deleteTestSession(session.id, io).catch(() => undefined);
+            throw error;
+        }
+    });
+    if (!result.ok) {
+        return res.status(result.status).json({ error: result.error, reason: result.reason });
     }
+    return res.status(201).json(result.value);
 });
 app.post('/tickets/:id/test-sessions', (req, res) => {
     const ticket = getTicket(req.params.id);
@@ -7735,7 +7953,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, { purgeExecutionRun: true });
+    const deleted = await deleteTestSession(req.params.id, io);
     if (!deleted) {
         return res.status(404).json({ error: 'Not found' });
     }
@@ -7890,6 +8108,7 @@ app.post('/tickets/:id/plan', (req, res) => {
     }
     const scheduling = startPlan(ticket, io, {
         branch,
+        targetBundleId,
     });
     if (!scheduling.accepted) {
         const status = scheduling.reason === 'queue_failed' ? 503 : 409;
@@ -7934,12 +8153,21 @@ if (clientBuild) {
         });
     });
 }
+app.use((error, _req, res, next) => {
+    if (error instanceof Error && error.message.includes('Project is being deleted')) {
+        res.status(409).json({ error: 'Project deletion is in progress' });
+        return;
+    }
+    next(error);
+});
 io.on('connection', (socket) => {
     console.log('client connected:', socket.id);
     registerTerminalSocketHandlers(io, socket);
 });
 const DEFAULT_PORT = 3001;
 let executionEvidenceCleanupTimer = null;
+let executionArtifactCleanupTimer = null;
+let executionArtifactCleanupPromise = null;
 let startServerPromise = null;
 let shutdownServerPromise = null;
 let shutdownRequested = false;
@@ -7966,6 +8194,41 @@ const startExecutionEvidenceCleanupTimer = () => {
     executionEvidenceCleanupTimer = setInterval(runExecutionEvidenceCleanup, EXECUTION_EVIDENCE_CLEANUP_INTERVAL_MS);
     executionEvidenceCleanupTimer.unref();
 };
+export const runExecutionArtifactCleanup = (mode) => {
+    if (executionArtifactCleanupPromise) {
+        return executionArtifactCleanupPromise;
+    }
+    executionArtifactCleanupPromise = (async () => {
+        if (mode === 'periodic') {
+            await resumeInterruptedProjectDeletions();
+        }
+        await runExclusiveExecutionArtifactMaintenance(async () => {
+            const intents = await reconcileExecutionArtifactRegistrationIntents({ mode });
+            const artifacts = await reconcileFinalizedExecutionArtifacts({ emitter: io });
+            const failures = intents.failed.length + artifacts.failed.length;
+            if (failures > 0) {
+                console.error(`Artifact reconciliation retained ${failures} item(s) for retry`);
+            }
+            if (intents.deleted + artifacts.deleted > 0) {
+                console.log(`Reconciled ${intents.deleted} artifact registration intent(s) and expired ${artifacts.deleted} artifact(s)`);
+            }
+        });
+    })().catch(error => {
+        console.error('Failed to reconcile execution artifacts', error);
+    }).finally(() => {
+        executionArtifactCleanupPromise = null;
+    });
+    return executionArtifactCleanupPromise;
+};
+const startExecutionArtifactCleanupTimer = () => {
+    if (executionArtifactCleanupTimer) {
+        return;
+    }
+    executionArtifactCleanupTimer = setInterval(() => {
+        void runExecutionArtifactCleanup('periodic');
+    }, resolveArtifactCleanupIntervalMs());
+    executionArtifactCleanupTimer.unref();
+};
 const resolveStartResult = (host) => {
     const address = httpServer.address();
     const { displayHost } = resolveDesktopServerHost(host);
@@ -7993,8 +8256,12 @@ export const startServer = ({ port = DEFAULT_PORT, host } = {}) => {
         return startServerPromise;
     }
     startServerPromise = (async () => {
+        releaseInterruptedProjectDeletionClaims();
+        await resumeInterruptedProjectDeletions();
         await reconcileStartupExecutions({ getGitHubConfig: getGitHubConnectionConfig });
         throwIfShutdownRequested();
+        await runExecutionArtifactCleanup('startup');
+        throwIfShutdownRequested();
         startGitHubActionsPolling(io);
         try {
             throwIfShutdownRequested();
@@ -8020,6 +8287,7 @@ export const startServer = ({ port = DEFAULT_PORT, host } = {}) => {
         runExecutionEvidenceCleanup();
         throwIfShutdownRequested();
         startExecutionEvidenceCleanupTimer();
+        startExecutionArtifactCleanupTimer();
         return resolveStartResult(host);
     })().finally(() => {
         startServerPromise = null;
@@ -8041,6 +8309,11 @@ export const shutdownServer = async (signal) => {
             clearInterval(executionEvidenceCleanupTimer);
             executionEvidenceCleanupTimer = null;
         }
+        if (executionArtifactCleanupTimer) {
+            clearInterval(executionArtifactCleanupTimer);
+            executionArtifactCleanupTimer = null;
+        }
+        await executionArtifactCleanupPromise;
         await stopMobileAccess();
         await clearAllTestSessions(io);
         await clearAllGitHubActionsSessions();