@straiffi/archon 1.8.20 → 1.8.22

package/dist/server/lib/executionReconciliation.js

@@ -1,7 +1,8 @@
 import db from '../db.js';
 import { terminalizeAgentRunsForExecutionRun, terminalizeLegacyAgentRuns } from './agentRuns.js';
 import { recoverInterruptedBuildOpenQuestionBatch } from './buildOpenQuestions.js';
-import { activateQueuedBuildSequenceTicket, getBuildSequenceIdForTicket, reconcileActiveBuildSequences, stopBuildSequence } from './buildSequences.js';
+import { activateQueuedBuildSequenceTicket, getBuildSequenceIdForTicket, getBuildSequenceTicketExecutionProfileSelection, reconcileActiveBuildSequences, stopBuildSequence, } from './buildSequences.js';
+import { parseExecutionProfileSelectionMetadata } from './executionRunAuthority.js';
 import { aggregateCheckBatch, completeCheckAttempt, getExecutionRun, reconcileInterruptedTestRuns, transitionExecutionRun, withExecutionRunTransaction, } from './executionRuns.js';
 import { getCheckBatchDetails } from './checkRuns.js';
 import { reconcileGitHubActionsRuns } from './integrations/githubActionsSessions.js';
@@ -18,6 +19,72 @@ const TERMINAL_EXECUTION_STATUSES = "('completed', 'failed', 'cancelled', 'inter
 const ACTIVE_EXECUTION_STATUS_SET = new Set(['queued', 'running', 'waiting']);
 const TERMINAL_EXECUTION_STATUS_SET = new Set(['completed', 'failed', 'cancelled', 'interrupted']);
 const RESTART_FAILURE_MESSAGE = 'Interrupted by server restart';
+const parseRunSelection = (metadataJson) => {
+    try {
+        return parseExecutionProfileSelectionMetadata(metadataJson ? JSON.parse(metadataJson) : null);
+    }
+    catch {
+        return null;
+    }
+};
+const isQualifiedQueuedBuildHandoff = (projectId, sequenceId, ticketId, runId) => {
+    let itemSelection;
+    try {
+        itemSelection = getBuildSequenceTicketExecutionProfileSelection(sequenceId, ticketId);
+    }
+    catch {
+        return false;
+    }
+    const source = db.prepare(`
+    SELECT source.id, previous_item.ticket_id
+    FROM build_sequences sequence
+    JOIN build_sequence_tickets current_item ON current_item.build_sequence_id = sequence.id
+      AND current_item.ticket_id = ? AND current_item.status IN ('active', 'queued')
+    JOIN build_sequence_tickets previous_item ON previous_item.build_sequence_id = sequence.id
+      AND previous_item.position = current_item.position - 1 AND previous_item.status = 'done'
+    JOIN execution_runs source ON source.project_id = sequence.project_id
+      AND source.kind IN ('build', 'build_follow_up') AND source.status = 'completed'
+      AND json_extract(source.metadata_json, '$.post_build_finalization.status') IN ('pending', 'finalized', 'completed')
+    JOIN execution_run_links source_ticket ON source_ticket.execution_run_id = source.id
+      AND source_ticket.project_id = source.project_id AND source_ticket.entity_type = 'ticket'
+      AND source_ticket.entity_id = previous_item.ticket_id AND source_ticket.relationship = 'primary'
+    JOIN execution_run_links source_sequence ON source_sequence.execution_run_id = source.id
+      AND source_sequence.project_id = source.project_id AND source_sequence.entity_type = 'build_sequence'
+      AND source_sequence.entity_id = sequence.id AND source_sequence.relationship = 'context'
+    WHERE sequence.id = ? AND sequence.project_id = ? AND sequence.status = 'active'
+    ORDER BY source.created_at DESC, source.id DESC
+    LIMIT 1
+  `).get(ticketId, sequenceId, projectId);
+    if (!source || !isLatestTicketBuildSource(projectId, source.id, source.ticket_id)) {
+        return false;
+    }
+    const activeRuns = db.prepare(`
+    SELECT run.id, run.status, run.parent_run_id, run.metadata_json, item.activation_execution_run_id
+    FROM execution_runs run
+    JOIN execution_run_links ticket_link ON ticket_link.execution_run_id = run.id
+      AND ticket_link.project_id = run.project_id AND ticket_link.entity_type = 'ticket'
+      AND ticket_link.entity_id = ? AND ticket_link.relationship = 'primary'
+    LEFT JOIN build_sequence_tickets item ON item.build_sequence_id = ? AND item.ticket_id = ?
+    WHERE run.project_id = ? AND run.kind = 'build' AND run.status IN ${ACTIVE_EXECUTION_STATUSES}
+    ORDER BY run.created_at ASC, run.id ASC
+  `).all(ticketId, sequenceId, ticketId, projectId);
+    if (!runId) {
+        return activeRuns.length === 0;
+    }
+    if (activeRuns.length !== 1) {
+        return false;
+    }
+    const [run] = activeRuns;
+    const runSelection = parseRunSelection(run.metadata_json);
+    return Boolean(run.id === runId
+        && run.status === 'queued'
+        && run.parent_run_id === source.id
+        && run.activation_execution_run_id === run.id
+        && runSelection
+        && runSelection.revisionId === itemSelection.revisionId
+        && runSelection.fingerprint === itemSelection.fingerprint
+        && runSelection.reason === itemSelection.reason);
+};
 const terminalizeInterruptedReviewRuns = (executionRunId, ticketId) => {
     const linked = db.prepare(`
     UPDATE review_runs
@@ -390,6 +457,8 @@ const reconcileBuildOpenQuestionBatches = () => {
     let questionsReopened = 0;
     let automationPaused = 0;
     let inconsistentBatchesRecovered = 0;
+    let orphanedProgressionChildrenInterrupted = 0;
+    const interruptedRunIds = new Set();
     const createLegacyRecoveryProgression = (batch) => {
         const state = getBundleAutomationState(batch.project_id, batch.worktree_bundle_id);
         if (!state?.automation_progression_run_id
@@ -426,6 +495,7 @@ const reconcileBuildOpenQuestionBatches = () => {
                 let terminalized = 0;
                 let errored = 0;
                 for (const referencedRun of referencedRuns) {
+                    interruptedRunIds.add(referencedRun.id);
                     const interrupted = interruptBuildOpenQuestionRun(transaction, referencedRun);
                     terminalized += interrupted.terminalized;
                     errored += interrupted.errored;
@@ -451,6 +521,7 @@ const reconcileBuildOpenQuestionBatches = () => {
                 childRunId: ownedRun.id,
             });
             const recovered = withExecutionRunTransaction(transaction => {
+                interruptedRunIds.add(ownedRun.id);
                 const interrupted = interruptBuildOpenQuestionRun(transaction, ownedRun);
                 const batchRecovery = recoverInterruptedBuildOpenQuestionBatch(batch.id);
                 waitAutomationProgression({
@@ -477,6 +548,34 @@ const reconcileBuildOpenQuestionBatches = () => {
         questionsReopened += recovered.questions_reopened;
         automationPaused += recovered.automation_paused;
     }
+    // Follow-up runs owned by an automation progression but referencing no pending or
+    // running batch survive restarts as active zombies. The direct-workflow sweep skips
+    // them (progression parents are excluded), so interrupt them here to keep waiting
+    // open-question progressions adoptable.
+    const orphanedProgressionChildren = db.prepare(`
+    SELECT id, project_id, source_kind, source_id, metadata_json, initiated_by
+    FROM execution_runs orphan_run
+    WHERE orphan_run.kind = 'build_follow_up'
+      AND orphan_run.status IN ${ACTIVE_EXECUTION_STATUSES}
+      AND EXISTS (
+        SELECT 1 FROM execution_runs parent
+        WHERE parent.id = orphan_run.parent_run_id
+          AND parent.project_id = orphan_run.project_id
+          AND parent.kind = 'automation_progression'
+      )
+    ORDER BY orphan_run.created_at ASC, orphan_run.id ASC
+  `).all();
+    for (const run of orphanedProgressionChildren) {
+        if (interruptedRunIds.has(run.id)) {
+            continue;
+        }
+        withExecutionRunTransaction(transaction => {
+            const interrupted = interruptBuildOpenQuestionRun(transaction, run);
+            childRowsTerminalized += interrupted.terminalized;
+            ticketsErrored += interrupted.errored;
+        });
+        orphanedProgressionChildrenInterrupted += 1;
+    }
     return {
         adopted_interrupted: adoptedInterrupted,
         legacy_recovered: legacyRecovered,
@@ -485,18 +584,13 @@ const reconcileBuildOpenQuestionBatches = () => {
         questions_reopened: questionsReopened,
         automation_paused: automationPaused,
         inconsistent_batches_recovered: inconsistentBatchesRecovered,
+        orphaned_progression_children_interrupted: orphanedProgressionChildrenInterrupted,
     };
 };
 const interruptSequenceBuild = (input) => {
     const rows = db.prepare(`
     SELECT execution_runs.id, execution_runs.project_id, execution_runs.status
     FROM execution_runs
-    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.entity_id = ?
-      AND sequence_link.relationship = 'context'
     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
@@ -506,31 +600,11 @@ const interruptSequenceBuild = (input) => {
     WHERE execution_runs.project_id = ?
       AND execution_runs.kind = 'build'
       AND execution_runs.status IN ${ACTIVE_EXECUTION_STATUSES}
-  `).all(input.sequenceId, input.ticketId, input.projectId);
-    const queuedHandoff = input.itemStatus !== null && Boolean(db.prepare(`
-    SELECT 1
-    FROM build_sequence_tickets current_item
-    JOIN build_sequence_tickets previous_item ON previous_item.build_sequence_id = current_item.build_sequence_id
-      AND previous_item.position = current_item.position - 1
-      AND previous_item.status = 'done'
-    JOIN execution_runs source ON source.project_id = ?
-    JOIN execution_run_links source_ticket ON source_ticket.execution_run_id = source.id
-      AND source_ticket.project_id = source.project_id
-      AND source_ticket.entity_type = 'ticket'
-      AND source_ticket.entity_id = previous_item.ticket_id
-      AND source_ticket.relationship = 'primary'
-    WHERE current_item.build_sequence_id = ?
-      AND current_item.ticket_id = ?
-      AND current_item.status IN ('active', 'queued')
-      AND source.kind IN ('build', 'build_follow_up')
-      AND source.status = 'completed'
-      AND json_extract(source.metadata_json, '$.post_build_finalization.status') IN ('pending', 'blocked', 'finalized', 'completed')
-    LIMIT 1
-  `).get(input.projectId, input.sequenceId, input.ticketId));
-    if (queuedHandoff && rows.every(row => row.status === 'queued')) {
-        return false;
-    }
-    if (rows.length > 1) {
+  `).all(input.ticketId, input.projectId);
+    const preservesHandoff = input.itemStatus !== null && (rows.length === 0
+        ? isQualifiedQueuedBuildHandoff(input.projectId, input.sequenceId, input.ticketId)
+        : rows.length === 1 && isQualifiedQueuedBuildHandoff(input.projectId, input.sequenceId, input.ticketId, rows[0].id));
+    if (preservesHandoff) {
         return false;
     }
     if (rows.length === 0) {
@@ -540,23 +614,24 @@ const interruptSequenceBuild = (input) => {
     `).run(input.ticketId, input.projectId);
         return true;
     }
-    const [run] = rows;
-    withExecutionRunTransaction(transaction => {
-        transaction.transitionExecutionRun({
-            projectId: run.project_id,
-            runId: run.id,
-            status: 'interrupted',
-            domainStatus: 'interrupted',
-            failure: { code: 'server_restarted', message: 'The server restarted while this sequenced Build run was active.' },
-            eventType: 'build_interrupted',
-            eventMessage: 'The server restarted while this sequenced Build run was active.',
+    for (const run of rows) {
+        withExecutionRunTransaction(transaction => {
+            transaction.transitionExecutionRun({
+                projectId: run.project_id,
+                runId: run.id,
+                status: 'interrupted',
+                domainStatus: 'interrupted',
+                failure: { code: 'server_restarted', message: 'The server restarted while this sequenced Build run was active.' },
+                eventType: 'build_interrupted',
+                eventMessage: 'The server restarted while this sequenced Build run was active.',
+            });
+            terminalizeAgentRunsForExecutionRun(run.id, 'error', RESTART_FAILURE_MESSAGE);
+            db.prepare(`
+        UPDATE tickets SET agent_status = 'error'
+        WHERE id = ? AND project_id = ? AND (agent_status = 'running' OR agent_status IS NULL)
+      `).run(input.ticketId, input.projectId);
         });
-        terminalizeAgentRunsForExecutionRun(run.id, 'error', RESTART_FAILURE_MESSAGE);
-        db.prepare(`
-      UPDATE tickets SET agent_status = 'error'
-      WHERE id = ? AND project_id = ? AND (agent_status = 'running' OR agent_status IS NULL)
-    `).run(input.ticketId, input.projectId);
-    });
+    }
     return true;
 };
 const reconcileSpecReviews = () => {
@@ -606,27 +681,10 @@ const reconcileSpecReviews = () => {
     };
 };
 const reconcileDirectWorkflow = (policy) => {
-    const queuedBuildHandoffCondition = policy.kind === 'build'
-        ? `
-      AND NOT (
-        execution_runs.status = 'queued'
-        AND EXISTS (
-          SELECT 1
-          FROM execution_runs parent
-          WHERE parent.id = execution_runs.parent_run_id
-            AND parent.project_id = execution_runs.project_id
-            AND parent.kind IN ('build', 'build_follow_up')
-            AND parent.status = 'completed'
-            AND json_extract(parent.metadata_json, '$.post_build_finalization.status') IN ('pending', 'blocked', 'finalized', 'completed')
-        )
-      )
-    `
-        : '';
     const rows = db.prepare(`
     SELECT id, project_id, source_kind, source_id
     FROM execution_runs
     WHERE kind = ? AND status IN ${ACTIVE_EXECUTION_STATUSES}
-      ${queuedBuildHandoffCondition}
       AND NOT EXISTS (
         SELECT 1 FROM execution_runs parent
         WHERE parent.id = execution_runs.parent_run_id
@@ -637,7 +695,20 @@ const reconcileDirectWorkflow = (policy) => {
   `).all(policy.kind);
     let childRowsTerminalized = 0;
     let domainParentsErrored = 0;
+    let interrupted = 0;
     const interruptRun = (row) => {
+        if (policy.kind === 'build' && row.source_id) {
+            const item = db.prepare(`
+        SELECT build_sequence_id
+        FROM build_sequence_tickets
+        WHERE ticket_id = ? AND activation_execution_run_id = ?
+      `).get(row.source_id, row.id);
+            // A durable post-Build handoff is the sole Build restart-preserved scheduling class.
+            if (item && isQualifiedQueuedBuildHandoff(row.project_id, item.build_sequence_id, row.source_id, row.id)) {
+                return;
+            }
+        }
+        interrupted += 1;
         withExecutionRunTransaction(transaction => {
             transaction.transitionExecutionRun({
                 projectId: row.project_id,
@@ -713,16 +784,22 @@ const reconcileDirectWorkflow = (policy) => {
     `).run(policy.domainParent.sourceKind).changes;
     }
     return {
-        interrupted: rows.length,
+        interrupted,
         child_rows_terminalized: childRowsTerminalized,
         domain_parents_errored: domainParentsErrored,
     };
 };
 const reconcileCheckBatches = async () => {
+    const hasApprovalRequests = Boolean(db.prepare(`
+    SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'approval_requests'
+  `).get());
     const attempts = db.prepare(`
-    SELECT run.id, run.project_id, run.parent_run_id, details.execution_run_id AS details_run_id
+    SELECT run.id, run.project_id, run.parent_run_id, details.execution_run_id AS details_run_id,
+      details.command_snapshot_json, ${hasApprovalRequests ? 'approval.status' : 'NULL'} AS approval_status
     FROM execution_runs run
     LEFT JOIN check_attempt_details details ON details.execution_run_id = run.id
+    ${hasApprovalRequests ? `LEFT JOIN approval_requests approval
+      ON approval.execution_run_id = run.id AND approval.project_id = run.project_id` : ''}
     WHERE run.kind = 'check_attempt' AND run.status IN ${ACTIVE_EXECUTION_STATUSES}
     ORDER BY run.created_at ASC, run.id ASC
   `).all();
@@ -733,20 +810,30 @@ const reconcileCheckBatches = async () => {
     let postBuildChatsFinalized = 0;
     let postBuildContinuationsResumed = 0;
     for (const attempt of attempts) {
+        if (attempt.approval_status === 'pending' || attempt.approval_status === 'approved') {
+            continue;
+        }
         if (attempt.parent_run_id) {
             affectedBatchIds.add(attempt.parent_run_id);
         }
         if (attempt.details_run_id) {
+            const productionConsumed = attempt.approval_status === 'consumed'
+                && attempt.command_snapshot_json !== null
+                && JSON.parse(attempt.command_snapshot_json).consequence === 'production';
             completeCheckAttempt({
                 projectId: attempt.project_id,
                 runId: attempt.id,
-                outcome: 'restart_loss',
+                outcome: productionConsumed ? 'ambiguous_process_loss' : 'restart_loss',
                 finalWorkspaceIdentity: {
                     state: 'unavailable',
                     reason: 'worktree_unavailable',
-                    message: 'The server restarted before this check attempt completed',
+                    message: productionConsumed
+                        ? 'The production command process identity was lost; its external outcome is ambiguous'
+                        : 'The server restarted before this check attempt completed',
                 },
-                exitError: 'The server restarted before this check attempt completed',
+                exitError: productionConsumed
+                    ? 'The production command process identity was lost; automatic replay is prohibited'
+                    : 'The server restarted before this check attempt completed',
             });
             interruptedAttempts += 1;
             continue;
@@ -1039,135 +1126,196 @@ export const reconcileEnvironmentValidationRuns = async (adapter) => {
     }
     return { interrupted };
 };
-export const createExecutionReconciliationPolicies = (input) => [
-    {
-        key: 'environment_validation',
-        workLocality: 'local_process',
-        startupStrategy: 'interrupt',
-        terminalStatus: 'interrupted',
-        failureCode: 'server_restarted',
-        updatesDomainRecords: false,
-        pausesAutomation: false,
-        reconcile: reconcileEnvironmentValidationRuns,
-    },
-    {
-        key: 'test',
-        workLocality: 'local_process',
-        startupStrategy: 'interrupt',
-        terminalStatus: 'interrupted',
-        failureCode: 'server_restarted',
-        updatesDomainRecords: false,
-        pausesAutomation: true,
-        reconcile: () => ({ interrupted: reconcileInterruptedTestRuns() }),
-    },
-    {
-        key: 'check_batch',
-        workLocality: 'local_process',
-        startupStrategy: 'interrupt',
-        terminalStatus: 'interrupted',
-        failureCode: 'restart_loss',
-        updatesDomainRecords: true,
-        pausesAutomation: false,
-        reconcile: reconcileCheckBatches,
-    },
-    {
-        key: 'check_auto_fix',
-        workLocality: 'durable_orchestration',
-        startupStrategy: 'reconcile',
-        terminalStatus: null,
-        failureCode: null,
-        updatesDomainRecords: true,
-        pausesAutomation: true,
-        reconcile: async () => db.prepare(`
+export const createExecutionReconciliationPolicies = (input) => {
+    const approvedRequests = [];
+    return [
+        {
+            key: 'approval',
+            workLocality: 'durable_orchestration',
+            startupStrategy: 'reconcile',
+            terminalStatus: null,
+            failureCode: null,
+            updatesDomainRecords: true,
+            pausesAutomation: true,
+            reconcile: async () => db.prepare(`
+      SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'approval_requests'
+    `).get()
+                ? (await import('./approvalReconciliation.js')).reconcileApprovalRequests({
+                    resumeApproved: request => {
+                        approvedRequests.push(request);
+                    },
+                    reconcileConsumed: request => {
+                        if (request.action_kind === 'git_push') {
+                            return import('./gitPushApprovals.js').then(async (pushes) => {
+                                await pushes.reconcileConsumedGitPush(request);
+                            });
+                        }
+                    },
+                    resolveTerminal: async (request) => {
+                        if (request.action_kind === 'git_push') {
+                            await (await import('./gitPushApprovals.js')).finalizeGitPushApproval(request.project_id, request.id);
+                        }
+                        else {
+                            await (await import('./checkRunner.js')).finalizeProductionCheckApproval(request.project_id, request.id);
+                        }
+                    },
+                })
+                : { expired: 0, invalidated: 0, pending: 0, approved_unclaimed: 0, consumed_delegated: 0 },
+        },
+        {
+            key: 'environment_validation',
+            workLocality: 'local_process',
+            startupStrategy: 'interrupt',
+            terminalStatus: 'interrupted',
+            failureCode: 'server_restarted',
+            updatesDomainRecords: false,
+            pausesAutomation: false,
+            reconcile: reconcileEnvironmentValidationRuns,
+        },
+        {
+            key: 'test',
+            workLocality: 'local_process',
+            startupStrategy: 'interrupt',
+            terminalStatus: 'interrupted',
+            failureCode: 'server_restarted',
+            updatesDomainRecords: false,
+            pausesAutomation: true,
+            reconcile: () => ({ interrupted: reconcileInterruptedTestRuns() }),
+        },
+        {
+            key: 'check_batch',
+            workLocality: 'local_process',
+            startupStrategy: 'interrupt',
+            terminalStatus: 'interrupted',
+            failureCode: 'restart_loss',
+            updatesDomainRecords: true,
+            pausesAutomation: false,
+            reconcile: async () => {
+                const result = await reconcileCheckBatches();
+                for (const request of approvedRequests.splice(0)) {
+                    if (request.action_kind === 'git_push') {
+                        await (await import('./gitPushApprovals.js')).resumeGitPushApproval(request.project_id, request.id);
+                    }
+                    else {
+                        await (await import('./checkRunner.js')).resumeProductionCheckApproval(request.project_id, request.id);
+                    }
+                }
+                return result;
+            },
+        },
+        {
+            key: 'check_auto_fix',
+            workLocality: 'durable_orchestration',
+            startupStrategy: 'reconcile',
+            terminalStatus: null,
+            failureCode: null,
+            updatesDomainRecords: true,
+            pausesAutomation: true,
+            reconcile: async () => db.prepare(`
       SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'check_auto_fix_loops'
     `).get()
-            ? (await import('./checkAutoFix.js')).reconcileCheckAutoFixLoops()
-            : { interrupted: 0 },
-    },
-    {
-        key: 'check_repair',
-        workLocality: 'durable_orchestration',
-        startupStrategy: 'reconcile',
-        terminalStatus: null,
-        failureCode: null,
-        updatesDomainRecords: true,
-        pausesAutomation: true,
-        reconcile: async () => (await import('./checkRepairReconciliation.js')).reconcileCheckRepairs(),
-    },
-    {
-        key: 'repository_graph_scan',
-        workLocality: 'local_process',
-        startupStrategy: 'interrupt',
-        terminalStatus: 'interrupted',
-        failureCode: 'server_restarted',
-        updatesDomainRecords: true,
-        pausesAutomation: false,
-        reconcile: reconcileRepositoryGraphScans,
-    },
-    {
-        key: 'automation',
-        workLocality: 'durable_orchestration',
-        startupStrategy: 'reconcile',
-        terminalStatus: null,
-        failureCode: null,
-        updatesDomainRecords: true,
-        pausesAutomation: true,
-        reconcile: reconcileAutomationExecutions,
-    },
-    {
-        key: 'build_sequence',
-        workLocality: 'durable_orchestration',
-        startupStrategy: 'reconcile',
-        terminalStatus: 'interrupted',
-        failureCode: 'server_restarted',
-        updatesDomainRecords: true,
-        pausesAutomation: false,
-        reconcile: () => reconcileActiveBuildSequences({ interruptActiveChild: interruptSequenceBuild }),
-    },
-    {
-        key: 'build_open_question_batch',
-        workLocality: 'durable_orchestration',
-        startupStrategy: 'reconcile',
-        terminalStatus: 'interrupted',
-        failureCode: 'server_restarted',
-        updatesDomainRecords: true,
-        pausesAutomation: true,
-        reconcile: reconcileBuildOpenQuestionBatches,
-    },
-    ...directWorkflowPolicies.map(policy => ({
-        key: policy.kind,
-        workLocality: 'local_process',
-        startupStrategy: 'interrupt',
-        terminalStatus: 'interrupted',
-        failureCode: 'server_restarted',
-        updatesDomainRecords: Boolean(policy.domainParent),
-        pausesAutomation: false,
-        reconcile: () => reconcileDirectWorkflow(policy),
-    })),
-    {
-        key: 'spec_review',
-        workLocality: 'local_process',
-        startupStrategy: 'interrupt',
-        terminalStatus: 'interrupted',
-        failureCode: 'server_restarted',
-        updatesDomainRecords: true,
-        pausesAutomation: false,
-        reconcile: reconcileSpecReviews,
-    },
-    {
-        key: 'github_actions',
-        workLocality: 'externally_observable',
-        startupStrategy: 'reconcile',
-        terminalStatus: null,
-        failureCode: null,
-        updatesDomainRecords: false,
-        pausesAutomation: false,
-        reconcile: () => reconcileGitHubActionsRuns({
-            getConfig: input.getGitHubConfig,
-            startPolling: false,
-        }),
-    },
-];
+                ? (await import('./checkAutoFix.js')).reconcileCheckAutoFixLoops()
+                : { interrupted: 0 },
+        },
+        {
+            key: 'check_repair',
+            workLocality: 'durable_orchestration',
+            startupStrategy: 'reconcile',
+            terminalStatus: null,
+            failureCode: null,
+            updatesDomainRecords: true,
+            pausesAutomation: true,
+            reconcile: async () => (await import('./checkRepairReconciliation.js')).reconcileCheckRepairs(),
+        },
+        {
+            key: 'repository_graph_scan',
+            workLocality: 'local_process',
+            startupStrategy: 'interrupt',
+            terminalStatus: 'interrupted',
+            failureCode: 'server_restarted',
+            updatesDomainRecords: true,
+            pausesAutomation: false,
+            reconcile: reconcileRepositoryGraphScans,
+        },
+        {
+            key: 'automation',
+            workLocality: 'durable_orchestration',
+            startupStrategy: 'reconcile',
+            terminalStatus: null,
+            failureCode: null,
+            updatesDomainRecords: true,
+            pausesAutomation: true,
+            reconcile: reconcileAutomationExecutions,
+        },
+        {
+            key: 'build_sequence',
+            workLocality: 'durable_orchestration',
+            startupStrategy: 'reconcile',
+            terminalStatus: 'interrupted',
+            failureCode: 'server_restarted',
+            updatesDomainRecords: true,
+            pausesAutomation: false,
+            reconcile: () => reconcileActiveBuildSequences({ interruptActiveChild: interruptSequenceBuild }),
+        },
+        {
+            key: 'build_open_question_batch',
+            workLocality: 'durable_orchestration',
+            startupStrategy: 'reconcile',
+            terminalStatus: 'interrupted',
+            failureCode: 'server_restarted',
+            updatesDomainRecords: true,
+            pausesAutomation: true,
+            reconcile: reconcileBuildOpenQuestionBatches,
+        },
+        ...directWorkflowPolicies.map(policy => ({
+            key: policy.kind,
+            workLocality: 'local_process',
+            startupStrategy: 'interrupt',
+            terminalStatus: 'interrupted',
+            failureCode: 'server_restarted',
+            updatesDomainRecords: Boolean(policy.domainParent),
+            pausesAutomation: false,
+            reconcile: () => reconcileDirectWorkflow(policy),
+        })),
+        {
+            key: 'build_setup',
+            workLocality: 'durable_orchestration',
+            startupStrategy: 'reconcile',
+            terminalStatus: 'failed',
+            failureCode: 'server_restarted',
+            updatesDomainRecords: true,
+            pausesAutomation: false,
+            reconcile: async () => db.prepare(`
+      SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'build_setup_evidence'
+    `).get()
+                ? (await import('./buildSetupAuthority.js')).reconcileBuildSetupEvidence()
+                : { failed: 0 },
+        },
+        {
+            key: 'spec_review',
+            workLocality: 'local_process',
+            startupStrategy: 'interrupt',
+            terminalStatus: 'interrupted',
+            failureCode: 'server_restarted',
+            updatesDomainRecords: true,
+            pausesAutomation: false,
+            reconcile: reconcileSpecReviews,
+        },
+        {
+            key: 'github_actions',
+            workLocality: 'externally_observable',
+            startupStrategy: 'reconcile',
+            terminalStatus: null,
+            failureCode: null,
+            updatesDomainRecords: false,
+            pausesAutomation: false,
+            reconcile: () => reconcileGitHubActionsRuns({
+                getConfig: input.getGitHubConfig,
+                startPolling: false,
+            }),
+        },
+    ];
+};
 export const reconcileStartupExecutions = async (input) => {
     const policies = input.policies ?? createExecutionReconciliationPolicies(input);
     const summary = {};