@inflexa-ai/harness 0.1.1

package/dist/state/runs.js

@@ -0,0 +1,206 @@
+/**
+ * `cortex_runs` operations — run lifecycle, dedup, run-mandate persistence. oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+ *
+ * Every read/write returns `ResultAsync<T, DbError>` — a driver failure rides
+ * the err channel, absence rides ok (`ok(null)` / `ok([])`). The lone exception
+ * is `insertRun`'s dedup collision: `RunDedupCollisionError` is a control-flow
+ * signal (the caller recovers via `queryActiveRun`), not a storage failure, so
+ * it is thrown verbatim ABOVE the Result boundary rather than mapped to a
+ * `DbError`. Every other write maps SQLSTATE 23505/23503/23502/23514 to
+ * `err(constraint_violation)` via `tryMutation`.
+ */
+import { tryMutation, tryQuery } from "../lib/db-result.js";
+/**
+ * Raised when `insertRun` collides with the partial-unique index
+ * `idx_cortex_runs_active_plan` — i.e., an active run already exists for
+ * `(analysisId, planId)`. Callers SHOULD recover via `queryActiveRun` and
+ * return the existing `runId` instead of starting a fresh workflow.
+ */
+export class RunDedupCollisionError extends Error {
+    analysisId;
+    planId;
+    constructor(analysisId, planId) {
+        super(`active run already exists for (analysisId=${analysisId}, planId=${planId ?? "null"})`);
+        this.analysisId = analysisId;
+        this.planId = planId;
+        this.name = "RunDedupCollisionError";
+    }
+}
+/**
+ * Insert the run row. On the partial-unique index collision
+ * (`idx_cortex_runs_active_plan`) the function throws `RunDedupCollisionError`
+ * verbatim — a control-flow signal the caller recovers from via
+ * `queryActiveRun`, NOT a `DbError`. The throw rides out of the `ResultAsync`
+ * as a rejected promise (so an `await insertRun(...).match(...)`-free caller
+ * sees the same exception it always did); every other driver failure stays in
+ * the err channel as a `DbError`.
+ */
+export function insertRun(pool, input) {
+    const now = new Date().toISOString();
+    return tryMutation("runs.insertRun", async () => {
+        await pool.query({
+            text: `INSERT INTO cortex_runs
+            (run_id, analysis_id, thread_id, workflow_name,
+             status, started_at, plan_id, mandate_jti, mandate_expires_at) -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+            VALUES ($1, $2, $3, $4, 'running', $5, $6, $7, $8)`,
+            values: [
+                input.runId,
+                input.analysisId,
+                input.threadId ?? null,
+                input.workflowName,
+                now,
+                input.planId ?? null,
+                input.mandateJti ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+                input.mandateExpiresAt ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+            ],
+        });
+    }).mapErr((e) => {
+        // The dedup collision is control flow, not a storage failure — re-throw it
+        // verbatim ABOVE the Result boundary so the caller's existing
+        // catch(RunDedupCollisionError) path still fires. `mapErr` runs in the
+        // ResultAsync's promise body, so the throw surfaces as a rejection.
+        if (isPartialUniqueViolation(e.cause)) {
+            throw new RunDedupCollisionError(input.analysisId, input.planId ?? null);
+        }
+        return e;
+    });
+}
+function isPartialUniqueViolation(err) {
+    if (err === null || typeof err !== "object")
+        return false;
+    const e = err;
+    return e.code === "23505" && e.constraint === "idx_cortex_runs_active_plan";
+}
+/**
+ * Recover the active run row for `(analysisId, planId)` after `insertRun`
+ * raises `RunDedupCollisionError`. The partial-unique index guarantees at
+ * most one match.
+ */
+export function queryActiveRun(pool, analysisId, planId) {
+    return tryQuery("runs.queryActiveRun", async () => {
+        const result = await pool.query({
+            text: `SELECT run_id, analysis_id, thread_id, workflow_name,
+                   status, started_at, completed_at, error, parts,
+                   mandate_jti, mandate_expires_at, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+            FROM cortex_runs
+            WHERE analysis_id = $1
+              AND plan_id IS NOT DISTINCT FROM $2
+              AND status IN ('running','suspended_insufficient_funds')`,
+            values: [analysisId, planId],
+        });
+        const row = result.rows[0];
+        return row ? mapRunRow(row) : null;
+    });
+}
+export function updateRunStatus(pool, runId, status, error) {
+    const now = new Date().toISOString();
+    const isTerminal = status === "completed" || status === "partial" || status === "failed" || status === "canceled";
+    return tryMutation("runs.updateRunStatus", async () => {
+        await pool.query({
+            text: `UPDATE cortex_runs
+            SET status = $1, completed_at = $2, error = $3
+            WHERE run_id = $4`,
+            values: [status, isTerminal ? now : null, error ?? null, runId],
+        });
+    });
+}
+export function promoteFailedToPartial(pool, runId) {
+    return tryMutation("runs.promoteFailedToPartial", async () => {
+        const result = await pool.query({
+            text: `UPDATE cortex_runs SET status = 'partial'
+             WHERE run_id = $1 AND status = 'failed'`,
+            values: [runId],
+        });
+        return (result.rowCount ?? 0) > 0;
+    });
+}
+export function queryRun(pool, runId) {
+    return tryQuery("runs.queryRun", async () => {
+        const result = await pool.query({
+            text: `SELECT run_id, analysis_id, thread_id, workflow_name,
+                   status, started_at, completed_at, error, parts,
+                   mandate_jti, mandate_expires_at, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+            FROM cortex_runs
+            WHERE run_id = $1`,
+            values: [runId],
+        });
+        const row = result.rows[0];
+        return row ? mapRunRow(row) : null;
+    });
+}
+export function queryRunsByAnalysis(pool, analysisId, { limit = 50, offset = 0 } = {}) {
+    return tryQuery("runs.queryRunsByAnalysis", async () => {
+        const result = await pool.query({
+            text: `SELECT run_id, analysis_id, thread_id, workflow_name,
+                   status, started_at, completed_at, error, parts,
+                   mandate_jti, mandate_expires_at, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+            FROM cortex_runs
+            WHERE analysis_id = $1
+            ORDER BY started_at DESC LIMIT $2 OFFSET $3`,
+            values: [analysisId, limit, offset],
+        });
+        return result.rows.map(mapRunRow);
+    });
+}
+export function queryRunsByThread(pool, analysisId, threadId, { limit = 50, offset = 0 } = {}) {
+    return tryQuery("runs.queryRunsByThread", async () => {
+        const result = await pool.query({
+            text: `SELECT run_id, analysis_id, thread_id, workflow_name,
+                   status, started_at, completed_at, error, parts,
+                   mandate_jti, mandate_expires_at, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+            FROM cortex_runs
+            WHERE analysis_id = $1 AND thread_id = $2
+            ORDER BY started_at DESC LIMIT $3 OFFSET $4`,
+            values: [analysisId, threadId, limit, offset],
+        });
+        return result.rows.map(mapRunRow);
+    });
+}
+/**
+ * Persist the run mandate jti + expiry for a run. oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+ * Called by `authorizeForRun` after a successful mint so the cancel
+ * handler can revoke the mandate by `runId → jti` lookup. oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+ * The JWT itself is NOT persisted — it rides in DBOS workflow input.
+ */
+export function setRunMandate(pool, runId, jti, expiresAt) {
+    // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+    return tryMutation("runs.setRunMandate", async () => {
+        // oss-core-managed-ok: run-mandate ledger op label
+        await pool.query({
+            text: `UPDATE cortex_runs
+            SET mandate_jti = $1, mandate_expires_at = $2 -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+            WHERE run_id = $3`,
+            values: [jti, expiresAt, runId],
+        });
+    });
+}
+function mapRunRow(row) {
+    // JSONB is parsed by `pg` into native arrays/objects. Treat legacy TEXT
+    // rows (if anything slipped through) as strings and parse them.
+    let parts = null;
+    if (Array.isArray(row.parts)) {
+        parts = row.parts;
+    }
+    else if (typeof row.parts === "string") {
+        try {
+            parts = JSON.parse(row.parts);
+        }
+        catch {
+            /* malformed — treat as null */
+        }
+    }
+    return {
+        runId: row.run_id,
+        analysisId: row.analysis_id,
+        threadId: row.thread_id ?? null,
+        workflowName: row.workflow_name,
+        status: row.status,
+        startedAt: row.started_at,
+        completedAt: row.completed_at ?? null,
+        error: row.error ?? null,
+        parts,
+        mandateJti: row.mandate_jti ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+        mandateExpiresAt: row.mandate_expires_at ?? null, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+        planId: row.plan_id ?? null,
+    };
+}

package/dist/state/schema.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Cortex execution state schemas.
+ *
+ * Defines Zod schemas for the cortex_* tables and their payloads.
+ * These schemas are Cortex-internal — they never cross the service API boundary.
+ */
+import { z } from "zod";
+export declare const AnalysisStateRowSchema: z.ZodObject<{
+    resourceId: z.ZodString;
+    status: z.ZodString;
+    context: z.ZodNullable<z.ZodString>;
+    dataProfileStatus: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    dataProfileError: z.ZodNullable<z.ZodString>;
+    dataProfileStartedAt: z.ZodNullable<z.ZodString>;
+    dataProfileCompletedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type AnalysisStateRow = z.infer<typeof AnalysisStateRowSchema>;
+export declare const ArtifactRole: z.ZodEnum<{
+    input: "input";
+    step_output: "step_output";
+}>;
+export type ArtifactRole = z.infer<typeof ArtifactRole>;
+export declare const ArtifactRowSchema: z.ZodObject<{
+    resourceId: z.ZodString;
+    path: z.ZodString;
+    artifactId: z.ZodNullable<z.ZodString>;
+    fileId: z.ZodNullable<z.ZodString>;
+    hash: z.ZodString;
+    size: z.ZodNumber;
+    role: z.ZodEnum<{
+        input: "input";
+        step_output: "step_output";
+    }>;
+    sourceStep: z.ZodNullable<z.ZodString>;
+    sourceRun: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    unrecoverableAt: z.ZodNullable<z.ZodString>;
+    fileType: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ArtifactRow = z.infer<typeof ArtifactRowSchema>;
+export declare const RunStatus: z.ZodEnum<{
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    partial: "partial";
+    canceled: "canceled";
+    suspended_insufficient_funds: "suspended_insufficient_funds";
+}>;
+export type RunStatus = z.infer<typeof RunStatus>;
+export declare const StepExecutionStatus: z.ZodEnum<{
+    pending: "pending";
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    canceled: "canceled";
+    skipped: "skipped";
+    blocked: "blocked";
+}>;
+export type StepExecutionStatus = z.infer<typeof StepExecutionStatus>;
+export declare const CortexRunRowSchema: z.ZodObject<{
+    runId: z.ZodString;
+    analysisId: z.ZodString;
+    threadId: z.ZodNullable<z.ZodString>;
+    workflowName: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        partial: "partial";
+        canceled: "canceled";
+        suspended_insufficient_funds: "suspended_insufficient_funds";
+    }>;
+    startedAt: z.ZodString;
+    completedAt: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+    parts: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+    mandateJti: z.ZodNullable<z.ZodString>;
+    mandateExpiresAt: z.ZodNullable<z.ZodString>;
+    planId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type CortexRunRow = z.infer<typeof CortexRunRowSchema>;
+/**
+ * Persistable sandbox handle — what the active-sandbox registry stores on
+ * `cortex_step_executions.sandbox_ref`. Excludes the per-sandbox
+ * `callbackSecret`, which lives only in the DBOS step-output cache (ADR
+ * 0007). The harness reconstructs the full in-memory `SandboxRef` by
+ * reading the secret from the cached `createSandbox` step output.
+ */
+export declare const PersistedSandboxRefSchema: z.ZodObject<{
+    sandboxId: z.ZodString;
+    host: z.ZodString;
+    port: z.ZodNumber;
+    backend: z.ZodEnum<{
+        docker: "docker";
+        k8s: "k8s";
+    }>;
+}, z.core.$strip>;
+export type PersistedSandboxRef = z.infer<typeof PersistedSandboxRefSchema>;
+export declare const StepExecutionRowSchema: z.ZodObject<{
+    runId: z.ZodString;
+    stepId: z.ZodString;
+    analysisId: z.ZodString;
+    wave: z.ZodNumber;
+    agentId: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        canceled: "canceled";
+        skipped: "skipped";
+        blocked: "blocked";
+    }>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    completedAt: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    error: z.ZodNullable<z.ZodString>;
+    attempts: z.ZodDefault<z.ZodNumber>;
+    lastErrorClass: z.ZodNullable<z.ZodString>;
+    finishReason: z.ZodNullable<z.ZodString>;
+    hitMaxSteps: z.ZodDefault<z.ZodBoolean>;
+    blockedReason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    sandboxRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        sandboxId: z.ZodString;
+        host: z.ZodString;
+        port: z.ZodNumber;
+        backend: z.ZodEnum<{
+            docker: "docker";
+            k8s: "k8s";
+        }>;
+    }, z.core.$strip>>>;
+    execId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    childWorkflowId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type StepExecutionRow = z.infer<typeof StepExecutionRowSchema>;
+export declare const CortexPlanRowSchema: z.ZodObject<{
+    planId: z.ZodString;
+    analysisId: z.ZodString;
+    plan: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    parentPlanId: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type CortexPlanRow = z.infer<typeof CortexPlanRowSchema>;

package/dist/state/schema.js

@@ -0,0 +1,100 @@
+/**
+ * Cortex execution state schemas.
+ *
+ * Defines Zod schemas for the cortex_* tables and their payloads.
+ * These schemas are Cortex-internal — they never cross the service API boundary.
+ */
+import { z } from "zod";
+// ── Table Row Types ──────────────────────────────────────────────────
+export const AnalysisStateRowSchema = z.object({
+    resourceId: z.string(),
+    status: z.string(),
+    context: z.string().nullable(),
+    dataProfileStatus: z.enum(["pending", "running", "completed", "failed"]),
+    dataProfileError: z.string().nullable(),
+    dataProfileStartedAt: z.string().nullable(),
+    dataProfileCompletedAt: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const ArtifactRole = z.enum(["input", "step_output"]);
+export const ArtifactRowSchema = z.object({
+    resourceId: z.string(),
+    path: z.string(),
+    artifactId: z.string().nullable(),
+    fileId: z.string().nullable(),
+    hash: z.string(),
+    size: z.number(),
+    role: ArtifactRole,
+    sourceStep: z.string().nullable(),
+    sourceRun: z.string().nullable(),
+    createdAt: z.string(),
+    unrecoverableAt: z.string().nullable(),
+    fileType: z.string().nullable(),
+});
+// ── Run & Step Execution Schemas ─────────────────────────────────────
+export const RunStatus = z.enum(["running", "completed", "partial", "failed", "canceled", "suspended_insufficient_funds"]);
+export const StepExecutionStatus = z.enum(["pending", "running", "completed", "failed", "skipped", "canceled", "blocked"]);
+export const CortexRunRowSchema = z.object({
+    runId: z.string(),
+    analysisId: z.string(),
+    threadId: z.string().nullable(),
+    workflowName: z.string(),
+    status: RunStatus,
+    startedAt: z.string(),
+    completedAt: z.string().nullable(),
+    error: z.string().nullable(),
+    parts: z.array(z.any()).nullable(),
+    mandateJti: z.string().nullable(), // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+    mandateExpiresAt: z.string().nullable(), // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+    planId: z.string().nullable(),
+});
+/**
+ * Persistable sandbox handle — what the active-sandbox registry stores on
+ * `cortex_step_executions.sandbox_ref`. Excludes the per-sandbox
+ * `callbackSecret`, which lives only in the DBOS step-output cache (ADR
+ * 0007). The harness reconstructs the full in-memory `SandboxRef` by
+ * reading the secret from the cached `createSandbox` step output.
+ */
+export const PersistedSandboxRefSchema = z.object({
+    sandboxId: z.string(),
+    host: z.string(),
+    port: z.number(),
+    backend: z.enum(["docker", "k8s"]),
+});
+export const StepExecutionRowSchema = z.object({
+    runId: z.string(),
+    stepId: z.string(),
+    analysisId: z.string(),
+    wave: z.number(),
+    agentId: z.string(),
+    status: StepExecutionStatus,
+    startedAt: z.string().nullable(),
+    completedAt: z.string().nullable(),
+    durationMs: z.number().nullable(),
+    error: z.string().nullable(),
+    /** 1-based count of attempts taken to execute this step (increments on retry). */
+    attempts: z.number().default(1),
+    /** Classified error class of the previous failed attempt (null on first attempt / success). */
+    lastErrorClass: z.string().nullable(),
+    /** Agent-stream finish reason of the final step ("stop", "tool-calls", "length", ...). */
+    finishReason: z.string().nullable(),
+    /** True when the agent exhausted its `maxSteps` turn budget. */
+    hitMaxSteps: z.boolean().default(false),
+    /** Agent-declared blocker reason (see the harness-sandbox-agents spec); null unless `status === "blocked"`. */
+    blockedReason: z.string().nullable().default(null),
+    /** Active-sandbox registry handle; null when no sandbox is live for this step. */
+    sandboxRef: PersistedSandboxRefSchema.nullable().default(null),
+    /** In-flight `${workflowId}:${stepId}:${functionId}`; null when no exec is in flight. */
+    execId: z.string().nullable().default(null),
+    /** DBOS child workflow id (`"${parentWorkflowId}-${N}"`); null on pre-DBOS rows. */
+    childWorkflowId: z.string().nullable().default(null),
+});
+// ── Plans ────────────────────────────────────────────────────────────
+export const CortexPlanRowSchema = z.object({
+    planId: z.string(),
+    analysisId: z.string(),
+    plan: z.record(z.string(), z.unknown()),
+    parentPlanId: z.string().nullable(),
+    createdAt: z.string(),
+});

package/dist/state/step-executions.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `cortex_step_executions` operations — step lifecycle and retry telemetry.
+ * The `sandbox_ref` column is read/written by the sibling `active-sandboxes`
+ * module.
+ */
+import type { ResultAsync } from "neverthrow";
+import { type DbError } from "../lib/db-result.js";
+import type { Querier } from "./db.js";
+import type { StepExecutionRow } from "./schema.js";
+export interface SeedStepExecutionRow {
+    runId: string;
+    stepId: string;
+    analysisId: string;
+    wave: number;
+    agentId: string;
+}
+/**
+ * Seed one `pending` row per plan step at run start (`started_at` NULL — no
+ * attempt has happened yet; `attempts`/`hit_max_steps` lean on their column
+ * defaults). `ON CONFLICT DO NOTHING`, NOT the mark-running upsert: on DBOS
+ * recovery the parent body replays this seed against rows a prior execution
+ * already advanced, and an upsert would reset them — DO NOTHING makes the seed
+ * idempotent and monotone (it can only ever add missing rows). From the first
+ * seed, `queryStepsByRun` returns the run's full DAG, so consumers can render
+ * honest done/total progress including not-yet-started steps.
+ */
+export declare function seedStepExecutions(pool: Querier, rows: readonly SeedStepExecutionRow[]): ResultAsync<void, DbError>;
+export interface InsertStepExecutionInput {
+    runId: string;
+    stepId: string;
+    analysisId: string;
+    wave: number;
+    agentId: string;
+    /** DBOS child workflow id (`"${parent}-${N}"`). Optional for legacy callers. */
+    childWorkflowId?: string | null;
+}
+export declare function insertStepExecution(pool: Querier, input: InsertStepExecutionInput): ResultAsync<void, DbError>;
+/**
+ * Look up a step execution by its DBOS child workflow id. The parent
+ * scheduler uses this to find the step row corresponding to a CANCELLED
+ * child without holding the runId/stepId map in memory across recovery.
+ */
+export interface UpdateStepExecutionInput {
+    /** Step status — `running` is allowed for mid-flight telemetry updates (retries). */
+    status: "running" | "completed" | "failed" | "skipped" | "canceled" | "blocked";
+    durationMs?: number | null;
+    error?: string | null;
+    /** Retry count (1-based). Writes to `attempts` column when provided. */
+    attempts?: number | null;
+    /** Classified error class for the previous attempt (null clears). */
+    lastErrorClass?: string | null;
+    /** Agent-declared blocker reason (see the harness-sandbox-agents spec); set when `status === "blocked"`. */
+    blockedReason?: string | null;
+    /** Agent-stream final-step finish reason ("stop", "tool-calls", ...). */
+    finishReason?: string | null;
+    /** True when `stepsUsed === maxSteps`. Stored as 0/1 in SQLite. */
+    hitMaxSteps?: boolean | null;
+}
+/**
+ * Update a step execution row. Columns are written conditionally so callers
+ * can bump `attempts` / `lastErrorClass` on retry without clobbering timing
+ * telemetry, or set `finishReason` / `hitMaxSteps` on success.
+ *
+ * `completed_at` is only stamped for terminal statuses (completed/failed/
+ * skipped) — running updates leave it NULL for the next transition.
+ */
+export declare function updateStepExecution(pool: Querier, runId: string, stepId: string, update: UpdateStepExecutionInput): ResultAsync<void, DbError>;
+/**
+ * Sweep a run's still-`pending` rows to `skipped` ("never ran, never will") at
+ * finalisation, stamping `completed_at`. Only genuinely-terminal paths may call
+ * this — the resumable budget-pause branch must NOT, because the resumed
+ * workflow still executes those steps (see the workflow-failure-lifecycle
+ * spec). `skipped`, not `canceled`: canceled means torn down mid-flight, and
+ * these steps never started.
+ */
+export declare function sweepPendingStepExecutions(pool: Querier, runId: string): ResultAsync<void, DbError>;
+export declare function queryStepsByRun(pool: Querier, runId: string): ResultAsync<StepExecutionRow[], DbError>;