@straiffi/archon 1.7.2 → 1.7.4

package/dist/server/lib/executionRuns.js

@@ -0,0 +1,1367 @@
+import { randomUUID } from 'crypto';
+import db from '../db.js';
+import { EXECUTION_RUN_KINDS, EXECUTION_RUN_LINK_ENTITY_TYPES } from './types.js';
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled', 'interrupted']);
+const ACTIVE_STATUSES = new Set(['queued', 'running', 'waiting']);
+const MAX_METADATA_BYTES = 16 * 1024;
+const MAX_EVENT_MESSAGE_LENGTH = 4_000;
+const MAX_FAILURE_MESSAGE_LENGTH = 4_000;
+const MAX_JOBS_SNAPSHOT_BYTES = 64 * 1024;
+const MAX_TEST_OUTPUT_LENGTH = 256 * 1024;
+const APPROVED_EXECUTION_RUN_KINDS = new Set(EXECUTION_RUN_KINDS);
+const EXECUTION_RUN_INITIATORS = new Set(['user', 'automation', 'recovery', 'system']);
+const EXECUTION_RUN_LINK_RELATIONSHIPS = new Set(['primary', 'context', 'result', 'trigger']);
+const EXECUTION_RUN_LINK_ENTITY_TYPE_SET = new Set(EXECUTION_RUN_LINK_ENTITY_TYPES);
+const GENERIC_RETRY_DENIED_KINDS = new Set([
+    'automation_commit',
+    'automation_push',
+    'automation_pull_request',
+]);
+export class GitHubActionsDispatchConflictError extends Error {
+    executionRunId;
+    constructor(executionRunId) {
+        super('A dispatch for this project, workflow, and ref is still being resolved.');
+        this.name = 'GitHubActionsDispatchConflictError';
+        this.executionRunId = executionRunId;
+    }
+}
+const getRunStatement = db.prepare('SELECT * FROM execution_runs WHERE id = ? AND project_id = ?');
+const getRunByIdStatement = db.prepare('SELECT * FROM execution_runs WHERE id = ?');
+const projectExistsStatement = db.prepare('SELECT 1 FROM projects WHERE id = ?');
+const insertRunStatement = db.prepare(`
+  INSERT INTO execution_runs (
+    id, project_id, kind, status, domain_status, source_kind, source_id, source_label, source_url,
+    correlation_id, initiated_by, metadata_schema_version, metadata_json, parent_run_id,
+    retry_of_run_id, attempt, created_at, updated_at
+  ) VALUES (?, ?, ?, 'queued', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`);
+const insertEventStatement = db.prepare(`
+  INSERT INTO lifecycle_events (
+    id, project_id, execution_run_id, correlation_id, sequence, event_type, from_status,
+    to_status, domain_status, message, metadata_schema_version, metadata_json, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`);
+const nextEventSequenceStatement = db.prepare(`
+  SELECT COALESCE(MAX(sequence), 0) + 1 AS sequence
+  FROM lifecycle_events
+  WHERE execution_run_id = ?
+`);
+const insertRunLinkStatement = db.prepare(`
+  INSERT INTO execution_run_links (
+    execution_run_id, project_id, entity_type, entity_id, relationship,
+    label_snapshot, url_snapshot, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+`);
+const getRunLinksStatement = db.prepare(`
+  SELECT * FROM execution_run_links
+  WHERE execution_run_id = ? AND project_id = ?
+  ORDER BY created_at ASC, entity_type ASC, entity_id ASC
+`);
+const getRunLinkStatement = db.prepare(`
+  SELECT * FROM execution_run_links
+  WHERE execution_run_id = ? AND project_id = ? AND entity_type = ? AND entity_id = ? AND relationship = ?
+`);
+const getDirectRetryChildStatement = db.prepare('SELECT id FROM execution_runs WHERE retry_of_run_id = ? LIMIT 1');
+const hasLaterRunForPrimaryEntityStatement = db.prepare(`
+  SELECT 1
+  FROM execution_runs candidate
+  INNER JOIN execution_run_links candidate_primary
+    ON candidate_primary.execution_run_id = candidate.id
+    AND candidate_primary.project_id = candidate.project_id
+    AND candidate_primary.relationship = 'primary'
+  INNER JOIN execution_runs source ON source.id = ? AND source.project_id = ?
+  WHERE candidate.project_id = ?
+    AND candidate.kind = ?
+    AND candidate_primary.entity_type = ?
+    AND candidate_primary.entity_id = ?
+    AND candidate.rowid > source.rowid
+    AND candidate.retry_of_run_id IS NOT source.id
+  LIMIT 1
+`);
+const getEventStatement = db.prepare('SELECT * FROM lifecycle_events WHERE id = ? AND project_id = ?');
+const insertTestDetailsStatement = db.prepare(`
+  INSERT INTO test_execution_details (
+    execution_run_id, command_id, command_name, command_runner, command_snapshot,
+    active_command, target_kind, target_bundle_id, target_label, ticket_id,
+    selection_json, summary_json, exit_code, duration_ms, output, output_truncated,
+    output_retention_state, output_expired_at, output_byte_count
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'retained', NULL, ?)
+`);
+const insertGitHubActionsDetailsStatement = db.prepare(`
+  INSERT INTO github_actions_run_details (
+    execution_run_id, workflow_id, workflow_name, ref, input_names_json, input_fingerprint,
+    resolution_attempts, provider_error_count, provider_run_id, provider_status,
+    conclusion, html_url, head_sha, head_branch, provider_created_at, provider_updated_at,
+    provider_started_at, dispatched_at, last_synced_at, jobs_json,
+    jobs_retention_state, jobs_expired_at, jobs_count
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'retained', NULL, ?)
+`);
+const getTestTargetBundleStatement = db.prepare(`
+  SELECT id, kind
+  FROM worktree_bundles
+  WHERE id = ? AND project_id = ?
+`);
+const getTestTargetTicketStatement = db.prepare(`
+  SELECT id, worktree_bundle_id
+  FROM tickets
+  WHERE id = ? AND project_id = ?
+`);
+const updateRunStatement = db.prepare(`
+  UPDATE execution_runs
+  SET status = ?, domain_status = ?, failure_code = ?, failure_message = ?,
+      failure_details_json = ?, started_at = ?, completed_at = ?, updated_at = ?
+  WHERE id = ? AND project_id = ?
+`);
+const assertBoundedString = (value, name, maxLength) => {
+    if (value !== null && value !== undefined && value.length > maxLength) {
+        throw new Error(`${name} exceeds ${maxLength} characters`);
+    }
+};
+const normalizeBoundedMessage = (value, maxLength) => {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (value.length <= maxLength) {
+        return value;
+    }
+    const truncated = value.slice(0, maxLength);
+    const lastCodeUnit = truncated.charCodeAt(truncated.length - 1);
+    return lastCodeUnit >= 0xD800 && lastCodeUnit <= 0xDBFF
+        ? truncated.slice(0, -1)
+        : truncated;
+};
+const serializeBoundedObject = (value, name) => {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw new Error(`${name} must be JSON serializable`);
+    }
+    if (Buffer.byteLength(serialized, 'utf8') > MAX_METADATA_BYTES) {
+        throw new Error(`${name} exceeds ${MAX_METADATA_BYTES} bytes`);
+    }
+    return serialized;
+};
+const parseStoredObject = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+};
+const parseStoredArray = (value) => {
+    if (!value) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+};
+const serializeJobsSnapshot = (jobs) => {
+    if (jobs === null || jobs === undefined) {
+        return null;
+    }
+    const bounded = jobs.slice(0, 50).map(job => ({
+        ...job,
+        steps: job.steps.slice(0, 50),
+    }));
+    while (bounded.length > 0) {
+        const serialized = JSON.stringify(bounded);
+        if (Buffer.byteLength(serialized, 'utf8') <= MAX_JOBS_SNAPSHOT_BYTES) {
+            return serialized;
+        }
+        bounded.pop();
+    }
+    return '[]';
+};
+const boundTestOutput = (output, alreadyTruncated = false) => {
+    if (output.length <= MAX_TEST_OUTPUT_LENGTH) {
+        return { output, outputTruncated: alreadyTruncated };
+    }
+    return {
+        output: output.slice(-MAX_TEST_OUTPUT_LENGTH),
+        outputTruncated: true,
+    };
+};
+const SOURCE_TABLES = {
+    ticket: 'tickets',
+    project: 'projects',
+    bundle: 'worktree_bundles',
+    chat_session: 'chat_sessions',
+    spec_session: 'spec_sessions',
+};
+const loadSourceAvailability = (rows) => {
+    const availability = new Map();
+    for (const [sourceKind, table] of Object.entries(SOURCE_TABLES)) {
+        const sourceRows = rows.filter(row => row.source_kind === sourceKind && row.source_id);
+        const ids = [...new Set(sourceRows.map(row => row.source_id))];
+        if (ids.length === 0) {
+            continue;
+        }
+        const projectIds = [...new Set(sourceRows.map(row => row.project_id))];
+        const records = db.prepare(`
+      SELECT id, ${sourceKind === 'project' ? 'id' : 'project_id'} AS project_id
+      FROM ${table}
+      WHERE id IN (${ids.map(() => '?').join(', ')})
+        AND ${sourceKind === 'project' ? 'id' : 'project_id'} IN (${projectIds.map(() => '?').join(', ')})
+    `).all(...ids, ...projectIds);
+        const availableKeys = new Set(records.map(record => `${record.project_id}:${sourceKind}:${record.id}`));
+        for (const row of sourceRows) {
+            availability.set(`${row.project_id}:${sourceKind}:${row.source_id}`, availableKeys.has(`${row.project_id}:${sourceKind}:${row.source_id}`));
+        }
+    }
+    return availability;
+};
+const safeSnapshotUrl = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? value : null;
+    }
+    catch {
+        return null;
+    }
+};
+const serializeRun = (row, sourceAvailability) => ({
+    id: row.id,
+    project_id: row.project_id,
+    kind: row.kind,
+    status: row.status,
+    domain_status: row.domain_status,
+    source_reference: row.source_kind && row.source_id
+        ? {
+            kind: row.source_kind,
+            id: row.source_id,
+            label: row.source_label,
+            available: sourceAvailability?.get(`${row.project_id}:${row.source_kind}:${row.source_id}`) ?? loadSourceAvailability([row]).get(`${row.project_id}:${row.source_kind}:${row.source_id}`) ?? Boolean(safeSnapshotUrl(row.source_url)),
+            url: safeSnapshotUrl(row.source_url),
+        }
+        : null,
+    correlation_id: row.correlation_id,
+    initiated_by: row.initiated_by,
+    metadata_schema_version: row.metadata_schema_version,
+    metadata: parseStoredObject(row.metadata_json),
+    parent_run_id: row.parent_run_id,
+    retry_of_run_id: row.retry_of_run_id,
+    attempt: row.attempt,
+    failure: row.failure_message
+        ? {
+            code: row.failure_code,
+            message: row.failure_message,
+            details: parseStoredObject(row.failure_details_json),
+        }
+        : null,
+    created_at: row.created_at,
+    started_at: row.started_at,
+    completed_at: row.completed_at,
+    updated_at: row.updated_at,
+});
+const serializeEvent = (row) => ({
+    ...row,
+    metadata: parseStoredObject(row.metadata_json),
+});
+const PUBLIC_EVENT_METADATA_KEYS = new Set([
+    'candidate_run_ids',
+    'conclusion',
+    'input_names',
+    'provider_run_id',
+    'ref',
+    'resolution_attempts',
+    'trigger',
+    'workflow_id',
+]);
+export const toCanonicalLifecycleEvent = (event) => {
+    const metadata = event.metadata
+        ? Object.fromEntries(Object.entries(event.metadata).filter(([key]) => PUBLIC_EVENT_METADATA_KEYS.has(key)))
+        : null;
+    return {
+        ...event,
+        metadata: metadata && Object.keys(metadata).length > 0 ? metadata : null,
+    };
+};
+const encodeCursor = (cursor) => Buffer.from(JSON.stringify({
+    version: 1,
+    created_at: cursor.created_at,
+    id: cursor.id,
+}), 'utf8').toString('base64url');
+const decodeCursor = (value) => {
+    try {
+        const parsed = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        if (parsed.version !== 1
+            || typeof parsed.created_at !== 'string'
+            || parsed.created_at.length === 0
+            || parsed.created_at.length > 64
+            || typeof parsed.id !== 'string'
+            || parsed.id.length === 0
+            || parsed.id.length > 128) {
+            throw new Error('Invalid execution run cursor');
+        }
+        return { created_at: parsed.created_at, id: parsed.id };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'Invalid execution run cursor') {
+            throw error;
+        }
+        throw new Error('Invalid execution run cursor');
+    }
+};
+const encodeLifecycleEventCursor = (cursor) => Buffer.from(JSON.stringify({
+    version: 1,
+    created_at: cursor.created_at,
+    execution_run_id: cursor.execution_run_id,
+    sequence: cursor.sequence,
+    id: cursor.id,
+}), 'utf8').toString('base64url');
+const decodeLifecycleEventCursor = (value) => {
+    try {
+        const parsed = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        if (parsed.version !== 1
+            || typeof parsed.created_at !== 'string'
+            || parsed.created_at.length === 0
+            || parsed.created_at.length > 64
+            || typeof parsed.execution_run_id !== 'string'
+            || parsed.execution_run_id.length === 0
+            || parsed.execution_run_id.length > 128
+            || !Number.isSafeInteger(parsed.sequence)
+            || parsed.sequence < 1
+            || typeof parsed.id !== 'string'
+            || parsed.id.length === 0
+            || parsed.id.length > 128) {
+            throw new Error('Invalid lifecycle event cursor');
+        }
+        return {
+            created_at: parsed.created_at,
+            execution_run_id: parsed.execution_run_id,
+            sequence: parsed.sequence,
+            id: parsed.id,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'Invalid lifecycle event cursor') {
+            throw error;
+        }
+        throw new Error('Invalid lifecycle event cursor');
+    }
+};
+const resolveLinkLabel = (projectId, link) => {
+    if (link.label) {
+        return link.label;
+    }
+    if (link.entityType === 'ticket') {
+        const row = db.prepare('SELECT title FROM tickets WHERE id = ? AND project_id = ?').get(link.entityId, projectId);
+        return row?.title ?? null;
+    }
+    if (link.entityType === 'project') {
+        const row = db.prepare('SELECT name FROM projects WHERE id = ?').get(link.entityId);
+        return row?.name ?? null;
+    }
+    if (link.entityType === 'bundle') {
+        const row = db.prepare('SELECT name FROM worktree_bundles WHERE id = ? AND project_id = ?').get(link.entityId, projectId);
+        return row?.name ?? null;
+    }
+    if (link.entityType === 'chat_session') {
+        const row = db.prepare('SELECT title FROM chat_sessions WHERE id = ? AND project_id = ?').get(link.entityId, projectId);
+        return row?.title ?? null;
+    }
+    if (link.entityType === 'spec_session') {
+        const row = db.prepare('SELECT title FROM spec_sessions WHERE id = ? AND project_id = ?').get(link.entityId, projectId);
+        return row?.title ?? null;
+    }
+    if (link.entityType === 'bundle_pull_request') {
+        const row = db.prepare(`
+      SELECT pr_number FROM bundle_pull_requests
+      WHERE id = ? AND project_id = ?
+    `).get(link.entityId, projectId);
+        return row ? `Pull request #${row.pr_number}` : null;
+    }
+    return null;
+};
+const resolveLinkOwner = (projectId, link) => {
+    switch (link.entityType) {
+        case 'project':
+            return link.entityId === projectId && projectExistsStatement.get(link.entityId)
+                ? { parentEntityType: null, parentEntityId: null }
+                : null;
+        case 'ticket':
+            return db.prepare('SELECT 1 FROM tickets WHERE id = ? AND project_id = ?').get(link.entityId, projectId)
+                ? { parentEntityType: null, parentEntityId: null }
+                : null;
+        case 'bundle':
+            return db.prepare('SELECT 1 FROM worktree_bundles WHERE id = ? AND project_id = ?').get(link.entityId, projectId)
+                ? { parentEntityType: null, parentEntityId: null }
+                : null;
+        case 'chat_session':
+            return db.prepare('SELECT 1 FROM chat_sessions WHERE id = ? AND project_id = ?').get(link.entityId, projectId)
+                ? { parentEntityType: null, parentEntityId: null }
+                : null;
+        case 'spec_session':
+            return db.prepare('SELECT 1 FROM spec_sessions WHERE id = ? AND project_id = ?').get(link.entityId, projectId)
+                ? { parentEntityType: null, parentEntityId: null }
+                : null;
+        case 'spec_snapshot': {
+            const row = db.prepare(`
+          SELECT snapshot.spec_session_id AS parent_id FROM spec_snapshots snapshot
+          JOIN spec_sessions session ON session.id = snapshot.spec_session_id
+          WHERE snapshot.id = ? AND session.project_id = ?
+      `).get(link.entityId, projectId);
+            return row ? { parentEntityType: 'spec_session', parentEntityId: row.parent_id } : null;
+        }
+        case 'review_run': {
+            const row = db.prepare(`
+        SELECT review.ticket_id AS parent_id FROM review_runs review
+        JOIN tickets ticket ON ticket.id = review.ticket_id
+        WHERE review.id = ? AND ticket.project_id = ?
+      `).get(link.entityId, projectId);
+            return row ? { parentEntityType: 'ticket', parentEntityId: row.parent_id } : null;
+        }
+        case 'spec_review_run': {
+            const row = db.prepare(`
+        SELECT review.spec_session_id AS parent_id FROM spec_review_runs review
+        JOIN spec_sessions session ON session.id = review.spec_session_id
+        JOIN spec_snapshots snapshot
+          ON snapshot.id = review.spec_snapshot_id AND snapshot.spec_session_id = review.spec_session_id
+        WHERE review.id = ? AND review.project_id = ? AND session.project_id = ?
+      `).get(link.entityId, projectId, projectId);
+            return row ? { parentEntityType: 'spec_session', parentEntityId: row.parent_id } : null;
+        }
+        case 'build_sequence':
+            return db.prepare('SELECT 1 FROM build_sequences WHERE id = ? AND project_id = ?').get(link.entityId, projectId)
+                ? { parentEntityType: null, parentEntityId: null }
+                : null;
+        case 'github_workflow':
+            return projectExistsStatement.get(projectId)
+                ? { parentEntityType: null, parentEntityId: null }
+                : null;
+        case 'ticket_message': {
+            const row = db.prepare(`
+        SELECT message.ticket_id AS parent_id
+        FROM ticket_messages message
+        JOIN tickets ticket ON ticket.id = message.ticket_id
+        WHERE message.id = ? AND ticket.project_id = ?
+      `).get(link.entityId, projectId);
+            return row ? { parentEntityType: 'ticket', parentEntityId: row.parent_id } : null;
+        }
+        case 'chat_message': {
+            const row = db.prepare(`
+        SELECT message.chat_session_id AS parent_id
+        FROM chat_messages message
+        JOIN chat_sessions session ON session.id = message.chat_session_id
+        WHERE message.id = ? AND session.project_id = ?
+      `).get(link.entityId, projectId);
+            return row ? { parentEntityType: 'chat_session', parentEntityId: row.parent_id } : null;
+        }
+        case 'spec_message': {
+            const row = db.prepare(`
+        SELECT message.spec_session_id AS parent_id
+        FROM spec_messages message
+        JOIN spec_sessions session ON session.id = message.spec_session_id
+        WHERE message.id = ? AND session.project_id = ?
+      `).get(link.entityId, projectId);
+            return row ? { parentEntityType: 'spec_session', parentEntityId: row.parent_id } : null;
+        }
+        case 'bundle_pull_request': {
+            const row = db.prepare(`
+        SELECT pull_request.bundle_id AS parent_id
+        FROM bundle_pull_requests pull_request
+        JOIN worktree_bundles bundle
+          ON bundle.id = pull_request.bundle_id AND bundle.project_id = pull_request.project_id
+        WHERE pull_request.id = ? AND pull_request.project_id = ?
+      `).get(link.entityId, projectId);
+            return row ? { parentEntityType: 'bundle', parentEntityId: row.parent_id } : null;
+        }
+    }
+};
+const assertLinkOwnership = (projectId, link) => {
+    if (!EXECUTION_RUN_LINK_ENTITY_TYPE_SET.has(link.entityType)) {
+        throw new Error(`Unsupported execution run link entity type: ${link.entityType}`);
+    }
+    const owner = resolveLinkOwner(projectId, link);
+    if (!owner) {
+        throw new Error(`${link.entityType} ${link.entityId} does not belong to project ${projectId}`);
+    }
+    if (link.expectedParent && (owner.parentEntityType !== link.expectedParent.entityType
+        || owner.parentEntityId !== link.expectedParent.entityId)) {
+        throw new Error(`${link.entityType} ${link.entityId} does not belong to expected ${link.expectedParent.entityType} ${link.expectedParent.entityId}`);
+    }
+};
+const validateExecutionRunLink = (projectId, link) => {
+    if (!EXECUTION_RUN_LINK_RELATIONSHIPS.has(link.relationship)) {
+        throw new Error(`Unsupported execution run link relationship: ${link.relationship}`);
+    }
+    if (!EXECUTION_RUN_LINK_ENTITY_TYPE_SET.has(link.entityType)) {
+        throw new Error(`Unsupported execution run link entity type: ${link.entityType}`);
+    }
+    if (link.entityType.trim().length === 0 || link.entityId.trim().length === 0) {
+        throw new Error('Execution run links require an entity type and ID');
+    }
+    assertBoundedString(link.entityType, 'Link entity type', 100);
+    assertBoundedString(link.entityId, 'Link entity ID', 500);
+    assertBoundedString(link.url, 'Link URL', 2_000);
+    assertLinkOwnership(projectId, link);
+    const label = resolveLinkLabel(projectId, link);
+    assertBoundedString(label, 'Link label', 500);
+    return { ...link, label };
+};
+const normalizeInitialLinks = (input) => {
+    const links = [...(input.links ?? [])];
+    if (input.sourceReference) {
+        links.push({
+            entityType: input.sourceReference.kind,
+            entityId: input.sourceReference.id,
+            relationship: 'primary',
+            label: input.sourceReference.label,
+            url: input.sourceReference.url,
+        });
+    }
+    if (links.filter(link => link.relationship === 'primary').length > 1) {
+        throw new Error('Execution runs may have only one primary link');
+    }
+    return links;
+};
+const resolveCorrelationId = (parent) => {
+    if (parent) {
+        return parent.correlation_id;
+    }
+    return randomUUID();
+};
+const assertRetryEligible = (kind, retrySource, allowAutomationSideEffect) => {
+    if (!TERMINAL_STATUSES.has(retrySource.status)) {
+        throw new Error('Retry source execution run must be terminal');
+    }
+    if (kind === 'github_actions') {
+        throw new Error('GitHub Actions execution runs cannot be retried directly');
+    }
+    if (GENERIC_RETRY_DENIED_KINDS.has(kind) && !allowAutomationSideEffect) {
+        throw new Error(`${kind} execution runs cannot be retried through the generic retry API`);
+    }
+    if (kind !== 'test' && retrySource.status === 'completed') {
+        throw new Error('Completed execution runs are not eligible for retry');
+    }
+    if (hasDirectRetryChild(retrySource.id)) {
+        throw new Error(`Execution run ${retrySource.id} already has a direct retry child`);
+    }
+};
+const assertTestTarget = (projectId, details) => {
+    let expectedTargetKind = 'repo_root';
+    let expectedBundleId = null;
+    if (details.ticketId) {
+        const ticket = getTestTargetTicketStatement.get(details.ticketId, projectId);
+        if (!ticket) {
+            throw new Error(`Ticket ${details.ticketId} does not belong to project ${projectId}`);
+        }
+        if (ticket.worktree_bundle_id) {
+            const bundle = getTestTargetBundleStatement.get(ticket.worktree_bundle_id, projectId);
+            if (!bundle) {
+                throw new Error(`Ticket ${details.ticketId} bundle target does not belong to project ${projectId}`);
+            }
+            if (bundle.kind !== 'project_root') {
+                expectedTargetKind = 'bundle';
+                expectedBundleId = bundle.id;
+            }
+        }
+    }
+    else if (details.targetKind === 'bundle') {
+        const bundle = getTestTargetBundleStatement.get(details.targetBundleId, projectId);
+        if (!bundle || bundle.kind === 'project_root') {
+            throw new Error(`Bundle ${details.targetBundleId} does not belong to project ${projectId}`);
+        }
+        expectedTargetKind = 'bundle';
+        expectedBundleId = bundle.id;
+    }
+    if (details.targetKind !== expectedTargetKind || (details.targetBundleId ?? null) !== expectedBundleId) {
+        throw new Error('Test execution target does not match its ticket or bundle context');
+    }
+};
+export const hasDirectRetryChild = (runId) => Boolean(getDirectRetryChildStatement.get(runId));
+export const getDirectRetryChild = (projectId, runId) => {
+    const child = getDirectRetryChildStatement.get(runId);
+    return child ? getExecutionRun(projectId, child.id) : null;
+};
+export const hasLaterExecutionRunForPrimaryEntity = ({ projectId, sourceRunId, kind, entityType, entityId, }) => Boolean(hasLaterRunForPrimaryEntityStatement.get(sourceRunId, projectId, projectId, kind, entityType, entityId));
+const insertTestDetails = (runId, details) => {
+    const boundedOutput = boundTestOutput(details.output ?? '', details.outputTruncated);
+    insertTestDetailsStatement.run(runId, details.commandId ?? null, details.commandName ?? null, details.commandRunner ?? null, details.commandSnapshot ?? null, details.activeCommand ?? null, details.targetKind ?? null, details.targetBundleId ?? null, details.targetLabel ?? null, details.ticketId ?? null, serializeBoundedObject(details.selection, 'Test selection'), serializeBoundedObject(details.summary, 'Test summary'), details.exitCode ?? null, details.durationMs ?? null, boundedOutput.output, boundedOutput.outputTruncated ? 1 : 0, Buffer.byteLength(boundedOutput.output, 'utf8'));
+};
+const insertGitHubActionsDetails = (runId, details) => {
+    const jobsJson = serializeJobsSnapshot(details.jobs);
+    insertGitHubActionsDetailsStatement.run(runId, details.workflowId, details.workflowName ?? null, details.ref ?? null, details.inputNames ? JSON.stringify([...new Set(details.inputNames)].sort()) : null, details.inputFingerprint ?? null, details.resolutionAttempts ?? 0, details.providerErrorCount ?? 0, details.providerRunId ?? null, details.providerStatus ?? null, details.conclusion ?? null, details.htmlUrl ?? null, details.headSha ?? null, details.headBranch ?? null, details.providerCreatedAt ?? null, details.providerUpdatedAt ?? null, details.providerStartedAt ?? null, details.dispatchedAt ?? null, details.lastSyncedAt ?? null, jobsJson, details.jobs?.length ?? 0);
+};
+const getRunRow = (projectId, runId) => {
+    const row = getRunStatement.get(runId, projectId);
+    if (!row) {
+        throw new Error(`Execution run ${runId} was not found in project ${projectId}`);
+    }
+    return row;
+};
+const getRelatedRun = (projectId, runId, relation) => {
+    const row = getRunByIdStatement.get(runId);
+    if (!row) {
+        throw new Error(`${relation} execution run ${runId} was not found`);
+    }
+    if (row.project_id !== projectId) {
+        throw new Error(`${relation} execution run must belong to project ${projectId}`);
+    }
+    return row;
+};
+const assertNoLineageCycle = (runId, relatedRun, column) => {
+    const visited = new Set();
+    let current = relatedRun;
+    while (current) {
+        if (current.id === runId) {
+            throw new Error(`Execution run ${runId} would create a lineage cycle`);
+        }
+        if (visited.has(current.id)) {
+            throw new Error(`Existing execution run lineage contains a cycle at ${current.id}`);
+        }
+        visited.add(current.id);
+        const nextId = current[column];
+        current = nextId ? getRunByIdStatement.get(nextId) : undefined;
+    }
+};
+const createEvent = (input) => {
+    assertBoundedString(input.eventType, 'Lifecycle event type', 100);
+    const message = normalizeBoundedMessage(input.message, MAX_EVENT_MESSAGE_LENGTH);
+    const schemaVersion = input.metadataSchemaVersion ?? 1;
+    if (!Number.isSafeInteger(schemaVersion) || schemaVersion < 1) {
+        throw new Error('Lifecycle event metadata schema version must be a positive integer');
+    }
+    const id = input.id ?? randomUUID();
+    const run = getRunRow(input.projectId, input.runId);
+    const sequence = nextEventSequenceStatement.get(input.runId).sequence;
+    insertEventStatement.run(id, input.projectId, input.runId, run.correlation_id, sequence, input.eventType, input.fromStatus, input.toStatus, input.domainStatus, message, schemaVersion, input.metadataJson, input.createdAt);
+    const row = getEventStatement.get(id, input.projectId);
+    return serializeEvent(row);
+};
+const emitCommittedNotifications = (notifications) => {
+    for (const notification of notifications) {
+        try {
+            if (notification.event === 'execution-run:updated') {
+                notification.emitter?.emit(notification.event, notification.payload);
+            }
+            else {
+                notification.emitter?.emit(notification.event, toCanonicalLifecycleEvent(notification.payload));
+            }
+        }
+        catch {
+            // Realtime delivery is best-effort after the database transaction commits.
+        }
+    }
+};
+const enqueueRunAndEvent = (notifications, run, event, emitter) => {
+    notifications.push({ event: 'execution-run:updated', payload: run, emitter }, { event: 'lifecycle-event:created', payload: event, emitter });
+};
+const createExecutionRunInTransaction = (input, allowAutomationSideEffectRetry = false) => {
+    if (!projectExistsStatement.get(input.projectId)) {
+        throw new Error(`Project ${input.projectId} was not found`);
+    }
+    const id = input.id ?? randomUUID();
+    assertBoundedString(id, 'Execution run ID', 128);
+    if (!APPROVED_EXECUTION_RUN_KINDS.has(input.kind)) {
+        throw new Error(`Unsupported execution run kind: ${input.kind}`);
+    }
+    const initiatedBy = input.initiatedBy ?? 'user';
+    if (!EXECUTION_RUN_INITIATORS.has(initiatedBy)) {
+        throw new Error(`Unsupported execution run initiator: ${initiatedBy}`);
+    }
+    assertBoundedString(input.domainStatus, 'Domain status', 200);
+    const links = normalizeInitialLinks(input).map(link => validateExecutionRunLink(input.projectId, link));
+    const primaryLink = links.find(link => link.relationship === 'primary') ?? null;
+    const metadataSchemaVersion = input.metadataSchemaVersion ?? 1;
+    if (!Number.isSafeInteger(metadataSchemaVersion) || metadataSchemaVersion < 1) {
+        throw new Error('Execution run metadata schema version must be a positive integer');
+    }
+    const metadataJson = serializeBoundedObject(input.metadata, 'Execution run metadata');
+    let retrySource = null;
+    if (input.retryOfRunId) {
+        retrySource = getRelatedRun(input.projectId, input.retryOfRunId, 'Retry source');
+        if (retrySource.kind !== input.kind) {
+            throw new Error('Retry source execution run must have the same kind');
+        }
+        assertNoLineageCycle(id, retrySource, 'retry_of_run_id');
+        if (allowAutomationSideEffectRetry && !GENERIC_RETRY_DENIED_KINDS.has(input.kind)) {
+            throw new Error('Dedicated automation retry creation only supports automation side-effect runs');
+        }
+        assertRetryEligible(input.kind, retrySource, allowAutomationSideEffectRetry);
+    }
+    let expectedParentId = retrySource?.parent_run_id ?? null;
+    if (retrySource && input.parentRunId !== undefined && input.parentRunId !== expectedParentId) {
+        const recoveryParent = allowAutomationSideEffectRetry && typeof input.parentRunId === 'string'
+            ? getRelatedRun(input.projectId, input.parentRunId, 'Recovery parent')
+            : null;
+        if (recoveryParent?.kind !== 'automation_progression'
+            || recoveryParent.initiated_by !== 'recovery'
+            || recoveryParent.parent_run_id !== retrySource.id
+            || !ACTIVE_STATUSES.has(recoveryParent.status)) {
+            throw new Error('Retry parent execution run must match the retry source parent');
+        }
+        expectedParentId = recoveryParent.id;
+    }
+    const parentRunId = retrySource ? expectedParentId : input.parentRunId ?? null;
+    let parent = null;
+    if (parentRunId) {
+        parent = getRelatedRun(input.projectId, parentRunId, 'Parent');
+        assertNoLineageCycle(id, parent, 'parent_run_id');
+    }
+    const correlationId = resolveCorrelationId(parent);
+    if (input.kind !== 'test' && input.testDetails) {
+        throw new Error('Test execution details require a test execution run');
+    }
+    if (input.kind !== 'github_actions' && input.githubActionsDetails) {
+        throw new Error('GitHub Actions details require a github_actions execution run');
+    }
+    if (input.kind === 'github_actions' && !input.githubActionsDetails) {
+        throw new Error('GitHub Actions execution runs require domain details');
+    }
+    if (input.kind === 'test') {
+        assertTestTarget(input.projectId, input.testDetails);
+    }
+    if (input.kind === 'github_actions') {
+        const details = input.githubActionsDetails;
+        if (!Number.isSafeInteger(details.workflowId) || details.workflowId < 1) {
+            throw new Error('GitHub Actions execution runs require a positive workflow ID');
+        }
+        const conflict = db.prepare(`
+      SELECT er.id
+      FROM execution_runs er
+      JOIN github_actions_run_details ga ON ga.execution_run_id = er.id
+      WHERE er.project_id = ?
+        AND er.kind = 'github_actions'
+        AND er.status IN ('queued', 'waiting')
+        AND ga.provider_run_id IS NULL
+        AND ga.workflow_id = ?
+        AND ga.ref = ?
+      LIMIT 1
+    `).get(input.projectId, details.workflowId, details.ref ?? null);
+        if (conflict) {
+            throw new GitHubActionsDispatchConflictError(conflict.id);
+        }
+    }
+    const now = new Date().toISOString();
+    insertRunStatement.run(id, input.projectId, input.kind, input.domainStatus ?? null, primaryLink?.entityType ?? null, primaryLink?.entityId ?? null, primaryLink?.label ?? null, primaryLink?.url ?? null, correlationId, initiatedBy, metadataSchemaVersion, metadataJson, parent?.id ?? null, retrySource?.id ?? null, retrySource ? retrySource.attempt + 1 : 1, now, now);
+    for (const link of links) {
+        insertRunLinkStatement.run(id, input.projectId, link.entityType, link.entityId, link.relationship, link.label, link.url ?? null, now);
+    }
+    if (input.kind === 'test') {
+        insertTestDetails(id, input.testDetails);
+    }
+    if (input.kind === 'github_actions') {
+        insertGitHubActionsDetails(id, input.githubActionsDetails);
+    }
+    const event = createEvent({
+        projectId: input.projectId,
+        runId: id,
+        eventType: input.eventType ?? 'created',
+        fromStatus: null,
+        toStatus: 'queued',
+        domainStatus: input.domainStatus ?? null,
+        message: input.eventMessage,
+        metadataJson: serializeBoundedObject(input.eventMetadata, 'Lifecycle event metadata'),
+        createdAt: now,
+    });
+    const retryEvents = retrySource
+        ? [
+            createEvent({
+                projectId: input.projectId,
+                runId: retrySource.id,
+                eventType: 'retry_requested',
+                fromStatus: retrySource.status,
+                toStatus: retrySource.status,
+                domainStatus: retrySource.domain_status,
+                metadataJson: serializeBoundedObject({ replacement_run_id: id }, 'Lifecycle event metadata'),
+                createdAt: now,
+            }),
+            ...(event.event_type === 'retry_started'
+                ? []
+                : [createEvent({
+                        projectId: input.projectId,
+                        runId: id,
+                        eventType: 'retry_started',
+                        fromStatus: 'queued',
+                        toStatus: 'queued',
+                        domainStatus: input.domainStatus ?? null,
+                        metadataJson: serializeBoundedObject({ retry_of_run_id: retrySource.id }, 'Lifecycle event metadata'),
+                        createdAt: now,
+                    })]),
+        ]
+        : [];
+    return { run: serializeRun(getRunRow(input.projectId, id)), event, retryEvents };
+};
+const insertRunLink = (input) => {
+    if (input.link.relationship === 'primary') {
+        throw new Error('Primary execution run links can only be set at run creation');
+    }
+    const link = validateExecutionRunLink(input.projectId, input.link);
+    const existing = getRunLinkStatement.get(input.runId, input.projectId, link.entityType, link.entityId, link.relationship);
+    if (existing) {
+        throw new Error(`Execution run link already exists for ${link.entityType} ${link.entityId} as ${link.relationship}`);
+    }
+    const now = new Date().toISOString();
+    insertRunLinkStatement.run(input.runId, input.projectId, link.entityType, link.entityId, link.relationship, link.label, link.url ?? null, now);
+    return getRunLinkStatement.get(input.runId, input.projectId, link.entityType, link.entityId, link.relationship);
+};
+const addExecutionRunLinkInTransaction = (input) => {
+    getRunRow(input.projectId, input.runId);
+    return insertRunLink(input);
+};
+const addExecutionRunLinksInTransaction = (input) => {
+    getRunRow(input.projectId, input.runId);
+    return input.links.map(link => insertRunLink({
+        projectId: input.projectId,
+        runId: input.runId,
+        link,
+    }));
+};
+const transitionExecutionRunInTransaction = (input, allowAmbiguousAutomationReconciliation = false) => {
+    const current = getRunRow(input.projectId, input.runId);
+    const domainStatus = input.domainStatus === undefined ? current.domain_status : input.domainStatus;
+    const failure = input.failure
+        ? { ...input.failure, message: normalizeBoundedMessage(input.failure.message, MAX_FAILURE_MESSAGE_LENGTH) ?? '' }
+        : null;
+    assertBoundedString(domainStatus, 'Domain status', 200);
+    assertBoundedString(failure?.code, 'Failure code', 200);
+    const failureDetailsJson = serializeBoundedObject(failure?.details, 'Failure details');
+    const isAmbiguousAutomationReconciliation = allowAmbiguousAutomationReconciliation
+        && current.status === 'failed'
+        && current.domain_status === 'ambiguous'
+        && GENERIC_RETRY_DENIED_KINDS.has(current.kind)
+        && (input.status === 'completed' || input.status === 'interrupted');
+    if (TERMINAL_STATUSES.has(current.status) && !isAmbiguousAutomationReconciliation) {
+        const terminalDataAgrees = current.status === input.status
+            && current.domain_status === domainStatus
+            && current.failure_code === (failure?.code ?? null)
+            && current.failure_message === (failure?.message ?? null)
+            && current.failure_details_json === failureDetailsJson
+            && (input.completedAt === undefined || current.completed_at === input.completedAt);
+        if (!terminalDataAgrees) {
+            throw new Error(`Execution run ${input.runId} is already terminal with conflicting data`);
+        }
+        return { run: serializeRun(current), event: null };
+    }
+    if (current.status === input.status) {
+        throw new Error(`Execution run ${input.runId} is already ${input.status}`);
+    }
+    if (ACTIVE_STATUSES.has(input.status)) {
+        const activeTransitionAllowed = (current.status === 'queued' && (input.status === 'running' || input.status === 'waiting'))
+            || (current.status === 'running' && input.status === 'waiting')
+            || (current.status === 'waiting' && input.status === 'running');
+        if (!activeTransitionAllowed) {
+            throw new Error(`Illegal execution run transition from ${current.status} to ${input.status}`);
+        }
+        if (failure) {
+            throw new Error('Active execution runs cannot have failure information');
+        }
+    }
+    const now = new Date().toISOString();
+    const completedAt = TERMINAL_STATUSES.has(input.status) ? input.completedAt ?? now : null;
+    const startedAt = input.status === 'running' ? current.started_at ?? now : current.started_at;
+    updateRunStatement.run(input.status, domainStatus, failure?.code ?? null, failure?.message ?? null, failureDetailsJson, startedAt, completedAt, now, input.runId, input.projectId);
+    const event = createEvent({
+        projectId: input.projectId,
+        runId: input.runId,
+        eventType: input.eventType ?? 'status_changed',
+        fromStatus: current.status,
+        toStatus: input.status,
+        domainStatus,
+        message: input.eventMessage,
+        metadataJson: serializeBoundedObject(input.eventMetadata, 'Lifecycle event metadata'),
+        createdAt: now,
+    });
+    return { run: serializeRun(getRunRow(input.projectId, input.runId)), event };
+};
+const appendLifecycleEventInTransaction = (input) => {
+    const run = getRunRow(input.projectId, input.runId);
+    const event = createEvent({
+        projectId: input.projectId,
+        runId: input.runId,
+        eventType: input.eventType,
+        fromStatus: run.status,
+        toStatus: run.status,
+        domainStatus: input.domainStatus === undefined ? run.domain_status : input.domainStatus,
+        message: input.message,
+        metadataSchemaVersion: input.metadataSchemaVersion,
+        metadataJson: serializeBoundedObject(input.metadata, 'Lifecycle event metadata'),
+        createdAt: new Date().toISOString(),
+    });
+    return { run: serializeRun(run), event };
+};
+const isPromiseLike = (value) => {
+    if ((typeof value !== 'object' || value === null) && typeof value !== 'function') {
+        return false;
+    }
+    return typeof value.then === 'function';
+};
+const executionTransactionNotificationScopes = [];
+export const withExecutionRunTransaction = (callback, emitter) => {
+    const notifications = [];
+    const runTransaction = db.transaction(() => {
+        const transaction = {
+            createExecutionRun: input => {
+                const result = createExecutionRunInTransaction(input);
+                enqueueRunAndEvent(notifications, result.run, result.event, emitter);
+                for (const retryEvent of result.retryEvents) {
+                    notifications.push({ event: 'lifecycle-event:created', payload: retryEvent, emitter });
+                }
+                return result.run;
+            },
+            createAutomationRetryExecutionRun: input => {
+                const result = createExecutionRunInTransaction(input, true);
+                enqueueRunAndEvent(notifications, result.run, result.event, emitter);
+                for (const retryEvent of result.retryEvents) {
+                    notifications.push({ event: 'lifecycle-event:created', payload: retryEvent, emitter });
+                }
+                return result.run;
+            },
+            transitionExecutionRun: input => {
+                const result = transitionExecutionRunInTransaction(input);
+                if (result.event) {
+                    enqueueRunAndEvent(notifications, result.run, result.event, emitter);
+                }
+                return result.run;
+            },
+            reconcileAmbiguousAutomationExecutionRun: input => {
+                const result = transitionExecutionRunInTransaction(input, true);
+                if (result.event) {
+                    enqueueRunAndEvent(notifications, result.run, result.event, emitter);
+                }
+                return result.run;
+            },
+            appendLifecycleEvent: input => {
+                const result = appendLifecycleEventInTransaction(input);
+                notifications.push({ event: 'lifecycle-event:created', payload: result.event, emitter });
+                return result.event;
+            },
+            addExecutionRunLink: input => {
+                const link = addExecutionRunLinkInTransaction(input);
+                return { ...link, url_snapshot: safeSnapshotUrl(link.url_snapshot) };
+            },
+            addExecutionRunLinks: input => addExecutionRunLinksInTransaction(input).map(link => ({
+                ...link,
+                url_snapshot: safeSnapshotUrl(link.url_snapshot),
+            })),
+        };
+        const result = callback(transaction);
+        if (isPromiseLike(result)) {
+            throw new Error('Execution run transactions require a synchronous callback');
+        }
+        return result;
+    });
+    const parentNotifications = executionTransactionNotificationScopes.at(-1);
+    executionTransactionNotificationScopes.push(notifications);
+    try {
+        const result = runTransaction();
+        executionTransactionNotificationScopes.pop();
+        if (parentNotifications) {
+            parentNotifications.push(...notifications);
+        }
+        else {
+            emitCommittedNotifications(notifications);
+        }
+        return result;
+    }
+    catch (error) {
+        executionTransactionNotificationScopes.pop();
+        throw error;
+    }
+};
+export const createExecutionRun = (input, emitter) => (withExecutionRunTransaction(transaction => transaction.createExecutionRun(input), emitter));
+export const addExecutionRunLink = (input) => (withExecutionRunTransaction(transaction => transaction.addExecutionRunLink(input)));
+export const addExecutionRunLinks = (input) => (withExecutionRunTransaction(transaction => transaction.addExecutionRunLinks(input)));
+export const transitionExecutionRun = (input, emitter) => (withExecutionRunTransaction(transaction => transaction.transitionExecutionRun(input), emitter));
+export const appendLifecycleEvent = (input, emitter) => {
+    return withExecutionRunTransaction(transaction => transaction.appendLifecycleEvent(input), emitter);
+};
+export const getExecutionRun = (projectId, runId) => {
+    const row = getRunStatement.get(runId, projectId);
+    return row ? serializeRun(row) : null;
+};
+export const getExecutionRunsByIds = (projectId, runIds) => {
+    const ids = [...new Set(runIds)];
+    if (ids.length === 0) {
+        return [];
+    }
+    const rows = db.prepare(`
+    SELECT * FROM execution_runs
+    WHERE project_id = ? AND id IN (${ids.map(() => '?').join(', ')})
+  `).all(projectId, ...ids);
+    const sourceAvailability = loadSourceAvailability(rows);
+    return rows.map(row => serializeRun(row, sourceAvailability));
+};
+export const getQueuedSpecReviewExecutionRun = (projectId, snapshotId) => {
+    const row = db.prepare(`
+    SELECT execution_runs.id
+    FROM execution_runs
+    INNER JOIN execution_run_links snapshot_link
+      ON snapshot_link.execution_run_id = execution_runs.id
+      AND snapshot_link.project_id = execution_runs.project_id
+      AND snapshot_link.entity_type = 'spec_snapshot'
+      AND snapshot_link.relationship = 'context'
+    WHERE execution_runs.project_id = ?
+      AND execution_runs.kind = 'spec_review'
+      AND execution_runs.status = 'queued'
+      AND snapshot_link.entity_id = ?
+    ORDER BY execution_runs.created_at DESC, execution_runs.id DESC
+    LIMIT 1
+  `).get(projectId, snapshotId);
+    return row ? getExecutionRun(projectId, row.id) : null;
+};
+export const getQueuedBuildExecutionRun = (projectId, ticketId, sequenceId) => {
+    const row = db.prepare(`
+    SELECT execution_runs.id
+    FROM execution_runs
+    INNER JOIN execution_run_links ticket_link
+      ON ticket_link.execution_run_id = execution_runs.id
+      AND ticket_link.project_id = execution_runs.project_id
+      AND ticket_link.entity_type = 'ticket'
+      AND ticket_link.relationship = 'primary'
+    INNER JOIN execution_run_links sequence_link
+      ON sequence_link.execution_run_id = execution_runs.id
+      AND sequence_link.project_id = execution_runs.project_id
+      AND sequence_link.entity_type = 'build_sequence'
+      AND sequence_link.relationship = 'context'
+    WHERE execution_runs.project_id = ?
+      AND execution_runs.kind = 'build'
+      AND execution_runs.status = 'queued'
+      AND ticket_link.entity_id = ?
+      AND sequence_link.entity_id = ?
+    ORDER BY execution_runs.created_at ASC, execution_runs.id ASC
+    LIMIT 1
+  `).get(projectId, ticketId, sequenceId);
+    return row ? getExecutionRun(projectId, row.id) : null;
+};
+export const hasActiveBuildExecutionRunForTicket = (projectId, ticketId) => {
+    return Boolean(db.prepare(`
+    SELECT 1
+    FROM execution_runs
+    INNER JOIN execution_run_links ticket_link
+      ON ticket_link.execution_run_id = execution_runs.id
+      AND ticket_link.project_id = execution_runs.project_id
+      AND ticket_link.entity_type = 'ticket'
+      AND ticket_link.relationship = 'primary'
+    WHERE execution_runs.project_id = ?
+      AND execution_runs.kind = 'build'
+      AND execution_runs.status IN ('queued', 'running', 'waiting')
+      AND ticket_link.entity_id = ?
+    LIMIT 1
+  `).get(projectId, ticketId));
+};
+export const listExecutionRunLinks = (projectId, runId) => {
+    getRunRow(projectId, runId);
+    const links = getRunLinksStatement.all(runId, projectId);
+    return links.map(link => ({ ...link, url_snapshot: safeSnapshotUrl(link.url_snapshot) }));
+};
+export const listExecutionRunLinksForRuns = (projectId, runIds) => {
+    const ids = [...new Set(runIds)];
+    if (ids.length === 0) {
+        return [];
+    }
+    const links = db.prepare(`
+    SELECT * FROM execution_run_links
+    WHERE project_id = ? AND execution_run_id IN (${ids.map(() => '?').join(', ')})
+    ORDER BY execution_run_id ASC, created_at ASC, entity_type ASC, entity_id ASC, relationship ASC
+  `).all(projectId, ...ids);
+    return links.map(link => ({ ...link, url_snapshot: safeSnapshotUrl(link.url_snapshot) }));
+};
+const testDetailsSelect = `
+  SELECT td.*, er.project_id, er.status AS execution_status
+  FROM test_execution_details td
+  JOIN execution_runs er ON er.id = td.execution_run_id
+`;
+const serializeTestDetails = (row) => ({
+    execution_run_id: row.execution_run_id,
+    project_id: row.project_id,
+    execution_status: row.execution_status,
+    command_id: row.command_id,
+    command_name: row.command_name,
+    command_runner: row.command_runner,
+    command_snapshot: row.command_snapshot,
+    active_command: row.active_command,
+    target_kind: row.target_kind,
+    target_bundle_id: row.target_bundle_id,
+    target_label: row.target_label,
+    ticket_id: row.ticket_id,
+    selection: parseStoredObject(row.selection_json),
+    summary: parseStoredObject(row.summary_json),
+    exit_code: row.exit_code,
+    duration_ms: row.duration_ms,
+    output: row.output,
+    output_truncated: row.output_truncated === 1,
+    output_retention_state: row.output_retention_state,
+    output_expired_at: row.output_expired_at,
+    output_byte_count: row.output_byte_count ?? Buffer.byteLength(row.output, 'utf8'),
+});
+export const getTestExecutionDetails = (projectId, runId) => {
+    const row = db.prepare(`${testDetailsSelect} WHERE er.project_id = ? AND er.id = ?`)
+        .get(projectId, runId);
+    return row ? serializeTestDetails(row) : null;
+};
+export const updateTestExecutionDetails = (input) => {
+    const current = getTestExecutionDetails(input.projectId, input.runId);
+    if (!current) {
+        throw new Error(`Test execution run ${input.runId} was not found in project ${input.projectId}`);
+    }
+    const boundedOutput = input.output === undefined
+        ? { output: current.output, outputTruncated: current.output_truncated }
+        : boundTestOutput(input.output, input.outputTruncated ?? current.output_truncated);
+    db.prepare(`
+    UPDATE test_execution_details
+    SET summary_json = ?, exit_code = ?, duration_ms = ?, output = ?, output_truncated = ?,
+        output_retention_state = ?, output_expired_at = ?, output_byte_count = ?
+    WHERE execution_run_id = ?
+  `).run(input.summary === undefined ? serializeBoundedObject(current.summary, 'Test summary') : serializeBoundedObject(input.summary, 'Test summary'), input.exitCode === undefined ? current.exit_code : input.exitCode, input.durationMs === undefined ? current.duration_ms : input.durationMs, boundedOutput.output, boundedOutput.outputTruncated ? 1 : 0, input.output === undefined ? current.output_retention_state : 'retained', input.output === undefined ? current.output_expired_at : null, input.output === undefined ? current.output_byte_count : Buffer.byteLength(boundedOutput.output, 'utf8'), input.runId);
+    return getTestExecutionDetails(input.projectId, input.runId);
+};
+export const reconcileInterruptedTestRuns = (emitter) => {
+    const rows = db.prepare(`
+    SELECT project_id, id
+    FROM execution_runs
+    WHERE kind = 'test' AND status IN ('queued', 'running', 'waiting')
+  `).all();
+    for (const row of rows) {
+        transitionExecutionRun({
+            projectId: row.project_id,
+            runId: row.id,
+            status: 'interrupted',
+            domainStatus: 'interrupted',
+            failure: {
+                code: 'server_restarted',
+                message: 'The server restarted while this local test run was active.',
+            },
+            eventType: 'test_run_interrupted',
+        }, emitter);
+    }
+    return rows.length;
+};
+const serializeGitHubActionsDetails = (row) => ({
+    execution_run_id: row.execution_run_id,
+    project_id: row.project_id,
+    execution_status: row.execution_status,
+    domain_status: row.domain_status,
+    failure: row.failure_message ? {
+        code: row.failure_code,
+        message: row.failure_message,
+        details: parseStoredObject(row.failure_details_json),
+    } : null,
+    workflow_id: row.workflow_id,
+    workflow_name: row.workflow_name,
+    ref: row.ref,
+    input_names: parseStoredArray(row.input_names_json).filter(value => typeof value === 'string'),
+    input_fingerprint: row.input_fingerprint,
+    resolution_attempts: row.resolution_attempts,
+    provider_error_count: row.provider_error_count,
+    provider_run_id: row.provider_run_id,
+    provider_status: row.provider_status,
+    conclusion: row.conclusion,
+    html_url: row.html_url,
+    head_sha: row.head_sha,
+    head_branch: row.head_branch,
+    provider_created_at: row.provider_created_at,
+    provider_updated_at: row.provider_updated_at,
+    provider_started_at: row.provider_started_at,
+    dispatched_at: row.dispatched_at,
+    last_synced_at: row.last_synced_at,
+    jobs: parseStoredArray(row.jobs_json),
+    jobs_retention_state: row.jobs_retention_state,
+    jobs_expired_at: row.jobs_expired_at,
+    jobs_count: row.jobs_count ?? parseStoredArray(row.jobs_json).length,
+});
+const githubActionsDetailsSelect = `
+  SELECT ga.*, er.project_id, er.status AS execution_status, er.domain_status,
+         er.failure_code, er.failure_message, er.failure_details_json
+  FROM github_actions_run_details ga
+  JOIN execution_runs er ON er.id = ga.execution_run_id
+`;
+export const getGitHubActionsExecutionDetails = (projectId, runId) => {
+    const row = db.prepare(`${githubActionsDetailsSelect} WHERE er.project_id = ? AND er.id = ?`)
+        .get(projectId, runId);
+    return row ? serializeGitHubActionsDetails(row) : null;
+};
+export const listGitHubActionsExecutionDetails = (projectId, statuses) => {
+    const clauses = ["er.kind = 'github_actions'"];
+    const parameters = [];
+    if (projectId) {
+        clauses.push('er.project_id = ?');
+        parameters.push(projectId);
+    }
+    if (statuses && statuses.length > 0) {
+        clauses.push(`er.status IN (${statuses.map(() => '?').join(', ')})`);
+        parameters.push(...statuses);
+    }
+    const rows = db.prepare(`${githubActionsDetailsSelect} WHERE ${clauses.join(' AND ')} ORDER BY er.created_at DESC, er.id DESC`)
+        .all(...parameters);
+    return rows.map(serializeGitHubActionsDetails);
+};
+export const updateGitHubActionsRunDetails = (input) => {
+    const current = getGitHubActionsExecutionDetails(input.projectId, input.runId);
+    if (!current) {
+        throw new Error(`GitHub Actions execution run ${input.runId} was not found in project ${input.projectId}`);
+    }
+    const jobsJson = input.jobs === undefined ? serializeJobsSnapshot(current.jobs) : serializeJobsSnapshot(input.jobs);
+    db.prepare(`
+    UPDATE github_actions_run_details
+    SET workflow_name = ?, resolution_attempts = ?, provider_error_count = ?, provider_run_id = ?, provider_status = ?,
+        conclusion = ?, html_url = ?, head_sha = ?, head_branch = ?, provider_created_at = ?,
+        provider_updated_at = ?, provider_started_at = ?, last_synced_at = ?, jobs_json = ?,
+        jobs_retention_state = ?, jobs_expired_at = ?, jobs_count = ?
+    WHERE execution_run_id = ?
+  `).run(input.workflowName === undefined ? current.workflow_name : input.workflowName, input.resolutionAttempts ?? current.resolution_attempts, input.providerErrorCount ?? current.provider_error_count, input.providerRunId === undefined ? current.provider_run_id : input.providerRunId, input.providerStatus === undefined ? current.provider_status : input.providerStatus, input.conclusion === undefined ? current.conclusion : input.conclusion, input.htmlUrl === undefined ? current.html_url : input.htmlUrl, input.headSha === undefined ? current.head_sha : input.headSha, input.headBranch === undefined ? current.head_branch : input.headBranch, input.providerCreatedAt === undefined ? current.provider_created_at : input.providerCreatedAt, input.providerUpdatedAt === undefined ? current.provider_updated_at : input.providerUpdatedAt, input.providerStartedAt === undefined ? current.provider_started_at : input.providerStartedAt, input.lastSyncedAt === undefined ? current.last_synced_at : input.lastSyncedAt, jobsJson, input.jobs === undefined ? current.jobs_retention_state : 'retained', input.jobs === undefined ? current.jobs_expired_at : null, input.jobs === undefined ? current.jobs_count : input.jobs?.length ?? 0, input.runId);
+    return getGitHubActionsExecutionDetails(input.projectId, input.runId);
+};
+export const toGitHubActionsRun = (details) => {
+    if (details.provider_run_id === null) {
+        return null;
+    }
+    return {
+        id: details.provider_run_id,
+        name: details.workflow_name,
+        workflow_id: details.workflow_id,
+        status: details.provider_status === 'queued' || details.provider_status === 'in_progress' || details.provider_status === 'completed'
+            ? details.provider_status
+            : 'unknown',
+        conclusion: details.conclusion,
+        html_url: details.html_url,
+        head_branch: details.head_branch,
+        created_at: details.provider_created_at,
+        updated_at: details.provider_updated_at,
+        run_started_at: details.provider_started_at,
+        jobs: details.jobs,
+    };
+};
+export const listExecutionRuns = (input) => {
+    const limit = input.limit ?? 50;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200) {
+        throw new Error('Execution run page limit must be between 1 and 200');
+    }
+    const statuses = [...new Set(input.statuses ?? [])];
+    const cursor = input.cursor ? decodeCursor(input.cursor) : null;
+    const clauses = ['er.project_id = ?'];
+    const parameters = [input.projectId];
+    if (input.kind) {
+        clauses.push('er.kind = ?');
+        parameters.push(input.kind);
+    }
+    if (statuses.length > 0) {
+        clauses.push(`er.status IN (${statuses.map(() => '?').join(', ')})`);
+        parameters.push(...statuses);
+    }
+    if (cursor) {
+        clauses.push('(er.created_at < ? OR (er.created_at = ? AND er.id < ?))');
+        parameters.push(cursor.created_at, cursor.created_at, cursor.id);
+    }
+    if (input.scopeEntity) {
+        clauses.push(`EXISTS (
+      SELECT 1 FROM execution_run_links scope_link
+      WHERE scope_link.execution_run_id = er.id
+        AND scope_link.project_id = er.project_id
+        AND scope_link.entity_type = ?
+        AND scope_link.entity_id = ?
+    )`);
+        parameters.push(input.scopeEntity.type, input.scopeEntity.id);
+    }
+    const rows = db.prepare(`
+    SELECT er.* FROM execution_runs er
+    WHERE ${clauses.join(' AND ')}
+    ORDER BY er.created_at DESC, er.id DESC
+    LIMIT ?
+  `).all(...parameters, limit + 1);
+    const pageRows = rows.slice(0, limit);
+    const sourceAvailability = loadSourceAvailability(pageRows);
+    const lastRow = pageRows.at(-1);
+    return {
+        runs: pageRows.map(row => serializeRun(row, sourceAvailability)),
+        next_cursor: rows.length > limit && lastRow
+            ? encodeCursor({ created_at: lastRow.created_at, id: lastRow.id })
+            : null,
+    };
+};
+export const listLifecycleEvents = (projectId, runId) => {
+    getRunRow(projectId, runId);
+    const rows = db.prepare(`
+    SELECT * FROM lifecycle_events
+    WHERE project_id = ? AND execution_run_id = ?
+    ORDER BY sequence ASC
+  `).all(projectId, runId);
+    return rows.map(serializeEvent);
+};
+export const listLatestLifecycleEventsForRuns = (projectId, runIds) => {
+    const ids = [...new Set(runIds)];
+    if (ids.length === 0) {
+        return [];
+    }
+    const rows = db.prepare(`
+    SELECT * FROM (
+      SELECT lifecycle_events.*,
+        ROW_NUMBER() OVER (PARTITION BY execution_run_id ORDER BY sequence DESC, id DESC) AS timeline_rank
+      FROM lifecycle_events
+      WHERE project_id = ? AND execution_run_id IN (${ids.map(() => '?').join(', ')})
+    )
+    WHERE timeline_rank = 1
+  `).all(projectId, ...ids);
+    return rows.map(({ timeline_rank: _timelineRank, ...row }) => serializeEvent(row));
+};
+export const listProjectLifecycleEvents = (input) => {
+    const limit = input.limit ?? 50;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200) {
+        throw new Error('Lifecycle event page limit must be between 1 and 200');
+    }
+    const statuses = [...new Set(input.statuses ?? [])];
+    const cursor = input.cursor ? decodeLifecycleEventCursor(input.cursor) : null;
+    const clauses = ['le.project_id = ?'];
+    const parameters = [input.projectId];
+    if (input.kind) {
+        clauses.push('er.kind = ?');
+        parameters.push(input.kind);
+    }
+    if (statuses.length > 0) {
+        clauses.push(`er.status IN (${statuses.map(() => '?').join(', ')})`);
+        parameters.push(...statuses);
+    }
+    if (cursor) {
+        clauses.push(`(
+      le.created_at < ?
+      OR (le.created_at = ? AND le.execution_run_id < ?)
+      OR (le.created_at = ? AND le.execution_run_id = ? AND le.sequence < ?)
+      OR (le.created_at = ? AND le.execution_run_id = ? AND le.sequence = ? AND le.id < ?)
+    )`);
+        parameters.push(cursor.created_at, cursor.created_at, cursor.execution_run_id, cursor.created_at, cursor.execution_run_id, cursor.sequence, cursor.created_at, cursor.execution_run_id, cursor.sequence, cursor.id);
+    }
+    const rows = db.prepare(`
+    SELECT le.*
+    FROM lifecycle_events le
+    JOIN execution_runs er ON er.id = le.execution_run_id AND er.project_id = le.project_id
+    WHERE ${clauses.join(' AND ')}
+    ORDER BY le.created_at DESC, le.execution_run_id DESC, le.sequence DESC, le.id DESC
+    LIMIT ?
+  `).all(...parameters, limit + 1);
+    const pageRows = rows.slice(0, limit);
+    const lastRow = pageRows.at(-1);
+    return {
+        events: pageRows.map(serializeEvent),
+        next_cursor: rows.length > limit && lastRow
+            ? encodeLifecycleEventCursor({
+                created_at: lastRow.created_at,
+                execution_run_id: lastRow.execution_run_id,
+                sequence: lastRow.sequence,
+                id: lastRow.id,
+            })
+            : null,
+    };
+};
+//# sourceMappingURL=executionRuns.js.map