vgxness 0.1.0

package/dist/runs/repositories/runs.js

@@ -0,0 +1,611 @@
+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;
+            }
+            const rows = this.db.connection.prepare(`
+        SELECT * FROM runs
+        ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+        ORDER BY created_at DESC
+      `).all(parameters);
+            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 };
+}