@straiffi/archon 1.7.6 → 1.7.8

package/dist/server/lib/checkRuns.js

@@ -0,0 +1,736 @@
+import { createHash, randomUUID } from 'crypto';
+import db from '../db.js';
+import { getCheckDefinitionFingerprint, normalizeCheckDefinitions } from './checkDefinitions.js';
+export const CHECK_ATTEMPT_OUTCOMES = [
+    'passed',
+    'command_failure',
+    'spawn_failure',
+    'timeout',
+    'workspace_changed_before_start',
+    'user_stop',
+    'restart_loss',
+    'shutdown_loss',
+];
+export const toCheckAttemptSummary = ({ retained_output: _retainedOutput, ...summary }) => summary;
+const canonicalDefinition = (definition) => ({
+    id: definition.id,
+    name: definition.name,
+    category: definition.category,
+    command: definition.command,
+    ...(definition.cwd ? { cwd: definition.cwd } : {}),
+    timeout_ms: definition.timeout_ms,
+    ...(definition.category === 'test' ? { runner: definition.runner } : {}),
+});
+const canonicalWorkspaceIdentity = (identity) => identity.state === 'available'
+    ? { state: 'available', algorithm: 'sha256', fingerprint: identity.fingerprint, head: identity.head }
+    : { state: 'unavailable', reason: identity.reason, message: identity.message };
+const assertSha256 = (value, name) => {
+    if (!/^[a-f0-9]{64}$/.test(value)) {
+        throw new Error(`${name} must be a lowercase SHA-256 fingerprint`);
+    }
+};
+const assertWorkspaceIdentity = (identity, name) => {
+    if (identity.state === 'available') {
+        assertSha256(identity.fingerprint, `${name} fingerprint`);
+        if (!/^[a-f0-9]{40,64}$/.test(identity.head)) {
+            throw new Error(`${name} HEAD must be a Git object ID`);
+        }
+        return;
+    }
+    if (!identity.reason || !identity.message) {
+        throw new Error(`${name} unavailable identity requires a reason and message`);
+    }
+};
+const updateLengthDelimited = (hash, value) => {
+    const buffer = Buffer.from(value, 'utf8');
+    const length = Buffer.alloc(8);
+    length.writeBigUInt64BE(BigInt(buffer.length));
+    hash.update(length).update(buffer);
+};
+const compareDefinitionIds = (left, right) => (Buffer.compare(Buffer.from(left.id, 'utf8'), Buffer.from(right.id, 'utf8')));
+export const getCheckConfigurationFingerprint = (target, definitions) => {
+    const hash = createHash('sha256');
+    updateLengthDelimited(hash, 'archon-check-configuration-v1');
+    updateLengthDelimited(hash, target.targetKind);
+    updateLengthDelimited(hash, target.targetBundleId ?? '');
+    for (const definition of [...definitions].sort(compareDefinitionIds)) {
+        updateLengthDelimited(hash, definition.id);
+        updateLengthDelimited(hash, getCheckDefinitionFingerprint(definition));
+    }
+    return hash.digest('hex');
+};
+export const mapCheckAttemptOutcomeToExecutionStatus = (outcome) => {
+    if (outcome === 'passed') {
+        return 'completed';
+    }
+    if (outcome === 'user_stop') {
+        return 'cancelled';
+    }
+    if (outcome === 'restart_loss' || outcome === 'shutdown_loss') {
+        return 'interrupted';
+    }
+    return 'failed';
+};
+const parseJson = (value) => JSON.parse(value);
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled', 'interrupted']);
+export const CHECK_ATTEMPT_OUTPUT_LIMIT_BYTES = 256 * 1024;
+const retainUtf8Suffix = (value, byteLimit) => {
+    if (Buffer.byteLength(value, 'utf8') <= byteLimit) {
+        return value;
+    }
+    let low = 0;
+    let high = value.length;
+    while (low < high) {
+        const midpoint = Math.floor((low + high) / 2);
+        if (Buffer.byteLength(value.slice(midpoint), 'utf8') <= byteLimit) {
+            high = midpoint;
+        }
+        else {
+            low = midpoint + 1;
+        }
+    }
+    let start = low;
+    if (start > 0 && start < value.length) {
+        const previous = value.charCodeAt(start - 1);
+        const next = value.charCodeAt(start);
+        if (previous >= 0xd800 && previous <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) {
+            start += 1;
+        }
+    }
+    return value.slice(start);
+};
+const assertBatchTarget = (projectId, details) => {
+    if (details.targetKind === 'repo_root') {
+        if (details.targetBundleId != null) {
+            throw new Error('Repository-root check batches cannot have a target bundle');
+        }
+        return;
+    }
+    const bundle = db.prepare(`
+    SELECT 1 FROM worktree_bundles
+    WHERE id = ? AND project_id = ? AND kind <> 'project_root'
+  `).get(details.targetBundleId, projectId);
+    if (!bundle) {
+        throw new Error(`Check target bundle ${details.targetBundleId} does not belong to project ${projectId}`);
+    }
+};
+const getRun = (projectId, runId) => db.prepare(`
+  SELECT id, project_id, kind, status, parent_run_id, correlation_id
+  FROM execution_runs WHERE id = ? AND project_id = ?
+`).get(runId, projectId);
+export const validateCheckBatchDetails = (projectId, details) => {
+    assertBatchTarget(projectId, details);
+    assertWorkspaceIdentity(details.initialWorkspaceIdentity, 'Initial workspace identity');
+    if (details.selectedDefinitions.length === 0) {
+        throw new Error('Check batches require at least one selected definition');
+    }
+    const normalized = normalizeCheckDefinitions(details.selectedDefinitions);
+    if ('error' in normalized) {
+        throw new Error(`Invalid selected check definitions: ${normalized.error}`);
+    }
+    const definitionIds = new Set();
+    for (const definition of details.selectedDefinitions) {
+        if (!definition.id || definitionIds.has(definition.id)) {
+            throw new Error('Selected check definition IDs must be non-empty and unique');
+        }
+        definitionIds.add(definition.id);
+        assertSha256(getCheckDefinitionFingerprint(definition), 'Definition fingerprint');
+    }
+    const expectedFingerprint = getCheckConfigurationFingerprint(details, details.selectedDefinitions);
+    const fingerprint = details.configurationFingerprint ?? expectedFingerprint;
+    assertSha256(fingerprint, 'Check configuration fingerprint');
+    if (fingerprint !== expectedFingerprint) {
+        throw new Error('Check configuration fingerprint does not match the selected definitions and target');
+    }
+    if (details.rerunOfBatchRunId) {
+        const source = getRun(projectId, details.rerunOfBatchRunId);
+        if (!source || source.kind !== 'check_batch' || !['completed', 'failed', 'cancelled', 'interrupted'].includes(source.status)) {
+            throw new Error('Check rerun source must be a check batch in the same project');
+        }
+    }
+    return fingerprint;
+};
+export const insertCheckBatchDetails = (projectId, runId, details) => {
+    const fingerprint = validateCheckBatchDetails(projectId, details);
+    db.prepare(`
+    INSERT INTO check_batch_details (
+      execution_run_id, target_kind, target_bundle_id, target_label,
+      selected_definition_snapshots_json, initial_workspace_identity_json,
+      configuration_fingerprint, stop_requested, rerun_of_batch_run_id
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(runId, details.targetKind, details.targetBundleId ?? null, details.targetLabel ?? null, JSON.stringify(details.selectedDefinitions.map(canonicalDefinition)), JSON.stringify(canonicalWorkspaceIdentity(details.initialWorkspaceIdentity)), fingerprint, details.stopRequested ? 1 : 0, details.rerunOfBatchRunId ?? null);
+};
+export const validateCheckAttemptDetails = (projectId, runId, details) => {
+    assertWorkspaceIdentity(details.initialWorkspaceIdentity, 'Initial workspace identity');
+    const normalized = normalizeCheckDefinitions([details.definition]);
+    if ('error' in normalized) {
+        throw new Error(`Invalid check attempt definition: ${normalized.error}`);
+    }
+    const batch = getRun(projectId, details.batchRunId);
+    if (!batch || batch.kind !== 'check_batch') {
+        throw new Error('Check attempts require a check batch parent in the same project');
+    }
+    const run = getRun(projectId, runId);
+    if (!run || run.kind !== 'check_attempt' || run.parent_run_id !== batch.id || run.correlation_id !== batch.correlation_id) {
+        throw new Error('Check attempt execution lineage must match its batch details');
+    }
+    const selected = db.prepare('SELECT selected_definition_snapshots_json FROM check_batch_details WHERE execution_run_id = ?')
+        .get(batch.id);
+    const selectedDefinitions = selected ? parseJson(selected.selected_definition_snapshots_json) : [];
+    const selectedDefinition = selectedDefinitions.find(definition => definition.id === details.definition.id);
+    if (!selectedDefinition || getCheckDefinitionFingerprint(selectedDefinition) !== getCheckDefinitionFingerprint(details.definition)) {
+        throw new Error('Check attempt definition must match an immutable batch definition snapshot');
+    }
+    if (details.rerunOfAttemptRunId) {
+        const source = db.prepare(`
+      SELECT source_run.project_id, source_run.kind, source_run.status, source.definition_id, source.batch_run_id,
+             source.outcome,
+             source_batch.rerun_of_batch_run_id
+      FROM execution_runs source_run
+      JOIN check_attempt_details source ON source.execution_run_id = source_run.id
+      JOIN check_batch_details source_batch ON source_batch.execution_run_id = ?
+      WHERE source_run.id = ?
+    `).get(batch.id, details.rerunOfAttemptRunId);
+        if (!source
+            || source.project_id !== projectId
+            || source.kind !== 'check_attempt'
+            || !['completed', 'failed', 'cancelled', 'interrupted'].includes(source.status)
+            || source.outcome === null
+            || source.definition_id !== details.definition.id
+            || source.batch_run_id !== source.rerun_of_batch_run_id) {
+            throw new Error('Check rerun attempt must match the stable definition ID in the source batch');
+        }
+    }
+};
+export const insertCheckAttemptDetails = (projectId, runId, details) => {
+    validateCheckAttemptDetails(projectId, runId, details);
+    const definition = canonicalDefinition(details.definition);
+    db.prepare(`
+    INSERT INTO check_attempt_details (
+      execution_run_id, batch_run_id, definition_id, command_snapshot_json,
+      definition_fingerprint, initial_workspace_identity_json, rerun_of_attempt_run_id
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(runId, details.batchRunId, definition.id, JSON.stringify(definition), getCheckDefinitionFingerprint(definition), JSON.stringify(canonicalWorkspaceIdentity(details.initialWorkspaceIdentity)), details.rerunOfAttemptRunId ?? null);
+};
+export const getCheckBatchDetails = (projectId, runId) => {
+    const row = db.prepare(`
+    SELECT details.*, run.project_id, run.status AS execution_status
+    FROM check_batch_details details
+    JOIN execution_runs run ON run.id = details.execution_run_id
+    WHERE run.project_id = ? AND run.id = ?
+  `).get(projectId, runId);
+    if (!row) {
+        return null;
+    }
+    const { selected_definition_snapshots_json, initial_workspace_identity_json, ...details } = row;
+    return {
+        ...details,
+        stop_requested: row.stop_requested === 1,
+        selected_definition_snapshots: parseJson(selected_definition_snapshots_json),
+        initial_workspace_identity: parseJson(initial_workspace_identity_json),
+    };
+};
+export const listCheckBatchDetailsForRuns = (projectId, runIds) => {
+    const ids = [...new Set(runIds)];
+    if (ids.length === 0) {
+        return new Map();
+    }
+    const rows = db.prepare(`
+    SELECT details.*, run.project_id, run.status AS execution_status
+    FROM check_batch_details details
+    JOIN execution_runs run ON run.id = details.execution_run_id
+    WHERE run.project_id = ? AND run.id IN (${ids.map(() => '?').join(', ')})
+  `).all(projectId, ...ids);
+    return new Map(rows.map(row => {
+        const { selected_definition_snapshots_json, initial_workspace_identity_json, ...details } = row;
+        return [row.execution_run_id, {
+                ...details,
+                stop_requested: row.stop_requested === 1,
+                selected_definition_snapshots: parseJson(selected_definition_snapshots_json),
+                initial_workspace_identity: parseJson(initial_workspace_identity_json),
+            }];
+    }));
+};
+export const getCheckAttemptDetails = (projectId, runId) => {
+    const row = db.prepare(`
+    SELECT details.*, run.project_id, run.status AS execution_status
+    FROM check_attempt_details details
+    JOIN execution_runs run ON run.id = details.execution_run_id
+    WHERE run.project_id = ? AND run.id = ?
+  `).get(projectId, runId);
+    if (!row) {
+        return null;
+    }
+    const { command_snapshot_json, initial_workspace_identity_json, final_workspace_identity_json, ...details } = row;
+    return {
+        ...details,
+        command_snapshot: parseJson(command_snapshot_json),
+        initial_workspace_identity: parseJson(initial_workspace_identity_json),
+        final_workspace_identity: final_workspace_identity_json ? parseJson(final_workspace_identity_json) : null,
+    };
+};
+export const listCheckAttemptDetailsForRuns = (projectId, runIds) => {
+    const ids = [...new Set(runIds)];
+    if (ids.length === 0) {
+        return new Map();
+    }
+    const rows = db.prepare(`
+    SELECT details.*, run.project_id, run.status AS execution_status
+    FROM check_attempt_details details
+    JOIN execution_runs run ON run.id = details.execution_run_id
+    WHERE run.project_id = ? AND run.id IN (${ids.map(() => '?').join(', ')})
+  `).all(projectId, ...ids);
+    return new Map(rows.map(row => {
+        const { command_snapshot_json, initial_workspace_identity_json, final_workspace_identity_json, ...details } = row;
+        return [row.execution_run_id, {
+                ...details,
+                command_snapshot: parseJson(command_snapshot_json),
+                initial_workspace_identity: parseJson(initial_workspace_identity_json),
+                final_workspace_identity: final_workspace_identity_json ? parseJson(final_workspace_identity_json) : null,
+            }];
+    }));
+};
+export const listCheckAttemptDetails = (projectId, batchRunId) => {
+    const rows = db.prepare(`
+    SELECT details.*, run.project_id, run.status AS execution_status
+    FROM check_attempt_details details
+    JOIN execution_runs run ON run.id = details.execution_run_id
+    WHERE run.project_id = ? AND details.batch_run_id = ?
+    ORDER BY run.rowid ASC
+  `).all(projectId, batchRunId);
+    return rows.map(row => {
+        const { command_snapshot_json, initial_workspace_identity_json, final_workspace_identity_json, ...details } = row;
+        return {
+            ...details,
+            command_snapshot: parseJson(command_snapshot_json),
+            initial_workspace_identity: parseJson(initial_workspace_identity_json),
+            final_workspace_identity: final_workspace_identity_json ? parseJson(final_workspace_identity_json) : null,
+        };
+    });
+};
+export const listCheckAttemptDetailsForBatches = (projectId, batchRunIds) => {
+    const ids = [...new Set(batchRunIds)];
+    const attemptsByBatchId = new Map(ids.map(id => [id, []]));
+    if (ids.length === 0) {
+        return attemptsByBatchId;
+    }
+    const rows = db.prepare(`
+    SELECT details.*, run.project_id, run.status AS execution_status
+    FROM check_attempt_details details
+    JOIN execution_runs run ON run.id = details.execution_run_id
+    WHERE run.project_id = ? AND details.batch_run_id IN (${ids.map(() => '?').join(', ')})
+    ORDER BY run.created_at ASC, run.id ASC
+  `).all(projectId, ...ids);
+    for (const row of rows) {
+        const { command_snapshot_json, initial_workspace_identity_json, final_workspace_identity_json, ...details } = row;
+        attemptsByBatchId.get(row.batch_run_id)?.push({
+            ...details,
+            command_snapshot: parseJson(command_snapshot_json),
+            initial_workspace_identity: parseJson(initial_workspace_identity_json),
+            final_workspace_identity: final_workspace_identity_json ? parseJson(final_workspace_identity_json) : null,
+        });
+    }
+    return attemptsByBatchId;
+};
+const resolveRerunDefinitionIds = (selection, sourceAttempts) => {
+    if (selection.mode === 'all') {
+        return sourceAttempts.map(attempt => attempt.definition_id);
+    }
+    if (selection.mode === 'failed') {
+        return sourceAttempts
+            .filter(attempt => attempt.outcome !== 'passed')
+            .map(attempt => attempt.definition_id);
+    }
+    if (selection.definitionIds.length === 0 || selection.definitionIds.length !== new Set(selection.definitionIds).size) {
+        throw new Error('Selected check reruns require at least one unique source definition ID');
+    }
+    return selection.definitionIds;
+};
+export const resolveCheckBatchRerunEligibility = (input) => {
+    const sourceBatch = getCheckBatchDetails(input.projectId, input.batchRunId);
+    const attempts = sourceBatch ? listCheckAttemptDetails(input.projectId, sourceBatch.execution_run_id) : [];
+    return resolveCheckBatchRerunEligibilityFromDetails({
+        batch: sourceBatch,
+        attempts,
+        availableDefinitions: input.availableDefinitions,
+        selection: input.selection,
+        targetAvailable: input.targetAvailable,
+        workspaceAvailable: input.workspaceAvailable,
+        targetBusy: Boolean(sourceBatch && findActiveCheckBatchForTarget(input.projectId, sourceBatch.target_kind, sourceBatch.target_bundle_id)),
+    });
+};
+export const resolveCheckBatchRerunEligibilityFromDetails = (input) => {
+    const sourceBatch = input.batch;
+    if (!sourceBatch || !TERMINAL_STATUSES.has(sourceBatch.execution_status)) {
+        return { eligible: false, reason: 'status_not_retryable' };
+    }
+    if (!input.targetAvailable) {
+        return { eligible: false, reason: 'retry_target_missing' };
+    }
+    if (!input.workspaceAvailable) {
+        return { eligible: false, reason: 'retry_workspace_unavailable' };
+    }
+    if (input.targetBusy) {
+        return { eligible: false, reason: 'retry_target_busy' };
+    }
+    const attempts = input.attempts;
+    if (attempts.length !== sourceBatch.selected_definition_snapshots.length || attempts.length === 0 || attempts.some(attempt => attempt.outcome === null)) {
+        return { eligible: false, reason: 'retry_input_unavailable' };
+    }
+    const availableIds = new Set(input.availableDefinitions.map(definition => definition.id));
+    let definitionIds;
+    try {
+        definitionIds = resolveRerunDefinitionIds(input.selection ?? { mode: 'all' }, attempts);
+    }
+    catch {
+        return { eligible: false, reason: 'retry_input_unavailable' };
+    }
+    const sourceIds = new Set(attempts.map(attempt => attempt.definition_id));
+    if (definitionIds.length === 0 || definitionIds.some(id => !sourceIds.has(id) || !availableIds.has(id))) {
+        return { eligible: false, reason: 'retry_input_unavailable' };
+    }
+    return { eligible: true, reason: null };
+};
+const getCheckTargetKey = (targetKind, targetBundleId) => (`${targetKind}:${targetBundleId ?? ''}`);
+export const listActiveCheckBatchTargetKeys = (projectId) => {
+    const rows = db.prepare(`
+    SELECT details.target_kind, details.target_bundle_id
+    FROM execution_runs run
+    JOIN check_batch_details details ON details.execution_run_id = run.id
+    WHERE run.project_id = ? AND run.status IN ('queued', 'waiting', 'running')
+  `).all(projectId);
+    return new Set(rows.map(row => getCheckTargetKey(row.target_kind, row.target_bundle_id)));
+};
+export const isCheckBatchTargetActive = (activeTargetKeys, batch) => (activeTargetKeys.has(getCheckTargetKey(batch.target_kind, batch.target_bundle_id)));
+export const listCheckBatchTargetStates = (projectId, batches) => {
+    const bundleIds = [...new Set(batches.flatMap(batch => batch.target_kind === 'bundle' && batch.target_bundle_id
+            ? [batch.target_bundle_id]
+            : []))];
+    const bundles = bundleIds.length === 0
+        ? []
+        : db.prepare(`
+        SELECT id, branch, kind FROM worktree_bundles
+        WHERE project_id = ? AND id IN (${bundleIds.map(() => '?').join(', ')})
+      `).all(projectId, ...bundleIds);
+    const bundlesById = new Map(bundles.map(bundle => [bundle.id, bundle]));
+    return new Map(batches.map(batch => {
+        if (batch.target_kind === 'repo_root') {
+            return [batch.execution_run_id, { targetAvailable: true, bundleBranch: null }];
+        }
+        const bundle = batch.target_bundle_id ? bundlesById.get(batch.target_bundle_id) : undefined;
+        return [batch.execution_run_id, {
+                targetAvailable: Boolean(bundle && bundle.kind !== 'project_root'),
+                bundleBranch: bundle?.kind === 'project_root' ? null : bundle?.branch ?? null,
+            }];
+    }));
+};
+export const getCheckBatchTargetState = (projectId, batch) => {
+    if (batch.target_kind === 'repo_root') {
+        return { targetAvailable: true, bundleBranch: null };
+    }
+    const bundle = db.prepare(`
+    SELECT branch, kind FROM worktree_bundles WHERE id = ? AND project_id = ?
+  `).get(batch.target_bundle_id, projectId);
+    return {
+        targetAvailable: Boolean(bundle && bundle.kind !== 'project_root'),
+        bundleBranch: bundle?.kind === 'project_root' ? null : bundle?.branch ?? null,
+    };
+};
+export const rerunCheckBatch = (input) => {
+    const sourceBatch = getCheckBatchDetails(input.projectId, input.sourceBatchRunId);
+    if (!sourceBatch || !TERMINAL_STATUSES.has(sourceBatch.execution_status)) {
+        throw new Error('Check rerun source must be a terminal batch in the same project');
+    }
+    assertWorkspaceIdentity(input.initialWorkspaceIdentity, 'Initial workspace identity');
+    if (input.initialWorkspaceIdentity.state !== 'available') {
+        throw new Error(`Check workspace identity is unavailable: ${input.initialWorkspaceIdentity.message}`);
+    }
+    const conflict = findActiveCheckBatchForTarget(input.projectId, sourceBatch.target_kind, sourceBatch.target_bundle_id);
+    if (conflict) {
+        throw new Error(`Check batch ${conflict} is already active for this target`);
+    }
+    const sourceAttempts = listCheckAttemptDetails(input.projectId, sourceBatch.execution_run_id);
+    if (sourceAttempts.length !== sourceBatch.selected_definition_snapshots.length || sourceAttempts.some(attempt => attempt.outcome === null)) {
+        throw new Error('Check rerun source attempt provenance is incomplete');
+    }
+    const sourceAttemptsByDefinitionId = new Map(sourceAttempts.map(attempt => [attempt.definition_id, attempt]));
+    const definitionIds = resolveRerunDefinitionIds(input.selection, sourceAttempts);
+    if (definitionIds.length === 0) {
+        throw new Error('The source batch has no matching attempts to rerun');
+    }
+    const availableById = new Map(input.availableDefinitions.map(definition => [definition.id, definition]));
+    const selectedDefinitions = definitionIds.map(definitionId => {
+        if (!sourceAttemptsByDefinitionId.has(definitionId)) {
+            throw new Error(`Check definition ${definitionId} does not belong to the source batch`);
+        }
+        const definition = availableById.get(definitionId);
+        if (!definition) {
+            throw new Error(`Check definition ${definitionId} is stale or unavailable`);
+        }
+        return definition;
+    });
+    const batchRunId = randomUUID();
+    const attempts = selectedDefinitions.map(definition => ({ runId: randomUUID(), definition }));
+    const target = sourceBatch.target_kind === 'bundle'
+        ? { targetKind: 'bundle', targetBundleId: sourceBatch.target_bundle_id }
+        : { targetKind: 'repo_root', targetBundleId: null };
+    const scopeLinks = sourceBatch.target_bundle_id
+        ? [{ entityType: 'bundle', entityId: sourceBatch.target_bundle_id, relationship: 'context' }]
+        : [];
+    input.transaction.createExecutionRun({
+        id: batchRunId,
+        projectId: input.projectId,
+        kind: 'check_batch',
+        domainStatus: 'queued',
+        sourceReference: { kind: 'project', id: input.projectId },
+        links: scopeLinks,
+        eventType: 'check_batch_rerun_created',
+        eventMetadata: { rerun_of_batch_run_id: sourceBatch.execution_run_id },
+        checkBatchDetails: {
+            ...target,
+            targetLabel: sourceBatch.target_label,
+            selectedDefinitions,
+            initialWorkspaceIdentity: input.initialWorkspaceIdentity,
+            rerunOfBatchRunId: sourceBatch.execution_run_id,
+        },
+    });
+    for (const attempt of attempts) {
+        input.transaction.createExecutionRun({
+            id: attempt.runId,
+            projectId: input.projectId,
+            kind: 'check_attempt',
+            parentRunId: batchRunId,
+            domainStatus: 'queued',
+            sourceReference: { kind: 'project', id: input.projectId },
+            links: scopeLinks,
+            eventType: 'check_attempt_rerun_created',
+            checkAttemptDetails: {
+                batchRunId,
+                definition: attempt.definition,
+                initialWorkspaceIdentity: input.initialWorkspaceIdentity,
+                rerunOfAttemptRunId: sourceAttemptsByDefinitionId.get(attempt.definition.id)?.execution_run_id ?? null,
+            },
+        });
+    }
+    input.transaction.transitionExecutionRun({
+        projectId: input.projectId,
+        runId: batchRunId,
+        status: 'running',
+        domainStatus: 'running',
+        eventType: 'check_batch_started',
+    });
+    return {
+        batchRunId,
+        attempts,
+        batch: getCheckBatchDetails(input.projectId, batchRunId),
+    };
+};
+export const setCheckBatchStopRequested = (projectId, runId) => {
+    if (!getCheckBatchDetails(projectId, runId)) {
+        throw new Error(`Check batch ${runId} was not found in project ${projectId}`);
+    }
+    db.prepare('UPDATE check_batch_details SET stop_requested = 1 WHERE execution_run_id = ?').run(runId);
+    return getCheckBatchDetails(projectId, runId);
+};
+export const findActiveCheckBatchForTarget = (projectId, targetKind, targetBundleId) => {
+    const row = db.prepare(`
+    SELECT run.id
+    FROM execution_runs run
+    JOIN check_batch_details details ON details.execution_run_id = run.id
+    WHERE run.project_id = ?
+      AND run.status IN ('queued', 'waiting', 'running')
+      AND details.target_kind = ?
+      AND details.target_bundle_id IS ?
+    ORDER BY run.rowid ASC
+    LIMIT 1
+  `).get(projectId, targetKind, targetBundleId);
+    return row?.id ?? null;
+};
+export const hasActiveProjectCheckBatch = (projectId) => Boolean(db.prepare(`
+  SELECT 1
+  FROM execution_runs run
+  JOIN check_batch_details details ON details.execution_run_id = run.id
+  WHERE run.project_id = ? AND run.status IN ('queued', 'waiting', 'running')
+  LIMIT 1
+`).get(projectId));
+export const updateCheckAttemptOutputState = (input) => {
+    const current = getCheckAttemptDetails(input.projectId, input.runId);
+    if (!current) {
+        throw new Error(`Check attempt ${input.runId} was not found in project ${input.projectId}`);
+    }
+    if (!Number.isSafeInteger(input.outputRevision)
+        || input.outputRevision <= current.output_revision
+        || !Number.isSafeInteger(input.retainedStartOffset)
+        || input.retainedStartOffset < current.retained_start_offset
+        || !Number.isSafeInteger(input.retainedEndOffset)
+        || input.retainedEndOffset < input.retainedStartOffset
+        || !Number.isSafeInteger(input.totalPersistedBytes)
+        || input.totalPersistedBytes < current.total_persisted_bytes
+        || input.retainedEndOffset > input.totalPersistedBytes) {
+        throw new Error('Check attempt output revisions and byte offsets must advance monotonically');
+    }
+    db.prepare(`
+    UPDATE check_attempt_details
+    SET output_revision = ?, retained_start_offset = ?, retained_end_offset = ?,
+        total_persisted_bytes = ?, output_retention_state = ?
+    WHERE execution_run_id = ?
+  `).run(input.outputRevision, input.retainedStartOffset, input.retainedEndOffset, input.totalPersistedBytes, input.outputRetentionState ?? current.output_retention_state, input.runId);
+    return getCheckAttemptDetails(input.projectId, input.runId);
+};
+export const appendCheckAttemptOutput = (input) => {
+    const append = db.transaction(() => {
+        const current = getCheckAttemptDetails(input.projectId, input.runId);
+        if (!current) {
+            throw new Error(`Check attempt ${input.runId} was not found in project ${input.projectId}`);
+        }
+        if (current.output_retention_state !== 'retained') {
+            throw new Error(`Check attempt ${input.runId} output is not retained`);
+        }
+        const byteLimit = input.retainedByteLimit ?? CHECK_ATTEMPT_OUTPUT_LIMIT_BYTES;
+        if (!Number.isSafeInteger(byteLimit) || byteLimit < 1) {
+            throw new Error('Check attempt retained output byte limit must be a positive integer');
+        }
+        const chunkBytes = Buffer.byteLength(input.chunk, 'utf8');
+        const fromOffset = current.total_persisted_bytes;
+        const toOffset = fromOffset + chunkBytes;
+        if (!Number.isSafeInteger(toOffset)) {
+            throw new Error('Check attempt output byte count exceeds the safe integer range');
+        }
+        const retainedOutput = retainUtf8Suffix(`${current.retained_output}${input.chunk}`, byteLimit);
+        const retainedBytes = Buffer.byteLength(retainedOutput, 'utf8');
+        const retainedStartOffset = toOffset - retainedBytes;
+        const revision = current.output_revision + 1;
+        db.prepare(`
+      UPDATE check_attempt_details
+      SET output_revision = ?, retained_start_offset = ?, retained_end_offset = ?,
+          total_persisted_bytes = ?, retained_output = ?
+      WHERE execution_run_id = ?
+    `).run(revision, retainedStartOffset, toOffset, toOffset, retainedOutput, input.runId);
+        return {
+            project_id: input.projectId,
+            batch_run_id: current.batch_run_id,
+            attempt_run_id: input.runId,
+            revision,
+            from_offset: fromOffset,
+            to_offset: toOffset,
+            retained_start_offset: retainedStartOffset,
+            chunk: input.chunk,
+            output_truncated: retainedStartOffset > 0,
+        };
+    });
+    return append.immediate();
+};
+export const completeCheckAttemptDetails = (input) => {
+    if (!CHECK_ATTEMPT_OUTCOMES.includes(input.outcome)) {
+        throw new Error(`Unsupported check attempt outcome: ${input.outcome}`);
+    }
+    assertWorkspaceIdentity(input.finalWorkspaceIdentity, 'Final workspace identity');
+    const current = getCheckAttemptDetails(input.projectId, input.runId);
+    if (!current) {
+        throw new Error(`Check attempt ${input.runId} was not found in project ${input.projectId}`);
+    }
+    if (current.outcome) {
+        const agrees = current.outcome === input.outcome
+            && JSON.stringify(current.final_workspace_identity) === JSON.stringify(canonicalWorkspaceIdentity(input.finalWorkspaceIdentity))
+            && current.exit_code === (input.exitCode ?? null)
+            && current.exit_signal === (input.exitSignal ?? null)
+            && current.exit_error === (input.exitError ?? null);
+        if (!agrees) {
+            throw new Error(`Check attempt ${input.runId} already has immutable conflicting outcome details`);
+        }
+        return current;
+    }
+    db.prepare(`
+    UPDATE check_attempt_details
+    SET final_workspace_identity_json = ?, outcome = ?, exit_code = ?, exit_signal = ?, exit_error = ?
+    WHERE execution_run_id = ?
+  `).run(JSON.stringify(canonicalWorkspaceIdentity(input.finalWorkspaceIdentity)), input.outcome, input.exitCode ?? null, input.exitSignal ?? null, input.exitError ?? null, input.runId);
+    return getCheckAttemptDetails(input.projectId, input.runId);
+};
+export const refreshCheckBatchAggregation = (projectId, batchRunId) => {
+    const existingBatch = getCheckBatchDetails(projectId, batchRunId);
+    if (!existingBatch) {
+        throw new Error(`Check batch ${batchRunId} was not found in project ${projectId}`);
+    }
+    const counts = db.prepare(`
+    SELECT
+      SUM(CASE WHEN run.status IN ('queued', 'waiting') THEN 1 ELSE 0 END) AS queued_count,
+      SUM(CASE WHEN run.status = 'running' THEN 1 ELSE 0 END) AS running_count,
+      SUM(CASE WHEN details.outcome = 'passed' THEN 1 ELSE 0 END) AS passed_count,
+      SUM(CASE WHEN details.outcome IN ('command_failure', 'spawn_failure', 'timeout', 'workspace_changed_before_start') THEN 1 ELSE 0 END) AS failed_count,
+      SUM(CASE WHEN details.outcome = 'user_stop' THEN 1 ELSE 0 END) AS cancelled_count,
+      SUM(CASE WHEN details.outcome IN ('restart_loss', 'shutdown_loss') THEN 1 ELSE 0 END) AS interrupted_count
+    FROM check_attempt_details details
+    JOIN execution_runs run ON run.id = details.execution_run_id
+    WHERE details.batch_run_id = ? AND run.project_id = ?
+  `).get(batchRunId, projectId);
+    db.prepare(`
+    UPDATE check_batch_details
+    SET queued_count = ?, running_count = ?, passed_count = ?, failed_count = ?,
+        cancelled_count = ?, interrupted_count = ?
+    WHERE execution_run_id = ?
+  `).run(counts.queued_count ?? 0, counts.running_count ?? 0, counts.passed_count ?? 0, counts.failed_count ?? 0, counts.cancelled_count ?? 0, counts.interrupted_count ?? 0, batchRunId);
+    return getCheckBatchDetails(projectId, batchRunId);
+};
+export const inspectCheckBatchAggregation = (projectId, batchRunId) => {
+    const aggregate = db.transaction(() => {
+        const before = getCheckBatchDetails(projectId, batchRunId);
+        if (!before) {
+            throw new Error(`Check batch ${batchRunId} was not found in project ${projectId}`);
+        }
+        const attempts = listCheckAttemptDetails(projectId, batchRunId);
+        const batch = refreshCheckBatchAggregation(projectId, batchRunId);
+        const expectedChildCount = batch.selected_definition_snapshots.length;
+        const activeChildCount = attempts.filter(attempt => !TERMINAL_STATUSES.has(attempt.execution_status)).length;
+        const terminalWithoutOutcome = attempts.some(attempt => TERMINAL_STATUSES.has(attempt.execution_status) && attempt.outcome === null);
+        const activeWithOutcome = attempts.some(attempt => !TERMINAL_STATUSES.has(attempt.execution_status) && attempt.outcome !== null);
+        let infrastructureError = null;
+        if (attempts.length !== expectedChildCount) {
+            infrastructureError = `Check batch expected ${expectedChildCount} children but found ${attempts.length}`;
+        }
+        else if (terminalWithoutOutcome || activeWithOutcome) {
+            infrastructureError = 'Check batch child status and outcome state is inconsistent';
+        }
+        else if (TERMINAL_STATUSES.has(batch.execution_status) && activeChildCount > 0) {
+            infrastructureError = 'Terminal check batch still has active children';
+        }
+        let terminalStatus = null;
+        if (activeChildCount === 0) {
+            if (batch.interrupted_count > 0) {
+                terminalStatus = 'interrupted';
+            }
+            else if (batch.stop_requested) {
+                terminalStatus = 'cancelled';
+            }
+            else if (infrastructureError || batch.failed_count > 0) {
+                terminalStatus = 'failed';
+            }
+            else if (batch.cancelled_count > 0) {
+                terminalStatus = 'cancelled';
+            }
+            else if (batch.passed_count === expectedChildCount) {
+                terminalStatus = 'completed';
+            }
+            else {
+                infrastructureError = infrastructureError ?? 'Check batch children did not produce a complete terminal outcome set';
+                terminalStatus = 'failed';
+            }
+        }
+        return {
+            batch,
+            child_count: attempts.length,
+            expected_child_count: expectedChildCount,
+            active_child_count: activeChildCount,
+            terminal_status: terminalStatus,
+            infrastructure_error: infrastructureError,
+        };
+    });
+    return aggregate();
+};
+export const isCheckAttemptCurrent = (details, workspaceIdentity) => (details.outcome === 'passed'
+    && details.initial_workspace_identity.state === 'available'
+    && details.final_workspace_identity?.state === 'available'
+    && workspaceIdentity.state === 'available'
+    && details.initial_workspace_identity.fingerprint === details.final_workspace_identity.fingerprint
+    && details.final_workspace_identity.fingerprint === workspaceIdentity.fingerprint);
+//# sourceMappingURL=checkRuns.js.map