vgxness 1.20.4 → 1.20.6

package/dist/runs/repositories/runs.js

@@ -1,676 +1 @@
-import { randomUUID } from 'node:crypto';
-const finalStatuses = new Set(['completed', 'failed', 'blocked', 'cancelled']);
-const allowedOutcomes = {
-    completed: ['success', 'partial'],
-    failed: ['failure'],
-    blocked: ['blocked'],
-    cancelled: ['cancelled'],
-};
-export class RunRepository {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    create(input) {
-        const validation = validateCreate(input);
-        if (!validation.ok)
-            return validation;
-        const result = this.db.transaction(() => {
-            const id = randomUUID();
-            const now = new Date().toISOString();
-            this.db.connection
-                .prepare(`
-        INSERT INTO runs(id, project, user_intent, workflow, phase, selected_agent_id, provider_adapter, model, status, created_at, updated_at)
-        VALUES (@id, @project, @userIntent, @workflow, @phase, @selectedAgentId, @providerAdapter, @model, 'created', @now, @now)
-      `)
-                .run({ ...input, id, now });
-            const run = this.getById(id);
-            if (!run.ok)
-                throw new Error(run.error.message);
-            return run.value;
-        });
-        return result.ok ? result : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    getById(id) {
-        try {
-            const row = this.db.connection.prepare('SELECT * FROM runs WHERE id=?').get(id);
-            return row ? ok(mapRun(row)) : missing(`Run not found: ${id}`);
-        }
-        catch (cause) {
-            return fail('Failed to read run', cause);
-        }
-    }
-    getDetails(id) {
-        const run = this.getById(id);
-        if (!run.ok)
-            return run;
-        const events = this.listEvents(id);
-        if (!events.ok)
-            return events;
-        const checkpoints = this.listCheckpoints(id);
-        if (!checkpoints.ok)
-            return checkpoints;
-        const approvals = this.listApprovals(id);
-        if (!approvals.ok)
-            return approvals;
-        const operationAttempts = this.listOperationAttempts(id);
-        if (!operationAttempts.ok)
-            return operationAttempts;
-        return ok({ ...run.value, events: events.value, checkpoints: checkpoints.value, approvals: approvals.value, operationAttempts: operationAttempts.value });
-    }
-    list(filters = {}) {
-        try {
-            const where = [];
-            const parameters = {};
-            if (filters.project !== undefined) {
-                where.push('project=@project');
-                parameters.project = filters.project;
-            }
-            if (filters.status !== undefined) {
-                where.push('status=@status');
-                parameters.status = filters.status;
-            }
-            if (filters.statuses !== undefined && filters.statuses.length > 0) {
-                const statusPlaceholders = filters.statuses.map((_, index) => `@status${index}`);
-                where.push(`status IN (${statusPlaceholders.join(', ')})`);
-                for (const [index, status] of filters.statuses.entries())
-                    parameters[`status${index}`] = status;
-            }
-            const limitClause = filters.limit === undefined ? '' : 'LIMIT @limit';
-            const queryParameters = { ...parameters };
-            if (filters.limit !== undefined)
-                queryParameters.limit = filters.limit;
-            const rows = this.db.connection
-                .prepare(`
-        SELECT * FROM runs
-        ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
-        ORDER BY created_at DESC
-        ${limitClause}
-      `)
-                .all(queryParameters);
-            return ok(rows.map(mapRun));
-        }
-        catch (cause) {
-            return fail('Failed to list runs', cause);
-        }
-    }
-    appendEvent(input) {
-        const run = this.getById(input.runId);
-        if (!run.ok)
-            return run;
-        if (!input.title.trim())
-            return validationFailure('Run event title is required');
-        const result = this.db.transaction(() => {
-            const next = this.nextSequence('run_events', input.runId);
-            const event = {
-                id: randomUUID(),
-                runId: input.runId,
-                sequence: next,
-                kind: input.kind,
-                title: input.title,
-                payloadJson: JSON.stringify(input.payload ?? {}),
-                relatedType: input.relatedType ?? null,
-                relatedId: input.relatedId ?? null,
-                createdAt: new Date().toISOString(),
-            };
-            this.db.connection
-                .prepare(`
-        INSERT INTO run_events(id, run_id, sequence, kind, title, payload_json, related_type, related_id, created_at)
-        VALUES (@id, @runId, @sequence, @kind, @title, @payloadJson, @relatedType, @relatedId, @createdAt)
-      `)
-                .run(event);
-            return mapEventRow({
-                ...event,
-                run_id: event.runId,
-                payload_json: event.payloadJson,
-                related_type: event.relatedType,
-                related_id: event.relatedId,
-                created_at: event.createdAt,
-            });
-        });
-        return result.ok ? result : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    appendCheckpoint(input) {
-        const run = this.getById(input.runId);
-        if (!run.ok)
-            return run;
-        if (finalStatuses.has(run.value.status))
-            return validationFailure(`Cannot checkpoint terminal run: ${run.value.status}`);
-        if (!input.label.trim())
-            return validationFailure('Run checkpoint label is required');
-        const result = this.db.transaction(() => {
-            const next = this.nextSequence('run_checkpoints', input.runId);
-            const checkpoint = {
-                id: randomUUID(),
-                runId: input.runId,
-                sequence: next,
-                label: input.label,
-                stateJson: JSON.stringify(input.state),
-                createdAt: new Date().toISOString(),
-            };
-            this.db.connection
-                .prepare(`
-        INSERT INTO run_checkpoints(id, run_id, sequence, label, state_json, created_at)
-        VALUES (@id, @runId, @sequence, @label, @stateJson, @createdAt)
-      `)
-                .run(checkpoint);
-            this.db.connection
-                .prepare('UPDATE runs SET latest_checkpoint_id=@checkpointId, updated_at=@updatedAt WHERE id=@runId')
-                .run({ checkpointId: checkpoint.id, updatedAt: checkpoint.createdAt, runId: input.runId });
-            return mapCheckpointRow({ ...checkpoint, run_id: checkpoint.runId, state_json: checkpoint.stateJson, created_at: checkpoint.createdAt });
-        });
-        return result.ok ? result : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    createApproval(input) {
-        const run = this.getById(input.runId);
-        if (!run.ok)
-            return run;
-        const decisionEvent = this.getEventById(input.decisionEventId);
-        if (!decisionEvent.ok)
-            return decisionEvent;
-        if (decisionEvent.value.runId !== input.runId)
-            return validationFailure('Approval decision event must belong to the run');
-        if (decisionEvent.value.kind !== 'permission-decision')
-            return validationFailure('Approval decision event must be a permission-decision event');
-        if (!isAskPermissionDecision(decisionEvent.value.payload))
-            return validationFailure('Approval can only be created for ask permission decisions');
-        const result = this.db.transaction(() => {
-            const approval = {
-                id: randomUUID(),
-                runId: input.runId,
-                decisionEventId: input.decisionEventId,
-                status: 'pending',
-                requestedAt: new Date().toISOString(),
-            };
-            this.db.connection
-                .prepare(`
-        INSERT INTO run_approvals(id, run_id, decision_event_id, status, requested_at)
-        VALUES (@id, @runId, @decisionEventId, @status, @requestedAt)
-      `)
-                .run(approval);
-            this.db.connection.prepare('UPDATE runs SET updated_at=@updatedAt WHERE id=@runId').run({ runId: input.runId, updatedAt: approval.requestedAt });
-            return approval;
-        });
-        return result.ok ? result : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    getApproval(id) {
-        try {
-            const row = this.db.connection.prepare('SELECT * FROM run_approvals WHERE id=?').get(id);
-            return row ? ok(mapApprovalRow(row)) : missing(`Approval not found: ${id}`);
-        }
-        catch (cause) {
-            return fail('Failed to read run approval', cause);
-        }
-    }
-    listApprovals(runId) {
-        const run = this.getById(runId);
-        if (!run.ok)
-            return run;
-        try {
-            const rows = this.db.connection.prepare('SELECT * FROM run_approvals WHERE run_id=? ORDER BY requested_at ASC').all(runId);
-            return ok(rows.map(mapApprovalRow));
-        }
-        catch (cause) {
-            return fail('Failed to list run approvals', cause);
-        }
-    }
-    listOperationAttempts(runId) {
-        const run = this.getById(runId);
-        if (!run.ok)
-            return run;
-        try {
-            const rows = this.db.connection
-                .prepare('SELECT * FROM run_operation_attempts WHERE run_id=? ORDER BY COALESCE(approval_id, id) ASC, attempt_sequence ASC, reserved_at ASC')
-                .all(runId);
-            return ok(rows.map(mapOperationAttemptRow));
-        }
-        catch (cause) {
-            return fail('Failed to list run operation attempts', cause);
-        }
-    }
-    getOperationAttempt(id) {
-        try {
-            const row = this.db.connection.prepare('SELECT * FROM run_operation_attempts WHERE id=?').get(id);
-            return row ? ok(mapOperationAttemptRow(row)) : missing(`Run operation attempt not found: ${id}`);
-        }
-        catch (cause) {
-            return fail('Failed to read run operation attempt', cause);
-        }
-    }
-    reserveOperationAttempt(input) {
-        const run = this.getById(input.runId);
-        if (!run.ok)
-            return run;
-        const decisionEvent = this.getEventById(input.decisionEventId);
-        if (!decisionEvent.ok)
-            return decisionEvent;
-        if (decisionEvent.value.runId !== input.runId)
-            return validationFailure('Attempt decision event must belong to the run');
-        if (input.pendingExecutionEventId !== undefined) {
-            const pendingEvent = this.getEventById(input.pendingExecutionEventId);
-            if (!pendingEvent.ok)
-                return pendingEvent;
-            if (pendingEvent.value.runId !== input.runId)
-                return validationFailure('Attempt pending execution event must belong to the run');
-        }
-        const result = this.db.transaction(() => {
-            const now = new Date().toISOString();
-            const existingReserved = input.approvalId === undefined
-                ? undefined
-                : this.db.connection.prepare("SELECT * FROM run_operation_attempts WHERE approval_id=? AND status='reserved'").get(input.approvalId);
-            if (existingReserved !== undefined) {
-                return validationFailure(`Approval already has an active operation attempt reservation: ${mapOperationAttemptRow(existingReserved).id}`);
-            }
-            const attemptSequence = input.approvalId === undefined
-                ? 1
-                : this.db.connection
-                    .prepare('SELECT COALESCE(MAX(attempt_sequence), 0) + 1 AS nextSequence FROM run_operation_attempts WHERE approval_id=?')
-                    .get(input.approvalId).nextSequence;
-            const attempt = {
-                id: randomUUID(),
-                runId: input.runId,
-                approvalId: input.approvalId ?? null,
-                attemptSequence,
-                decisionEventId: input.decisionEventId,
-                pendingExecutionEventId: input.pendingExecutionEventId ?? null,
-                category: input.category,
-                operation: input.operation,
-                operationJson: JSON.stringify(input.operationMetadata),
-                executorName: input.executorName,
-                status: 'reserved',
-                reservedAt: now,
-                updatedAt: now,
-            };
-            const insert = this.db.connection
-                .prepare(`
-        INSERT OR IGNORE INTO run_operation_attempts(
-          id, run_id, approval_id, attempt_sequence, decision_event_id, pending_execution_event_id,
-          category, operation, operation_json, executor_name, status, reserved_at, updated_at
-        ) VALUES (
-          @id, @runId, @approvalId, @attemptSequence, @decisionEventId, @pendingExecutionEventId,
-          @category, @operation, @operationJson, @executorName, @status, @reservedAt, @updatedAt
-        )
-      `)
-                .run(attempt);
-            if (insert.changes === 0) {
-                const existing = input.approvalId === undefined
-                    ? undefined
-                    : this.db.connection
-                        .prepare('SELECT * FROM run_operation_attempts WHERE approval_id=? AND attempt_sequence=?')
-                        .get(input.approvalId, attemptSequence);
-                const status = existing === undefined ? 'existing' : mapOperationAttemptRow(existing).status;
-                return validationFailure(`Approval attempt sequence is already reserved: ${status}`);
-            }
-            this.db.connection.prepare('UPDATE runs SET updated_at=@updatedAt WHERE id=@runId').run({ runId: input.runId, updatedAt: now });
-            return ok(mapOperationAttemptRow({
-                ...attempt,
-                run_id: attempt.runId,
-                approval_id: attempt.approvalId,
-                attempt_sequence: attempt.attemptSequence,
-                decision_event_id: attempt.decisionEventId,
-                pending_execution_event_id: attempt.pendingExecutionEventId,
-                operation_json: attempt.operationJson,
-                executor_name: attempt.executorName,
-                result_event_id: null,
-                output_json: null,
-                error_json: null,
-                reserved_at: attempt.reservedAt,
-                updated_at: attempt.updatedAt,
-                completed_at: null,
-            }));
-        });
-        return result.ok ? result.value : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    completeOperationAttempt(input) {
-        const existing = this.getOperationAttempt(input.attemptId);
-        if (!existing.ok)
-            return existing;
-        if (existing.value.status !== 'reserved')
-            return validationFailure(`Operation attempt is already finalized: ${existing.value.status}`);
-        const result = this.db.transaction(() => {
-            const now = new Date().toISOString();
-            this.db.connection
-                .prepare(`
-        UPDATE run_operation_attempts
-        SET status=@status, output_json=@outputJson, error_json=@errorJson, updated_at=@now, completed_at=@now
-        WHERE id=@attemptId AND status='reserved'
-      `)
-                .run({
-                attemptId: input.attemptId,
-                status: input.status,
-                outputJson: input.output === undefined ? null : JSON.stringify(input.output),
-                errorJson: input.error === undefined ? null : JSON.stringify(input.error),
-                now,
-            });
-            this.db.connection.prepare('UPDATE runs SET updated_at=@updatedAt WHERE id=@runId').run({ runId: existing.value.runId, updatedAt: now });
-            const updated = this.getOperationAttempt(input.attemptId);
-            if (!updated.ok)
-                throw new Error(updated.error.message);
-            return updated.value;
-        });
-        return result.ok ? result : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    abandonOperationAttempt(input) {
-        const existing = this.getOperationAttempt(input.attemptId);
-        if (!existing.ok)
-            return existing;
-        if (existing.value.status !== 'reserved')
-            return validationFailure(`Only reserved operation attempts can be abandoned: ${existing.value.status}`);
-        if (!input.actor.trim())
-            return validationFailure('Operation attempt abandonment actor is required');
-        if (!input.reason.trim())
-            return validationFailure('Operation attempt abandonment reason is required');
-        const result = this.db.transaction(() => {
-            const now = new Date().toISOString();
-            const update = this.db.connection
-                .prepare(`
-        UPDATE run_operation_attempts
-        SET status='abandoned', updated_at=@now, completed_at=@now
-        WHERE id=@attemptId AND status='reserved'
-      `)
-                .run({ attemptId: input.attemptId, now });
-            if (update.changes === 0)
-                return validationFailure(`Operation attempt is already finalized: ${input.attemptId}`);
-            const event = this.insertEvent({
-                runId: existing.value.runId,
-                kind: 'operation-execution',
-                title: `Operation attempt abandoned: ${existing.value.category} ${existing.value.operation}`,
-                payload: {
-                    status: 'abandoned',
-                    attemptId: existing.value.id,
-                    approvalId: existing.value.approvalId ?? null,
-                    decisionEventId: existing.value.decisionEventId,
-                    pendingExecutionEventId: existing.value.pendingExecutionEventId ?? null,
-                    actor: input.actor,
-                    reason: input.reason,
-                    timestamp: now,
-                    executorName: existing.value.executorName,
-                    executorInvoked: false,
-                    operationExecuted: false,
-                    retryAllowed: false,
-                    requestedOperation: existing.value.operationMetadata,
-                },
-                relatedType: 'operation-attempt',
-                relatedId: existing.value.id,
-            });
-            this.db.connection
-                .prepare('UPDATE run_operation_attempts SET result_event_id=@eventId, updated_at=@now WHERE id=@attemptId')
-                .run({ attemptId: input.attemptId, eventId: event.id, now });
-            this.db.connection.prepare('UPDATE runs SET updated_at=@updatedAt WHERE id=@runId').run({ runId: existing.value.runId, updatedAt: now });
-            const updated = this.getOperationAttempt(input.attemptId);
-            if (!updated.ok)
-                throw new Error(updated.error.message);
-            return ok({ attempt: updated.value, event });
-        });
-        return result.ok ? result.value : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    attachAttemptResultEvent(attemptId, eventId) {
-        const attempt = this.getOperationAttempt(attemptId);
-        if (!attempt.ok)
-            return attempt;
-        const event = this.getEventById(eventId);
-        if (!event.ok)
-            return event;
-        if (event.value.runId !== attempt.value.runId)
-            return validationFailure('Attempt result event must belong to the run');
-        const result = this.db.transaction(() => {
-            const now = new Date().toISOString();
-            this.db.connection
-                .prepare('UPDATE run_operation_attempts SET result_event_id=@eventId, updated_at=@now WHERE id=@attemptId')
-                .run({ attemptId, eventId, now });
-            const updated = this.getOperationAttempt(attemptId);
-            if (!updated.ok)
-                throw new Error(updated.error.message);
-            return updated.value;
-        });
-        return result.ok ? result : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    resolveApproval(input) {
-        const approval = this.getApproval(input.approvalId);
-        if (!approval.ok)
-            return approval;
-        if (approval.value.status !== 'pending')
-            return validationFailure(`Approval is already resolved: ${approval.value.status}`);
-        if (!input.actor.trim())
-            return validationFailure('Approval resolution actor is required');
-        const result = this.db.transaction(() => {
-            const resolvedAt = new Date().toISOString();
-            const update = this.db.connection
-                .prepare(`
-        UPDATE run_approvals
-        SET status=@status, resolved_at=@resolvedAt, resolved_by=@actor, resolution_reason=@reason
-        WHERE id=@approvalId AND status='pending'
-      `)
-                .run({ approvalId: input.approvalId, status: input.status, resolvedAt, actor: input.actor, reason: input.reason ?? null });
-            if (update.changes === 0)
-                return validationFailure(`Approval is already resolved or changed by another resolver: ${input.approvalId}`);
-            const event = this.insertEvent({
-                runId: approval.value.runId,
-                kind: 'approval',
-                title: `Approval ${input.status}`,
-                payload: {
-                    approvalId: input.approvalId,
-                    decisionEventId: approval.value.decisionEventId,
-                    status: input.status,
-                    actor: input.actor,
-                    reason: input.reason ?? null,
-                    resolvedAt,
-                    operationExecuted: false,
-                },
-                relatedType: 'approval',
-                relatedId: input.approvalId,
-            });
-            this.db.connection.prepare('UPDATE runs SET updated_at=@updatedAt WHERE id=@runId').run({ runId: approval.value.runId, updatedAt: resolvedAt });
-            const resolved = this.getApproval(input.approvalId);
-            if (!resolved.ok)
-                throw new Error(resolved.error.message);
-            return ok({ approval: resolved.value, event });
-        });
-        return result.ok ? result.value : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    updateFinalStatus(input) {
-        const run = this.getById(input.runId);
-        if (!run.ok)
-            return run;
-        if (finalStatuses.has(run.value.status))
-            return validationFailure(`Run is already terminal: ${run.value.status}`);
-        if (!allowedOutcomes[input.status].includes(input.outcome))
-            return validationFailure(`Outcome ${input.outcome} is not valid for status ${input.status}`);
-        const result = this.db.transaction(() => {
-            const now = new Date().toISOString();
-            this.db.connection
-                .prepare(`
-        UPDATE runs
-        SET status=@status, outcome=@outcome, outcome_reason=@outcomeReason, completed_at=@now, updated_at=@now
-        WHERE id=@runId
-      `)
-                .run({ ...input, outcomeReason: input.outcomeReason ?? null, now });
-            const updated = this.getById(input.runId);
-            if (!updated.ok)
-                throw new Error(updated.error.message);
-            return updated.value;
-        });
-        return result.ok ? result : fail(result.error.message, result.error.cause, result.error.code);
-    }
-    listEvents(runId) {
-        try {
-            const rows = this.db.connection.prepare('SELECT * FROM run_events WHERE run_id=? ORDER BY sequence ASC').all(runId);
-            return ok(rows.map(mapEventRow));
-        }
-        catch (cause) {
-            return fail('Failed to list run events', cause);
-        }
-    }
-    getEventById(id) {
-        try {
-            const row = this.db.connection.prepare('SELECT * FROM run_events WHERE id=?').get(id);
-            return row ? ok(mapEventRow(row)) : missing(`Run event not found: ${id}`);
-        }
-        catch (cause) {
-            return fail('Failed to read run event', cause);
-        }
-    }
-    listCheckpoints(runId) {
-        try {
-            const rows = this.db.connection.prepare('SELECT * FROM run_checkpoints WHERE run_id=? ORDER BY sequence ASC').all(runId);
-            return ok(rows.map(mapCheckpointRow));
-        }
-        catch (cause) {
-            return fail('Failed to list run checkpoints', cause);
-        }
-    }
-    nextSequence(table, runId) {
-        const row = this.db.connection.prepare(`SELECT COALESCE(MAX(sequence), 0) + 1 AS sequence FROM ${table} WHERE run_id=?`).get(runId);
-        return row.sequence;
-    }
-    insertEvent(input) {
-        const next = this.nextSequence('run_events', input.runId);
-        const event = {
-            id: randomUUID(),
-            runId: input.runId,
-            sequence: next,
-            kind: input.kind,
-            title: input.title,
-            payloadJson: JSON.stringify(input.payload ?? {}),
-            relatedType: input.relatedType ?? null,
-            relatedId: input.relatedId ?? null,
-            createdAt: new Date().toISOString(),
-        };
-        this.db.connection
-            .prepare(`
-      INSERT INTO run_events(id, run_id, sequence, kind, title, payload_json, related_type, related_id, created_at)
-      VALUES (@id, @runId, @sequence, @kind, @title, @payloadJson, @relatedType, @relatedId, @createdAt)
-    `)
-            .run(event);
-        return mapEventRow({
-            ...event,
-            run_id: event.runId,
-            payload_json: event.payloadJson,
-            related_type: event.relatedType,
-            related_id: event.relatedId,
-            created_at: event.createdAt,
-        });
-    }
-}
-function validateCreate(input) {
-    if (!input.project.trim())
-        return validationFailure('Run project is required');
-    if (!input.userIntent.trim())
-        return validationFailure('Run user intent is required');
-    if (!input.workflow.trim())
-        return validationFailure('Run workflow is required');
-    if (!input.phase.trim())
-        return validationFailure('Run phase is required');
-    if (!input.selectedAgentId.trim())
-        return validationFailure('Run selectedAgentId is required');
-    if (!input.providerAdapter.trim())
-        return validationFailure('Run providerAdapter is required');
-    if (!input.model.trim())
-        return validationFailure('Run model is required');
-    return ok(undefined);
-}
-function mapRun(row) {
-    const run = {
-        id: row.id,
-        project: row.project,
-        userIntent: row.user_intent,
-        workflow: row.workflow,
-        phase: row.phase,
-        selectedAgentId: row.selected_agent_id,
-        providerAdapter: row.provider_adapter,
-        model: row.model,
-        status: row.status,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-    if (row.outcome !== null)
-        run.outcome = row.outcome;
-    if (row.outcome_reason !== null)
-        run.outcomeReason = row.outcome_reason;
-    if (row.latest_checkpoint_id !== null)
-        run.latestCheckpointId = row.latest_checkpoint_id;
-    if (row.completed_at !== null)
-        run.completedAt = row.completed_at;
-    return run;
-}
-function mapEventRow(row) {
-    const event = {
-        id: row.id,
-        runId: row.run_id,
-        sequence: row.sequence,
-        kind: row.kind,
-        title: row.title,
-        payload: JSON.parse(row.payload_json),
-        createdAt: row.created_at,
-    };
-    if (row.related_type !== null)
-        event.relatedType = row.related_type;
-    if (row.related_id !== null)
-        event.relatedId = row.related_id;
-    return event;
-}
-function mapCheckpointRow(row) {
-    return { id: row.id, runId: row.run_id, sequence: row.sequence, label: row.label, state: JSON.parse(row.state_json), createdAt: row.created_at };
-}
-function mapApprovalRow(row) {
-    const approval = {
-        id: row.id,
-        runId: row.run_id,
-        decisionEventId: row.decision_event_id,
-        status: row.status,
-        requestedAt: row.requested_at,
-    };
-    if (row.resolved_at !== null)
-        approval.resolvedAt = row.resolved_at;
-    if (row.resolved_by !== null)
-        approval.resolvedBy = row.resolved_by;
-    if (row.resolution_reason !== null)
-        approval.resolutionReason = row.resolution_reason;
-    return approval;
-}
-function mapOperationAttemptRow(row) {
-    const attempt = {
-        id: row.id,
-        runId: row.run_id,
-        attemptSequence: row.attempt_sequence ?? 1,
-        decisionEventId: row.decision_event_id,
-        category: row.category,
-        operation: row.operation,
-        operationMetadata: JSON.parse(row.operation_json),
-        executorName: row.executor_name,
-        status: row.status,
-        reservedAt: row.reserved_at,
-        updatedAt: row.updated_at,
-    };
-    if (row.approval_id !== null)
-        attempt.approvalId = row.approval_id;
-    if (row.pending_execution_event_id !== null)
-        attempt.pendingExecutionEventId = row.pending_execution_event_id;
-    if (row.result_event_id !== null)
-        attempt.resultEventId = row.result_event_id;
-    if (row.output_json !== null)
-        attempt.output = JSON.parse(row.output_json);
-    if (row.error_json !== null)
-        attempt.error = JSON.parse(row.error_json);
-    if (row.completed_at !== null)
-        attempt.completedAt = row.completed_at;
-    return attempt;
-}
-function isAskPermissionDecision(payload) {
-    return typeof payload === 'object' && payload !== null && !Array.isArray(payload) && payload.decision === 'ask';
-}
-function ok(value) {
-    return { ok: true, value };
-}
-function missing(message) {
-    return { ok: false, error: { code: 'not_found', message } };
-}
-function validationFailure(message) {
-    return { ok: false, error: { code: 'validation_failed', message } };
-}
-function fail(message, cause, code = 'validation_failed') {
-    const error = { code, message };
-    if (cause !== undefined)
-        error.cause = cause;
-    return { ok: false, error };
-}
+export * from '../../storage/runs/repositories/runs.js';