@straiffi/archon 1.7.3 → 1.7.4

package/dist/server/lib/executionRetry.js

@@ -0,0 +1,694 @@
+import { existsSync } from 'fs';
+import db from '../db.js';
+import { startBuild } from '../workers/build.js';
+import { startPlan } from '../workers/plan.js';
+import { listChatAttachmentRowsForMessage, listSpecAttachmentRowsForMessage } from './attachments.js';
+import { prepareTicketForBuild } from './buildFlow.js';
+import { compensateBuildSequenceAcceptance, enqueueBundledBuild, hasActiveSequenceForBundle } from './buildSequences.js';
+import { getTicketReviewRetryEligibilityError, rerunTicketReviewOperation } from './bundleReviewOperations.js';
+import { getBundlePlanMutationBlockerById, shouldBlockPlanForBundleMutationById } from './bundleActivity.js';
+import { submitProjectChatSessionMessage } from './chatOperations.js';
+import { getChatMessage } from './chatMessages.js';
+import { doesChatSessionTargetMatchProjectTarget, resolveChatSessionTarget } from './chatTargets.js';
+import { getChatSession } from './chats.js';
+import { getDirectRetryChild, getExecutionRun, getTestExecutionDetails, hasLaterExecutionRunForPrimaryEntity, listExecutionRunLinks, withExecutionRunTransaction } from './executionRuns.js';
+import { buildExecutionRetryContext, createExecutionRetryResolutionContext, resolveExecutionRetryEligibilityFromContext } from './executionRetryContext.js';
+import { hasExecutionRetryAutomationOwnership, isLaterRunSupersededKind, isRetryableExecutionStatus, parseExecutionRetryTestSelection, RETRYABLE_AGENT_STATUSES, RETRYABLE_EXECUTION_KINDS, RETRYABLE_TEST_STATUSES, resolveExecutionRetryRunConfig, resolveExecutionRetrySessionMode, } from './executionRetryPredicates.js';
+import { getProjectBranch, resolveExistingWorktreePath } from './git.js';
+import { getEffectiveProject, getProjectById } from './projects.js';
+import { getBundleAutomationState } from './ticketAutomation.js';
+import { submitPlanTicketFollowUp, submitTicketFollowUp } from './ticketFollowUpOperations.js';
+import { getTicketMessage } from './ticketMessages.js';
+import { getBundle, getTicket, resolveTicketBranch } from './tickets.js';
+import { doesTestFileExist, findProjectTestCommand, isTestSelectionSupported } from './testSessions.js';
+import { getBundleBuildBlockerResponse } from './ticketWorkflowOperations.js';
+import { submitProjectSpecSessionMessage } from './specOperations.js';
+import { getSpecMessage } from './specMessages.js';
+import { startProjectSpecReview } from './specReviewOperations.js';
+import { getSpecSession, getSpecSnapshot } from './specs.js';
+const deny = (reason, status, message) => ({
+    eligibility: { eligible: false, reason },
+    error: { status, message },
+});
+const resolveTicketWorkspace = (ticket, project) => {
+    const branch = resolveTicketBranch(ticket);
+    if (!branch) {
+        return null;
+    }
+    if (ticket.worktree_bundle_id) {
+        const bundle = getBundle(ticket.worktree_bundle_id, project.id);
+        if (!bundle) {
+            return null;
+        }
+        if (bundle.kind === 'project_root') {
+            const branchState = getProjectBranch(project, { includeDiffStats: false });
+            return branchState.status === 'ready' && branchState.branch
+                ? { project, cwd: project.repo_path, target_kind: 'repo_root', target_bundle_id: null, target_label: branchState.branch }
+                : null;
+        }
+        else {
+            const cwd = resolveExistingWorktreePath(bundle.branch, project);
+            return cwd
+                ? { project, cwd, target_kind: 'bundle', target_bundle_id: bundle.id, target_label: bundle.name || bundle.branch }
+                : null;
+        }
+    }
+    const cwd = resolveExistingWorktreePath(branch, project);
+    return cwd
+        ? { project, cwd, target_kind: 'repo_root', target_bundle_id: null, target_label: branch }
+        : null;
+};
+const resolveTestWorkspace = (project, details) => {
+    if (details.ticket_id) {
+        const ticket = getTicket(details.ticket_id);
+        const workspace = ticket?.project_id === project.id ? resolveTicketWorkspace(ticket, project) : null;
+        return workspace
+            && workspace.target_kind === details.target_kind
+            && workspace.target_bundle_id === details.target_bundle_id
+            ? workspace
+            : null;
+    }
+    if (details.target_kind === 'bundle' && details.target_bundle_id) {
+        const bundle = getBundle(details.target_bundle_id, project.id);
+        if (!bundle || bundle.kind === 'project_root') {
+            return null;
+        }
+        const cwd = resolveExistingWorktreePath(bundle.branch, project);
+        return cwd
+            ? { project, cwd, target_kind: 'bundle', target_bundle_id: bundle.id, target_label: bundle.name || bundle.branch }
+            : null;
+    }
+    if (details.target_kind !== 'repo_root') {
+        return null;
+    }
+    const branchState = getProjectBranch(project, { includeDiffStats: false });
+    return branchState.status === 'ready' && branchState.branch
+        ? { project, cwd: project.repo_path, target_kind: 'repo_root', target_bundle_id: null, target_label: 'Repo root' }
+        : null;
+};
+const resolvePrimaryTicket = (projectId, source) => {
+    const links = listExecutionRunLinks(projectId, source.id);
+    const primaryLinks = links.filter(link => link.relationship === 'primary' && link.entity_type === 'ticket');
+    if (primaryLinks.length !== 1) {
+        return null;
+    }
+    const ticket = getTicket(primaryLinks[0].entity_id);
+    return ticket?.project_id === projectId ? ticket : null;
+};
+const resolveBundleId = (projectId, source, ticket) => {
+    const bundleLinks = listExecutionRunLinks(projectId, source.id)
+        .filter(link => link.relationship === 'context' && link.entity_type === 'bundle');
+    if (bundleLinks.length > 1) {
+        return undefined;
+    }
+    const bundleId = bundleLinks[0]?.entity_id ?? ticket.worktree_bundle_id ?? null;
+    if (bundleId !== (ticket.worktree_bundle_id ?? null)) {
+        return undefined;
+    }
+    return bundleId;
+};
+const resolvePlanTarget = (projectId, source) => {
+    const bundleId = source.metadata?.plan_target_bundle_id;
+    const branch = source.metadata?.plan_target_branch;
+    if (!Object.prototype.hasOwnProperty.call(source.metadata ?? {}, 'plan_target_bundle_id')
+        || !Object.prototype.hasOwnProperty.call(source.metadata ?? {}, 'plan_target_branch')
+        || (typeof bundleId !== 'string' && bundleId !== null)
+        || (typeof branch !== 'string' && branch !== null)) {
+        return null;
+    }
+    const bundleLinks = listExecutionRunLinks(projectId, source.id)
+        .filter(link => link.relationship === 'context' && link.entity_type === 'bundle');
+    if (bundleId === null) {
+        return bundleLinks.length === 0 ? { bundleId, branch } : null;
+    }
+    const bundle = getBundle(bundleId, projectId);
+    return bundleLinks.length === 1 && bundleLinks[0].entity_id === bundleId && bundle?.branch === branch
+        ? { bundleId, branch }
+        : null;
+};
+const hasAutomationOwnership = (source, bundleId) => {
+    const parent = source.parent_run_id ? getExecutionRun(source.project_id, source.parent_run_id) : null;
+    const state = bundleId ? getBundleAutomationState(source.project_id, bundleId) : null;
+    return hasExecutionRetryAutomationOwnership({
+        source,
+        parentKind: parent?.kind ?? null,
+        automationPausedStageRunId: state?.automation_paused_stage_run_id ?? null,
+    });
+};
+const resolveTrigger = (source, ticket) => {
+    const triggerLinks = listExecutionRunLinks(source.project_id, source.id)
+        .filter(link => link.relationship === 'trigger' && link.entity_type === 'ticket_message');
+    if (triggerLinks.length !== 1) {
+        return null;
+    }
+    const message = getTicketMessage(triggerLinks[0].entity_id);
+    const expectedKind = source.kind === 'plan_follow_up' ? 'planning_follow_up' : 'follow_up';
+    if (!message
+        || message.ticket_id !== ticket.id
+        || message.role !== 'user'
+        || message.kind !== expectedKind
+        || !message.content.trim()) {
+        return null;
+    }
+    return { id: message.id, instruction: message.content.trim() };
+};
+const resolveSessionRetry = (project, source) => {
+    const isChat = source.kind === 'chat_turn';
+    const primaryType = isChat ? 'chat_session' : 'spec_session';
+    const triggerType = isChat ? 'chat_message' : 'spec_message';
+    const links = listExecutionRunLinks(project.id, source.id);
+    const primary = links.filter(link => link.relationship === 'primary' && link.entity_type === primaryType);
+    const triggers = links.filter(link => link.relationship === 'trigger' && link.entity_type === triggerType);
+    if (primary.length !== 1 || triggers.length !== 1) {
+        return deny('retry_input_unavailable', 409, 'The exact session trigger is unavailable.');
+    }
+    const session = isChat
+        ? getChatSession(primary[0].entity_id, { includeMessages: true })
+        : getSpecSession(primary[0].entity_id, { includeMessages: true });
+    const message = isChat ? getChatMessage(triggers[0].entity_id) : getSpecMessage(triggers[0].entity_id);
+    const messageBelongsToSession = isChat
+        ? message !== null && 'chat_session_id' in message && message.chat_session_id === session?.id
+        : message !== null && 'spec_session_id' in message && message.spec_session_id === session?.id;
+    if (!session
+        || session.project_id !== project.id
+        || session.agent_status === 'running'
+        || !message
+        || !messageBelongsToSession
+        || message.role !== 'user'
+        || message.kind !== 'prompt') {
+        return deny(session?.agent_status === 'running' ? 'retry_target_busy' : 'retry_input_unavailable', 409, 'The session retry input is unavailable.');
+    }
+    const attachments = isChat
+        ? listChatAttachmentRowsForMessage(session.id, message.id)
+        : listSpecAttachmentRowsForMessage(session.id, message.id);
+    const expectedAttachmentCount = source.metadata?.retry_attachment_count;
+    if (!Number.isInteger(expectedAttachmentCount)
+        || expectedAttachmentCount !== attachments.length
+        || (!message.content.trim() && attachments.length === 0)
+        || attachments.some(attachment => !existsSync(attachment.storage_path))) {
+        return deny('retry_input_unavailable', 409, 'The session retry input is unavailable.');
+    }
+    const replay = buildExecutionRetryContext({ messages: session.messages ?? [], triggerMessageId: message.id });
+    if (!replay.ok) {
+        if (replay.hasLaterUserTurn) {
+            return deny('attempt_superseded', 409, 'A newer session turn has already advanced the conversation.');
+        }
+        return deny('retry_input_unavailable', 409, 'The pre-trigger conversation is unavailable.');
+    }
+    if (hasLaterExecutionRunForPrimaryEntity({
+        projectId: project.id,
+        sourceRunId: source.id,
+        kind: isChat ? 'chat_turn' : 'spec_turn',
+        entityType: primaryType,
+        entityId: session.id,
+    })) {
+        return deny('attempt_superseded', 409, 'A newer session turn has already advanced the conversation.');
+    }
+    const runConfig = resolveExecutionRetryRunConfig(source);
+    if (!runConfig) {
+        return deny('retry_input_unavailable', 409, 'The original provider configuration is unavailable.');
+    }
+    const sessionMode = resolveExecutionRetrySessionMode(source);
+    if (!sessionMode) {
+        return deny('retry_input_unavailable', 409, 'The original session mode is unavailable.');
+    }
+    if (isChat) {
+        const target = resolveChatSessionTarget(session, project);
+        if (!target.target_available || !doesChatSessionTargetMatchProjectTarget(session, project)) {
+            return deny('retry_workspace_unavailable', 409, 'The Chat workspace is unavailable.');
+        }
+    }
+    else if (!existsSync(project.repo_path)) {
+        return deny('retry_workspace_unavailable', 409, 'The Spec workspace is unavailable.');
+    }
+    let priorSnapshotId;
+    if (!isChat) {
+        const priorSnapshotLinks = links.filter(link => link.relationship === 'context' && link.entity_type === 'spec_snapshot');
+        const resultSnapshotLinks = links.filter(link => link.relationship === 'result' && link.entity_type === 'spec_snapshot');
+        if (priorSnapshotLinks.length > 1 || resultSnapshotLinks.length > 0) {
+            return deny('retry_input_unavailable', 409, 'The prior Spec snapshot is unavailable.');
+        }
+        priorSnapshotId = priorSnapshotLinks[0]?.entity_id ?? null;
+        if (priorSnapshotId && getSpecSnapshot(priorSnapshotId)?.spec_session_id !== session.id) {
+            return deny('retry_input_unavailable', 409, 'The prior Spec snapshot is unavailable.');
+        }
+    }
+    return {
+        eligibility: { eligible: true, reason: null },
+        source,
+        project,
+        ticket: null,
+        bundleId: null,
+        triggerMessageId: message.id,
+        instruction: message.content.trim(),
+        followUpMode: null,
+        sessionId: session.id,
+        attachments,
+        conversationContext: replay.context,
+        priorSnapshotId,
+        runConfig: runConfig ?? undefined,
+        sessionMode: sessionMode,
+    };
+};
+const resolveSpecReviewRetry = (project, source) => {
+    const links = listExecutionRunLinks(project.id, source.id);
+    const primary = links.filter(link => link.relationship === 'primary' && link.entity_type === 'spec_session');
+    const snapshots = links.filter(link => link.relationship === 'context' && link.entity_type === 'spec_snapshot');
+    const runConfig = resolveExecutionRetryRunConfig(source);
+    const boundary = source.metadata?.retry_transcript_boundary_message_id;
+    if (primary.length !== 1 || snapshots.length !== 1 || !runConfig || typeof boundary !== 'string') {
+        return deny('retry_input_unavailable', 409, 'The Spec Review input is unavailable.');
+    }
+    const session = getSpecSession(primary[0].entity_id, { includeMessages: true });
+    const snapshot = getSpecSnapshot(snapshots[0].entity_id);
+    const boundaryId = boundary === 'none' ? null : boundary;
+    if (!session
+        || session.project_id !== project.id
+        || !snapshot
+        || snapshot.spec_session_id !== session.id
+        || (boundaryId && !session.messages?.some(message => message.id === boundaryId))) {
+        return deny('retry_input_unavailable', 409, 'The Spec Review input is unavailable.');
+    }
+    return {
+        eligibility: { eligible: true, reason: null },
+        source,
+        project,
+        ticket: null,
+        bundleId: null,
+        triggerMessageId: null,
+        instruction: null,
+        followUpMode: null,
+        sessionId: session.id,
+        priorSnapshotId: snapshot.id,
+        transcriptBoundaryMessageId: boundaryId,
+        runConfig: runConfig ?? undefined,
+    };
+};
+const resolveTestRetry = (project, source) => {
+    const details = getTestExecutionDetails(project.id, source.id);
+    if (!details?.command_id) {
+        return deny('retry_input_unavailable', 409, 'The original test command is no longer identifiable.');
+    }
+    const command = findProjectTestCommand(project, details.command_id);
+    const selection = parseExecutionRetryTestSelection(details.selection);
+    if (!command || !selection) {
+        return deny('retry_input_unavailable', 409, 'The original test input is no longer available.');
+    }
+    const workspace = resolveTestWorkspace(project, details);
+    if (!workspace) {
+        return deny('retry_workspace_unavailable', 409, 'The original test workspace is no longer available.');
+    }
+    if (!isTestSelectionSupported(command, selection, workspace.cwd)) {
+        return deny('retry_input_unavailable', 409, 'The original test selection is no longer supported.');
+    }
+    if (selection.kind !== 'all' && !doesTestFileExist(workspace.cwd, selection.path, command)) {
+        return deny('retry_input_unavailable', 409, 'The selected test file no longer exists.');
+    }
+    return {
+        eligibility: { eligible: true, reason: null },
+        source,
+        project,
+        ticket: details.ticket_id ? getTicket(details.ticket_id) : null,
+        bundleId: workspace.target_bundle_id,
+        triggerMessageId: null,
+        instruction: null,
+        followUpMode: null,
+        test: { command, selection, workspace, ticketId: details.ticket_id },
+    };
+};
+export const resolveExecutionRetry = (projectId, runId) => {
+    const project = getProjectById(projectId);
+    const source = project ? getExecutionRun(project.id, runId) : null;
+    if (!project || !source) {
+        return deny('retry_target_missing', 404, 'Execution run not found');
+    }
+    const links = listExecutionRunLinks(project.id, source.id);
+    const eligibility = resolveExecutionRetryEligibilityFromContext(createExecutionRetryResolutionContext({ project, runs: [source], links }), source.id);
+    if (!eligibility.eligible) {
+        return deny(eligibility.reason, eligibility.reason === 'retry_target_missing' ? 404 : 409, 'This execution is not eligible for retry.');
+    }
+    if (!RETRYABLE_EXECUTION_KINDS.has(source.kind)) {
+        return deny('unsupported_kind', 409, 'This execution kind cannot be retried through the generic retry API.');
+    }
+    if (!isRetryableExecutionStatus(source.kind, source.status)) {
+        return deny('status_not_retryable', 409, 'Only failed, cancelled, or interrupted executions can be retried.');
+    }
+    const directChild = getDirectRetryChild(project.id, source.id);
+    if (directChild) {
+        return (directChild.kind === 'test' ? RETRYABLE_TEST_STATUSES : RETRYABLE_AGENT_STATUSES).has(directChild.status)
+            ? deny('retry_source_superseded', 409, 'Retry the latest replacement attempt instead.')
+            : deny('retry_already_created', 409, 'A retry has already been created for this execution.');
+    }
+    if (source.kind === 'test') {
+        return resolveTestRetry(project, source);
+    }
+    if (source.kind === 'chat_turn' || source.kind === 'spec_turn') {
+        return resolveSessionRetry(project, source);
+    }
+    if (source.kind === 'spec_review') {
+        return resolveSpecReviewRetry(project, source);
+    }
+    const ticket = resolvePrimaryTicket(project.id, source);
+    if (!ticket) {
+        return deny('retry_target_missing', 404, 'The execution ticket no longer exists.');
+    }
+    if (isLaterRunSupersededKind(source.kind) && hasLaterExecutionRunForPrimaryEntity({
+        projectId: project.id,
+        sourceRunId: source.id,
+        kind: source.kind,
+        entityType: 'ticket',
+        entityId: ticket.id,
+    })) {
+        return deny('attempt_superseded', 409, 'A newer ticket execution has already advanced this workflow.');
+    }
+    const planTarget = source.kind === 'plan' ? resolvePlanTarget(project.id, source) : undefined;
+    const bundleId = source.kind === 'plan' ? planTarget?.bundleId : resolveBundleId(project.id, source, ticket);
+    const bundle = bundleId ? getBundle(bundleId, project.id) : null;
+    if ((source.kind === 'plan' && !planTarget) || bundleId === undefined || (bundleId && !bundle)) {
+        return deny('retry_target_missing', 404, 'The execution bundle no longer exists.');
+    }
+    if (hasAutomationOwnership(source, bundleId)) {
+        return deny('automation_resume_required', 409, 'This execution is owned by automation and must be resumed through automation recovery.');
+    }
+    if (ticket.agent_status === 'running') {
+        return deny('retry_target_busy', 409, 'The execution ticket is already running.');
+    }
+    const effectiveProject = getEffectiveProject(ticket);
+    if (!effectiveProject || effectiveProject.id !== project.id || !existsSync(project.repo_path)) {
+        return deny('retry_workspace_unavailable', 409, 'The execution workspace is unavailable.');
+    }
+    if (source.kind === 'plan' && bundle && bundle.kind !== 'project_root' && !resolveExistingWorktreePath(bundle.branch, project)) {
+        return deny('retry_workspace_unavailable', 409, 'The preserved Plan worktree is unavailable.');
+    }
+    if (source.kind === 'plan' && ticket.state !== 'plan') {
+        return deny('retry_state_incompatible', 409, 'The ticket is no longer in Plan.');
+    }
+    if (source.kind === 'plan'
+        && shouldBlockPlanForBundleMutationById(bundleId, planTarget?.branch, bundle?.branch)
+        && getBundlePlanMutationBlockerById(bundleId)) {
+        return deny('retry_target_busy', 409, 'The bundle is busy with other domain work.');
+    }
+    if (source.kind === 'build') {
+        if (ticket.state !== 'build') {
+            return deny('retry_state_incompatible', 409, 'The ticket is no longer in Build.');
+        }
+        if (getBundleBuildBlockerResponse(ticket)) {
+            return deny('retry_target_busy', 409, 'The bundle is busy with other domain work.');
+        }
+        const buildEligibility = prepareTicketForBuild(ticket.id, { updateState: false });
+        if (!buildEligibility.ok) {
+            return deny('retry_state_incompatible', buildEligibility.status, buildEligibility.error);
+        }
+    }
+    if (source.kind === 'review') {
+        const reviewError = getTicketReviewRetryEligibilityError(ticket);
+        if (reviewError) {
+            return deny('retry_state_incompatible', 409, reviewError);
+        }
+    }
+    if (source.kind === 'build_follow_up' && ticket.state === 'plan') {
+        return deny('retry_state_incompatible', 409, 'The ticket can no longer accept a Build follow-up.');
+    }
+    if (source.kind === 'plan_follow_up' && ticket.state !== 'plan') {
+        return deny('retry_state_incompatible', 409, 'The ticket can no longer accept a Plan follow-up.');
+    }
+    if ((source.kind === 'review' || source.kind === 'build_follow_up')
+        && !resolveExistingWorktreePath(resolveTicketBranch(ticket) ?? '', project)) {
+        return deny('retry_workspace_unavailable', 409, 'The execution worktree is unavailable.');
+    }
+    const trigger = source.kind === 'build_follow_up' || source.kind === 'plan_follow_up'
+        ? resolveTrigger(source, ticket)
+        : null;
+    if ((source.kind === 'build_follow_up' || source.kind === 'plan_follow_up') && !trigger) {
+        return deny('retry_input_unavailable', 409, 'The exact follow-up trigger is unavailable.');
+    }
+    const followUpMode = source.kind === 'build_follow_up'
+        ? source.metadata?.follow_up_mode
+        : null;
+    if (source.kind === 'build_follow_up' && followUpMode !== 'plan' && followUpMode !== 'build') {
+        return deny('retry_input_unavailable', 409, 'The Build follow-up mode was not preserved for this attempt.');
+    }
+    const runConfig = source.kind === 'build_follow_up' || source.kind === 'plan_follow_up'
+        ? resolveExecutionRetryRunConfig(source)
+        : undefined;
+    if ((source.kind === 'build_follow_up' || source.kind === 'plan_follow_up') && !runConfig) {
+        return deny('retry_input_unavailable', 409, 'The original follow-up provider configuration is unavailable.');
+    }
+    return {
+        eligibility: { eligible: true, reason: null },
+        source,
+        project,
+        ticket,
+        bundleId,
+        triggerMessageId: trigger?.id ?? null,
+        instruction: trigger?.instruction ?? null,
+        followUpMode: followUpMode,
+        planBranch: planTarget?.branch,
+        runConfig: runConfig ?? undefined,
+    };
+};
+const createdRetryResponse = (source) => {
+    const replacement = getDirectRetryChild(source.project_id, source.id);
+    return replacement ? {
+        execution_run_id: replacement.id,
+        retry_of_run_id: source.id,
+        attempt: replacement.attempt,
+    } : null;
+};
+const retryResponse = (source, replacementRunId) => {
+    const replacement = createdRetryResponse(source);
+    if (!replacement && !replacementRunId) {
+        throw new Error('Retry scheduling did not create a replacement execution');
+    }
+    return replacement ?? {
+        execution_run_id: replacementRunId,
+        retry_of_run_id: source.id,
+        attempt: source.attempt + 1,
+    };
+};
+export const dispatchExecutionRetry = async (resolution, broadcaster, dispatchTest) => {
+    if ('error' in resolution) {
+        return { ok: false, status: resolution.error.status, error: resolution.error.message, reason: resolution.eligibility.reason };
+    }
+    const { source, ticket } = resolution;
+    if (source.kind === 'test' && resolution.test) {
+        try {
+            const replacementRunId = await dispatchTest(resolution.test);
+            return { ok: true, value: retryResponse(source, replacementRunId) };
+        }
+        catch (error) {
+            const replacement = createdRetryResponse(source);
+            if (replacement) {
+                return { ok: true, value: replacement };
+            }
+            return { ok: false, status: 409, error: error instanceof Error ? error.message : String(error), reason: 'retry_input_unavailable' };
+        }
+    }
+    if ((source.kind === 'chat_turn' || source.kind === 'spec_turn') && resolution.sessionId && resolution.runConfig) {
+        const operation = source.kind === 'chat_turn'
+            ? submitProjectChatSessionMessage({
+                projectId: source.project_id,
+                chatSessionId: resolution.sessionId,
+                payload: { instruction: resolution.instruction },
+                broadcaster,
+                initiation: { initiator: 'user', retrySourceRunId: source.id },
+                existingTriggerMessageId: resolution.triggerMessageId ?? undefined,
+                existingAttachments: resolution.attachments,
+                providerContinuation: 'fresh',
+                conversationContext: resolution.conversationContext,
+                retryRunConfig: resolution.runConfig,
+                turnMode: resolution.sessionMode,
+            })
+            : submitProjectSpecSessionMessage({
+                projectId: source.project_id,
+                specSessionId: resolution.sessionId,
+                payload: { instruction: resolution.instruction },
+                broadcaster,
+                initiation: { initiator: 'user', retrySourceRunId: source.id },
+                existingTriggerMessageId: resolution.triggerMessageId ?? undefined,
+                existingAttachments: resolution.attachments,
+                providerContinuation: 'fresh',
+                conversationContext: resolution.conversationContext,
+                priorSnapshotId: resolution.priorSnapshotId,
+                retryRunConfig: resolution.runConfig,
+                turnMode: resolution.sessionMode,
+            });
+        if (!operation.ok) {
+            const replacement = createdRetryResponse(source);
+            if (replacement) {
+                return { ok: true, value: replacement };
+            }
+            return { ok: false, status: operation.status, error: operation.error, reason: 'retry_target_busy' };
+        }
+        return { ok: true, value: retryResponse(source) };
+    }
+    if (source.kind === 'spec_review' && resolution.sessionId && resolution.priorSnapshotId && resolution.runConfig) {
+        const operation = startProjectSpecReview({
+            projectId: source.project_id,
+            specSessionId: resolution.sessionId,
+            snapshotId: resolution.priorSnapshotId,
+            payload: undefined,
+            broadcaster,
+            retrySourceRunId: source.id,
+            retryRunConfig: resolution.runConfig,
+            transcriptBoundaryMessageId: resolution.transcriptBoundaryMessageId,
+        });
+        if (!operation.ok) {
+            const replacement = createdRetryResponse(source);
+            if (replacement) {
+                return { ok: true, value: replacement };
+            }
+            return { ok: false, status: operation.status, error: operation.error, reason: 'retry_target_busy' };
+        }
+        return { ok: true, value: retryResponse(source) };
+    }
+    if (!ticket) {
+        return { ok: false, status: 404, error: 'Retry target not found', reason: 'retry_target_missing' };
+    }
+    const initiation = { initiator: 'user', retrySourceRunId: source.id };
+    let schedulingError = null;
+    if (source.kind === 'plan') {
+        const scheduling = startPlan(ticket, broadcaster, {
+            branch: resolution.planBranch,
+            targetBundleId: resolution.bundleId,
+            initiation,
+            providerContinuation: 'fresh',
+        });
+        if (!scheduling.accepted) {
+            schedulingError = { status: scheduling.reason === 'queue_failed' ? 503 : 409, error: scheduling.error };
+        }
+    }
+    else if (source.kind === 'build') {
+        if (resolution.bundleId && hasActiveSequenceForBundle(source.project_id, resolution.bundleId)) {
+            try {
+                withExecutionRunTransaction(transaction => {
+                    const updated = db.prepare(`
+            UPDATE tickets
+            SET agent_status = NULL, agent_log = NULL, streaming_response = NULL,
+              build_completed_at = NULL, run_setup_status = NULL, updated_at = CURRENT_TIMESTAMP
+            WHERE id = ? AND project_id = ? AND agent_status IS NOT 'running' AND state = 'build'
+          `).run(ticket.id, source.project_id);
+                    if (updated.changes !== 1) {
+                        throw new Error('Ticket is already running or no longer in Build');
+                    }
+                    const acceptedTicket = getTicket(ticket.id);
+                    if (!acceptedTicket || !acceptedTicket.worktree_bundle_id) {
+                        throw new Error('Retry target not found');
+                    }
+                    const sequenceId = enqueueBundledBuild({
+                        ticketId: acceptedTicket.id,
+                        projectId: source.project_id,
+                        worktreeBundleId: acceptedTicket.worktree_bundle_id,
+                        activate: false,
+                    }).sequenceId;
+                    transaction.createExecutionRun({
+                        projectId: source.project_id,
+                        kind: 'build',
+                        domainStatus: 'queued',
+                        sourceReference: { kind: 'ticket', id: acceptedTicket.id, label: acceptedTicket.title },
+                        links: [
+                            { entityType: 'bundle', entityId: acceptedTicket.worktree_bundle_id, relationship: 'context' },
+                            { entityType: 'build_sequence', entityId: sequenceId, relationship: 'context' },
+                        ],
+                        initiatedBy: 'user',
+                        retryOfRunId: source.id,
+                        eventType: 'retry_started',
+                    });
+                }, broadcaster);
+            }
+            catch (error) {
+                schedulingError = { status: 409, error: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        else {
+            const scheduling = startBuild(ticket, broadcaster, {
+                resume: false,
+                initiation,
+                accept: () => {
+                    const updated = db.prepare(`
+          UPDATE tickets
+          SET agent_status = NULL, agent_log = NULL, streaming_response = NULL,
+            build_completed_at = NULL, run_setup_status = NULL, updated_at = CURRENT_TIMESTAMP
+          WHERE id = ? AND project_id = ? AND agent_status IS NOT 'running' AND state = 'build'
+        `).run(ticket.id, source.project_id);
+                    if (updated.changes !== 1) {
+                        throw new Error('Ticket is already running or no longer in Build');
+                    }
+                    const acceptedTicket = getTicket(ticket.id);
+                    if (!acceptedTicket) {
+                        throw new Error('Retry target not found');
+                    }
+                    const sequenceId = acceptedTicket.worktree_bundle_id
+                        ? enqueueBundledBuild({
+                            ticketId: acceptedTicket.id,
+                            projectId: source.project_id,
+                            worktreeBundleId: acceptedTicket.worktree_bundle_id,
+                            activate: true,
+                        }).sequenceId
+                        : null;
+                    return {
+                        ticket: acceptedTicket,
+                        sequenceId,
+                        ...(sequenceId ? { compensate: () => compensateBuildSequenceAcceptance(sequenceId, [acceptedTicket.id]) } : {}),
+                    };
+                },
+            });
+            if (!scheduling.accepted) {
+                schedulingError = { status: scheduling.reason === 'queue_failed' ? 503 : 409, error: scheduling.error };
+            }
+        }
+    }
+    else if (source.kind === 'review') {
+        const result = rerunTicketReviewOperation(ticket, broadcaster, { initiation });
+        if (!result.ok) {
+            schedulingError = result;
+        }
+    }
+    else if (source.kind === 'build_follow_up') {
+        const result = submitTicketFollowUp({
+            ticketId: ticket.id,
+            requestedProjectId: source.project_id,
+            payload: { instruction: resolution.instruction, mode: resolution.followUpMode },
+            broadcaster,
+            initiation,
+            existingTriggerMessageId: resolution.triggerMessageId ?? undefined,
+            providerContinuation: 'fresh',
+            retryRunConfig: resolution.runConfig,
+        });
+        if (!result.ok) {
+            schedulingError = result;
+        }
+    }
+    else if (source.kind === 'plan_follow_up') {
+        const result = submitPlanTicketFollowUp({
+            ticketId: ticket.id,
+            requestedProjectId: source.project_id,
+            payload: { instruction: resolution.instruction },
+            broadcaster,
+            initiation,
+            existingTriggerMessageId: resolution.triggerMessageId ?? undefined,
+            providerContinuation: 'fresh',
+            retryRunConfig: resolution.runConfig,
+        });
+        if (!result.ok) {
+            schedulingError = result;
+        }
+    }
+    if (schedulingError) {
+        const replacement = createdRetryResponse(source);
+        if (replacement) {
+            return { ok: true, value: replacement };
+        }
+        return { ok: false, status: schedulingError.status, error: schedulingError.error, reason: 'retry_target_busy' };
+    }
+    try {
+        return { ok: true, value: retryResponse(source) };
+    }
+    catch (error) {
+        return { ok: false, status: 409, error: error instanceof Error ? error.message : String(error), reason: 'retry_already_created' };
+    }
+};
+export const getExecutionRetryEligibility = (projectId, runId, context) => (context
+    ? resolveExecutionRetryEligibilityFromContext(context, runId)
+    : resolveExecutionRetry(projectId, runId).eligibility);
+//# sourceMappingURL=executionRetry.js.map