@cascade-flow/backend-postgres 0.2.7 → 0.2.9

package/dist/index.js

@@ -4744,6 +4744,7 @@ import {
   projectRunStateFromEvents,
   extractLogsFromEvents,
   getCurrentAttemptNumber,
+  getVersionIdFromEvents,
   getMicrosecondTimestamp,
   computeErrorAnalysis,
   computeRetryAnalysis,
@@ -4773,6 +4774,10 @@ var esm_default = import_lib.default;
 
 // src/db.ts
 var { Pool: Pool2 } = esm_default;
+function stripEventIdFromJson(event) {
+  const { eventId, ...eventWithoutId } = event;
+  return eventWithoutId;
+}
 
 class DatabaseClient {
   pool;
@@ -4807,7 +4812,7 @@ class DatabaseClient {
         } else if ("workflowAttemptNumber" in we) {
           workflowAttemptNumber = we.workflowAttemptNumber;
         }
-        if (we.type === "WorkflowStarted") {
+        if (we.type === "WorkflowStarted" || we.type === "WorkflowResumed") {
           versionId = we.versionId;
         }
         if (versionId === null) {
@@ -4830,7 +4835,7 @@ class DatabaseClient {
           we.timestampUs,
           we.category,
           we.type,
-          JSON.stringify(event),
+          JSON.stringify(stripEventIdFromJson(event)),
           workflowAttemptNumber,
           availableAtUs,
           priority,
@@ -4889,7 +4894,7 @@ class DatabaseClient {
           se.timestampUs,
           se.category,
           se.type,
-          JSON.stringify(event),
+          JSON.stringify(stripEventIdFromJson(event)),
           workerId,
           attemptNumber,
           availableAtUs,
@@ -4947,7 +4952,7 @@ class DatabaseClient {
         we.timestampUs,
         we.category,
         we.type,
-        JSON.stringify(event),
+        JSON.stringify(stripEventIdFromJson(event)),
         workflowAttemptNumber,
         availableAtUs,
         priority,
@@ -5006,7 +5011,7 @@ class DatabaseClient {
         se.timestampUs,
         se.category,
         se.type,
-        JSON.stringify(event),
+        JSON.stringify(stripEventIdFromJson(event)),
         workerId,
         attemptNumber,
         availableAtUs,
@@ -5048,12 +5053,12 @@ class DatabaseClient {
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       const query = `
-      SELECT event_data FROM ${this.schema}.${table}
+      SELECT event_data, event_id FROM ${this.schema}.${table}
       ${whereClause}
       ORDER BY timestamp_us ASC, event_id ASC
     `;
       const result = await client.query(query, values);
-      return result.rows.map((row) => row.event_data);
+      return result.rows.map((row) => ({ ...row.event_data, eventId: row.event_id }));
     } finally {
       client.release();
     }
@@ -5070,7 +5075,32 @@ class DatabaseClient {
       ORDER BY timestamp_us ASC, event_id ASC
     `;
       const result = await client.query(query, [workflowSlug, runId]);
-      return result.rows.map((row) => row.event_data);
+      return result.rows.map((row) => ({ ...row.event_data, eventId: row.event_id }));
+    } finally {
+      client.release();
+    }
+  }
+  async loadStepEventsForProjection(workflowSlug, runId) {
+    const client = await this.pool.connect();
+    try {
+      const query = `
+        SELECT event_data, event_id, step_id
+        FROM ${this.schema}.step_events
+        WHERE workflow_slug = $1 AND run_id = $2
+          AND type NOT IN ('LogEntry', 'StepHeartbeat', 'StepRetrying')
+        ORDER BY timestamp_us ASC, event_id ASC
+      `;
+      const result = await client.query(query, [workflowSlug, runId]);
+      const eventsByStep = new Map;
+      for (const row of result.rows) {
+        const stepId = row.step_id;
+        const event = { ...row.event_data, eventId: row.event_id };
+        if (!eventsByStep.has(stepId)) {
+          eventsByStep.set(stepId, []);
+        }
+        eventsByStep.get(stepId).push(event);
+      }
+      return eventsByStep;
     } finally {
       client.release();
     }
@@ -5135,7 +5165,7 @@ class DatabaseClient {
         eventToWrite.timestampUs,
         eventToWrite.category,
         eventToWrite.type,
-        JSON.stringify(eventToWrite),
+        JSON.stringify(stripEventIdFromJson(eventToWrite)),
         workerId2,
         attemptNumber,
         null,
@@ -5341,6 +5371,59 @@ class DatabaseClient {
       client.release();
     }
   }
+  async getWorkflowVersion(workflowSlug, versionId) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH numbered_versions AS (
+          SELECT *,
+            ROW_NUMBER() OVER (PARTITION BY workflow_slug ORDER BY created_at ASC) as version_number
+          FROM ${this.schema}.workflow_versions
+          WHERE workflow_slug = $1
+        )
+        SELECT * FROM numbered_versions WHERE version_id = $2`, [workflowSlug, versionId]);
+      if (result.rows.length === 0)
+        return null;
+      return result.rows[0];
+    } finally {
+      client.release();
+    }
+  }
+  async getCurrentWorkflowVersion(workflowSlug) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH numbered_versions AS (
+          SELECT *,
+            ROW_NUMBER() OVER (PARTITION BY workflow_slug ORDER BY created_at ASC) as version_number
+          FROM ${this.schema}.workflow_versions
+          WHERE workflow_slug = $1
+        )
+        SELECT * FROM numbered_versions
+        ORDER BY created_at DESC
+        LIMIT 1`, [workflowSlug]);
+      if (result.rows.length === 0)
+        return null;
+      return result.rows[0];
+    } finally {
+      client.release();
+    }
+  }
+  async listWorkflowVersions(workflowSlug, limit) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH numbered_versions AS (
+          SELECT *,
+            ROW_NUMBER() OVER (PARTITION BY workflow_slug ORDER BY created_at ASC) as version_number
+          FROM ${this.schema}.workflow_versions
+          WHERE workflow_slug = $1
+        )
+        SELECT * FROM numbered_versions
+        ORDER BY created_at DESC
+        LIMIT $2`, [workflowSlug, limit]);
+      return result.rows;
+    } finally {
+      client.release();
+    }
+  }
   async saveIdempotencyKey(hash, runId) {
     const client = await this.pool.connect();
     try {
@@ -5393,6 +5476,253 @@ class DatabaseClient {
       client.release();
     }
   }
+  async getQueueDepthAggregation(workflowSlug) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH
+        -- Get the latest workflow event per run to determine run status
+        run_status AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            type,
+            timestamp_us AS created_at
+          FROM ${this.schema}.workflow_events
+          WHERE ($1::text IS NULL OR workflow_slug = $1)
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
+        ),
+        -- Filter to only active (pending/running) runs
+        active_runs AS (
+          SELECT
+            workflow_slug,
+            run_id,
+            CASE WHEN type IN ('RunSubmitted', 'WorkflowRetryStarted') THEN 'pending' ELSE 'running' END AS status,
+            created_at
+          FROM run_status
+          WHERE type IN ('RunSubmitted', 'WorkflowRetryStarted', 'WorkflowStarted', 'WorkflowResumed')
+        ),
+        -- Get latest step event per step (excluding LogEntry which doesn't change state)
+        latest_step_events AS (
+          SELECT DISTINCT ON (se.workflow_slug, se.run_id, se.step_id)
+            se.type,
+            se.available_at_us
+          FROM ${this.schema}.step_events se
+          INNER JOIN active_runs ar
+            ON ar.workflow_slug = se.workflow_slug
+            AND ar.run_id = se.run_id
+            AND ar.status = 'running'
+          WHERE se.type != 'LogEntry'
+          ORDER BY se.workflow_slug, se.run_id, se.step_id, se.timestamp_us DESC, se.event_id DESC
+        ),
+        -- Aggregate step counts
+        step_counts AS (
+          SELECT
+            COUNT(*) FILTER (WHERE type IN ('StepScheduled', 'StepReclaimed')) AS scheduled_steps,
+            COUNT(*) FILTER (WHERE type IN ('StepStarted', 'StepHeartbeat')) AS running_steps,
+            MIN(available_at_us) FILTER (WHERE type IN ('StepScheduled', 'StepReclaimed')) AS oldest_scheduled_step_us
+          FROM latest_step_events
+        ),
+        -- Aggregate run counts
+        run_counts AS (
+          SELECT
+            COUNT(*) FILTER (WHERE status = 'pending') AS pending_runs,
+            COUNT(*) FILTER (WHERE status = 'running') AS running_runs,
+            MIN(created_at) FILTER (WHERE status = 'pending') AS oldest_pending_run_us
+          FROM active_runs
+        )
+        SELECT
+          COALESCE(rc.pending_runs, 0) AS pending_runs,
+          COALESCE(rc.running_runs, 0) AS running_runs,
+          COALESCE(sc.scheduled_steps, 0) AS scheduled_steps,
+          COALESCE(sc.running_steps, 0) AS running_steps,
+          sc.oldest_scheduled_step_us,
+          rc.oldest_pending_run_us
+        FROM run_counts rc, step_counts sc`, [workflowSlug ?? null]);
+      const row = result.rows[0];
+      return {
+        pendingRuns: parseInt(row?.pending_runs ?? "0", 10),
+        runningRuns: parseInt(row?.running_runs ?? "0", 10),
+        scheduledSteps: parseInt(row?.scheduled_steps ?? "0", 10),
+        runningSteps: parseInt(row?.running_steps ?? "0", 10),
+        oldestScheduledStepUs: row?.oldest_scheduled_step_us ? parseInt(row.oldest_scheduled_step_us, 10) : null,
+        oldestPendingRunUs: row?.oldest_pending_run_us ? parseInt(row.oldest_pending_run_us, 10) : null
+      };
+    } finally {
+      client.release();
+    }
+  }
+  async listRunsFiltered(options) {
+    const client = await this.pool.connect();
+    try {
+      const statusToEvents = {
+        pending: ["RunSubmitted", "WorkflowRetryStarted"],
+        running: ["WorkflowStarted", "WorkflowResumed"],
+        completed: ["WorkflowCompleted"],
+        failed: ["WorkflowFailed"],
+        cancelled: ["WorkflowCancelled"]
+      };
+      let eventTypeFilter = null;
+      if (options?.status && options.status.length > 0) {
+        eventTypeFilter = options.status.flatMap((s) => statusToEvents[s] || []);
+      }
+      const result = await client.query(`WITH
+        -- Get first event (RunSubmitted) for each run to get createdAt and tags
+        run_submitted AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            timestamp_us AS created_at,
+            event_data->'tags' AS tags
+          FROM ${this.schema}.workflow_events
+          WHERE type = 'RunSubmitted'
+            AND ($1::text IS NULL OR workflow_slug = $1)
+          ORDER BY workflow_slug, run_id, timestamp_us ASC
+        ),
+        -- Get latest status-determining event for each run
+        latest_status AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            CASE
+              WHEN type IN ('RunSubmitted', 'WorkflowRetryStarted') THEN 'pending'
+              WHEN type IN ('WorkflowStarted', 'WorkflowResumed') THEN 'running'
+              WHEN type = 'WorkflowCompleted' THEN 'completed'
+              WHEN type = 'WorkflowFailed' THEN 'failed'
+              WHEN type = 'WorkflowCancelled' THEN 'cancelled'
+            END AS status,
+            type
+          FROM ${this.schema}.workflow_events
+          WHERE ($1::text IS NULL OR workflow_slug = $1)
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
+        )
+        SELECT
+          ls.workflow_slug,
+          ls.run_id,
+          ls.status,
+          rs.created_at,
+          rs.tags
+        FROM latest_status ls
+        JOIN run_submitted rs ON ls.workflow_slug = rs.workflow_slug AND ls.run_id = rs.run_id
+        WHERE ($2::text[] IS NULL OR ls.type = ANY($2))
+        ORDER BY rs.created_at DESC
+        LIMIT $3`, [
+        options?.workflowSlug ?? null,
+        eventTypeFilter,
+        options?.limit ?? null
+      ]);
+      return result.rows.map((row) => ({
+        workflowSlug: row.workflow_slug,
+        runId: row.run_id,
+        status: row.status,
+        createdAt: parseInt(row.created_at, 10),
+        tags: row.tags
+      }));
+    } finally {
+      client.release();
+    }
+  }
+  async loadWorkflowEventsForRuns(runs) {
+    if (runs.length === 0) {
+      return new Map;
+    }
+    const client = await this.pool.connect();
+    try {
+      const values = [];
+      const valuePlaceholders = [];
+      runs.forEach((run, i) => {
+        values.push(run.workflowSlug, run.runId);
+        valuePlaceholders.push(`($${i * 2 + 1}, $${i * 2 + 2})`);
+      });
+      const result = await client.query(`SELECT workflow_slug, run_id, event_data, event_id
+         FROM ${this.schema}.workflow_events
+         WHERE (workflow_slug, run_id) IN (VALUES ${valuePlaceholders.join(", ")})
+         ORDER BY workflow_slug, run_id, timestamp_us ASC, event_id ASC`, values);
+      const eventsByRun = new Map;
+      for (const row of result.rows) {
+        const key = `${row.workflow_slug}:${row.run_id}`;
+        const events = eventsByRun.get(key) || [];
+        events.push({ ...row.event_data, eventId: row.event_id });
+        eventsByRun.set(key, events);
+      }
+      return eventsByRun;
+    } finally {
+      client.release();
+    }
+  }
+  async getQueueDepthByWorkflowAggregation() {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH
+        -- Get the latest workflow event per run to determine run status
+        run_status AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            type,
+            timestamp_us AS created_at
+          FROM ${this.schema}.workflow_events
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
+        ),
+        -- Filter to only active (pending/running) runs
+        active_runs AS (
+          SELECT
+            workflow_slug,
+            run_id,
+            CASE WHEN type IN ('RunSubmitted', 'WorkflowRetryStarted') THEN 'pending' ELSE 'running' END AS status,
+            created_at
+          FROM run_status
+          WHERE type IN ('RunSubmitted', 'WorkflowRetryStarted', 'WorkflowStarted', 'WorkflowResumed')
+        ),
+        -- Get latest step event per step (excluding LogEntry)
+        latest_step_events AS (
+          SELECT DISTINCT ON (se.workflow_slug, se.run_id, se.step_id)
+            se.workflow_slug,
+            se.type,
+            se.available_at_us
+          FROM ${this.schema}.step_events se
+          INNER JOIN active_runs ar
+            ON ar.workflow_slug = se.workflow_slug
+            AND ar.run_id = se.run_id
+            AND ar.status = 'running'
+          WHERE se.type != 'LogEntry'
+          ORDER BY se.workflow_slug, se.run_id, se.step_id, se.timestamp_us DESC, se.event_id DESC
+        ),
+        -- Aggregate step counts by workflow
+        step_counts_by_workflow AS (
+          SELECT
+            workflow_slug,
+            COUNT(*) FILTER (WHERE type IN ('StepScheduled', 'StepReclaimed')) AS scheduled_steps,
+            MIN(available_at_us) FILTER (WHERE type IN ('StepScheduled', 'StepReclaimed')) AS oldest_scheduled_us
+          FROM latest_step_events
+          GROUP BY workflow_slug
+        ),
+        -- Aggregate run counts by workflow
+        run_counts_by_workflow AS (
+          SELECT
+            workflow_slug,
+            COUNT(*) FILTER (WHERE status = 'pending') AS pending_runs,
+            MIN(created_at) FILTER (WHERE status = 'pending') AS oldest_pending_run_us
+          FROM active_runs
+          GROUP BY workflow_slug
+        )
+        SELECT
+          COALESCE(r.workflow_slug, s.workflow_slug) AS workflow_slug,
+          COALESCE(r.pending_runs, 0) AS pending_runs,
+          COALESCE(s.scheduled_steps, 0) AS scheduled_steps,
+          LEAST(r.oldest_pending_run_us, s.oldest_scheduled_us) AS oldest_pending_item_us
+        FROM run_counts_by_workflow r
+        FULL OUTER JOIN step_counts_by_workflow s ON r.workflow_slug = s.workflow_slug
+        WHERE COALESCE(r.pending_runs, 0) > 0 OR COALESCE(s.scheduled_steps, 0) > 0`);
+      return result.rows.map((row) => ({
+        workflowSlug: row.workflow_slug,
+        pendingRuns: parseInt(row.pending_runs, 10),
+        scheduledSteps: parseInt(row.scheduled_steps, 10),
+        oldestPendingItemUs: row.oldest_pending_item_us ? parseInt(row.oldest_pending_item_us, 10) : null
+      }));
+    } finally {
+      client.release();
+    }
+  }
 }
 function createPool(connectionString) {
   return new Pool2({ connectionString });
@@ -5671,6 +6001,60 @@ async function migration005_addWorkflowVersioning(pool, schema) {
     client.release();
   }
 }
+async function migration006_addDescIndexes(pool, schema) {
+  const client = await pool.connect();
+  try {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_latest
+      ON ${schema}.workflow_events (workflow_slug, run_id, timestamp_us DESC, event_id DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_latest
+      ON ${schema}.step_events (workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_by_type
+      ON ${schema}.workflow_events (type, workflow_slug, run_id, timestamp_us ASC)
+    `);
+    console.log("[Migration 006] Optimized query indexes added successfully");
+  } catch (error) {
+    console.error("[Migration 006] Error adding DESC indexes:", error);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function migration007_addWorkerIndexes(pool, schema) {
+  const client = await pool.connect();
+  try {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_scheduled_status
+      ON ${schema}.step_events (type, workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC)
+      WHERE type IN ('StepScheduled', 'StepReclaimed', 'StepRetrying')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_heartbeat_status
+      ON ${schema}.step_events (type, workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC)
+      WHERE type IN ('StepStarted', 'StepHeartbeat')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_active_types
+      ON ${schema}.workflow_events (type)
+      WHERE type IN ('RunSubmitted', 'WorkflowStarted', 'WorkflowResumed')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_active_types
+      ON ${schema}.step_events (type)
+      WHERE type IN ('StepScheduled', 'StepStarted', 'StepReclaimed', 'StepRetrying')
+    `);
+    console.log("[Migration 007] Worker loop indexes added successfully");
+  } catch (error) {
+    console.error("[Migration 007] Error adding worker indexes:", error);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
 async function runMigrations(pool, schema = "cascadeflow") {
   console.log(`[Migrations] Starting database migrations in schema '${schema}'...`);
   try {
@@ -5680,6 +6064,8 @@ async function runMigrations(pool, schema = "cascadeflow") {
     await migration003_createIndexes(pool, schema);
     await migration004_addErrorFingerprints(pool, schema);
     await migration005_addWorkflowVersioning(pool, schema);
+    await migration006_addDescIndexes(pool, schema);
+    await migration007_addWorkerIndexes(pool, schema);
     console.log("[Migrations] All migrations completed successfully");
   } catch (error) {
     console.error("[Migrations] Migration failed:", error);
@@ -5703,6 +6089,20 @@ class PostgresBackend extends Backend {
     await runMigrations(this.db.getPool(), this.db.getSchema());
     this.initialized = true;
   }
+  async backendReady() {
+    try {
+      const client = await this.db.getPool().connect();
+      try {
+        await client.query("SELECT 1");
+        return true;
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      console.error("Backend health check failed:", error);
+      return false;
+    }
+  }
   generateRunId() {
     return `run_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
   }
@@ -5766,6 +6166,203 @@ class PostgresBackend extends Backend {
       return this.db.loadAllRunEvents(workflowSlug, runId);
     }
   }
+  async loadStepEventsForProjection(workflowSlug, runId) {
+    return this.db.loadStepEventsForProjection(workflowSlug, runId);
+  }
+  async copyEntireRun(workflowSlug, sourceRunId, targetRunId) {
+    await this.copyEntireRunWithClient(workflowSlug, sourceRunId, targetRunId, this.db.getPool());
+  }
+  async copyEntireRunWithClient(workflowSlug, sourceRunId, targetRunId, client) {
+    const schema = this.db.getSchema();
+    await client.query(`INSERT INTO ${schema}.workflow_events (
+         event_id, workflow_slug, run_id, timestamp_us, category, type, event_data, created_at,
+         workflow_attempt_number, available_at_us, priority, timeout_us, idempotency_key, version_id
+       )
+       SELECT
+         gen_random_uuid()::text,
+         workflow_slug,
+         $2,
+         timestamp_us,
+         category,
+         type,
+         jsonb_set(event_data, '{runId}', to_jsonb($2::text)),
+         created_at,
+         workflow_attempt_number,
+         available_at_us,
+         priority,
+         timeout_us,
+         idempotency_key,
+         version_id
+       FROM ${schema}.workflow_events
+       WHERE workflow_slug = $1 AND run_id = $3`, [workflowSlug, targetRunId, sourceRunId]);
+    await client.query(`INSERT INTO ${schema}.step_events (
+         event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data, created_at,
+         worker_id, attempt_number, available_at_us, export_output,
+         error_name_hash, error_message_hash, error_stack_exact_hash, error_stack_normalized_hash, error_stack_portable_hash,
+         version_id
+       )
+       SELECT
+         gen_random_uuid()::text,
+         workflow_slug,
+         $2,
+         step_id,
+         timestamp_us,
+         category,
+         type,
+         jsonb_set(event_data, '{runId}', to_jsonb($2::text)),
+         created_at,
+         worker_id,
+         attempt_number,
+         available_at_us,
+         export_output,
+         error_name_hash,
+         error_message_hash,
+         error_stack_exact_hash,
+         error_stack_normalized_hash,
+         error_stack_portable_hash,
+         version_id
+       FROM ${schema}.step_events
+       WHERE workflow_slug = $1 AND run_id = $3`, [workflowSlug, targetRunId, sourceRunId]);
+  }
+  async deleteStepEvents(workflowSlug, runId, stepIds) {
+    await this.deleteStepEventsWithClient(workflowSlug, runId, stepIds, this.db.getPool());
+  }
+  async deleteStepEventsWithClient(workflowSlug, runId, stepIds, client) {
+    if (stepIds.size === 0)
+      return;
+    const schema = this.db.getSchema();
+    const stepIdsArray = Array.from(stepIds);
+    await client.query(`DELETE FROM ${schema}.step_events
+       WHERE workflow_slug = $1 AND run_id = $2 AND step_id = ANY($3)`, [workflowSlug, runId, stepIdsArray]);
+  }
+  async deleteWorkflowTerminalEvents(workflowSlug, runId) {
+    await this.deleteWorkflowTerminalEventsWithClient(workflowSlug, runId, this.db.getPool());
+  }
+  async deleteWorkflowTerminalEventsWithClient(workflowSlug, runId, client) {
+    const schema = this.db.getSchema();
+    await client.query(`DELETE FROM ${schema}.workflow_events
+       WHERE workflow_slug = $1
+         AND run_id = $2
+         AND type IN ('WorkflowCompleted', 'WorkflowFailed', 'WorkflowCancelled')`, [workflowSlug, runId]);
+  }
+  async copyWorkflowEvents(workflowSlug, sourceRunId, targetRunId, excludeTerminal) {
+    const pool = this.db.getPool();
+    const schema = this.db.getSchema();
+    const terminalFilter = excludeTerminal ? `AND type NOT IN ('WorkflowCompleted', 'WorkflowFailed', 'WorkflowCancelled')` : "";
+    await pool.query(`INSERT INTO ${schema}.workflow_events (
+         event_id, workflow_slug, run_id, timestamp_us, category, type, event_data, created_at,
+         workflow_attempt_number, available_at_us, priority, timeout_us, idempotency_key, version_id
+       )
+       SELECT
+         gen_random_uuid()::text,
+         workflow_slug,
+         $3,
+         timestamp_us,
+         category,
+         type,
+         jsonb_set(event_data, '{runId}', to_jsonb($3::text)),
+         created_at,
+         workflow_attempt_number,
+         available_at_us,
+         priority,
+         timeout_us,
+         idempotency_key,
+         version_id
+       FROM ${schema}.workflow_events
+       WHERE workflow_slug = $1
+         AND run_id = $2
+         ${terminalFilter}`, [workflowSlug, sourceRunId, targetRunId]);
+  }
+  async copyStepEvents(workflowSlug, sourceRunId, targetRunId, includeStepIds) {
+    const pool = this.db.getPool();
+    const schema = this.db.getSchema();
+    const stepIdsArray = Array.from(includeStepIds);
+    if (stepIdsArray.length === 0)
+      return;
+    await pool.query(`INSERT INTO ${schema}.step_events (
+         event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data, created_at,
+         worker_id, attempt_number, available_at_us, export_output,
+         error_name_hash, error_message_hash, error_stack_exact_hash, error_stack_normalized_hash, error_stack_portable_hash,
+         version_id
+       )
+       SELECT
+         gen_random_uuid()::text,
+         workflow_slug,
+         $3,
+         step_id,
+         timestamp_us,
+         category,
+         type,
+         jsonb_set(event_data, '{runId}', to_jsonb($3::text)),
+         created_at,
+         worker_id,
+         attempt_number,
+         available_at_us,
+         export_output,
+         error_name_hash,
+         error_message_hash,
+         error_stack_exact_hash,
+         error_stack_normalized_hash,
+         error_stack_portable_hash,
+         version_id
+       FROM ${schema}.step_events
+       WHERE workflow_slug = $1
+         AND run_id = $2
+         AND step_id = ANY($4)`, [workflowSlug, sourceRunId, targetRunId, stepIdsArray]);
+  }
+  async rerunFrom(params) {
+    const parentRun = await this.getRun(params.parentRunId);
+    if (!parentRun) {
+      throw new Error(`Parent run "${params.parentRunId}" not found`);
+    }
+    const dependents = await this.calculateDependents(parentRun.workflowSlug, params.fromStepId);
+    const rerunStepIds = new Set([params.fromStepId, ...dependents]);
+    const newRunId = getMicrosecondTimestamp().toString();
+    const pool = this.db.getPool();
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+      await this.copyEntireRunWithClient(parentRun.workflowSlug, params.parentRunId, newRunId, client);
+      await this.deleteStepEventsWithClient(parentRun.workflowSlug, newRunId, rerunStepIds, client);
+      await this.deleteWorkflowTerminalEventsWithClient(parentRun.workflowSlug, newRunId, client);
+      await client.query("COMMIT");
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+    const currentVersion = await this.getCurrentWorkflowVersion(parentRun.workflowSlug);
+    if (!currentVersion) {
+      throw new Error(`Workflow ${parentRun.workflowSlug} not registered. Please ensure the worker has started and registered workflows.`);
+    }
+    const parentWorkflowEvents = await this.loadEvents(parentRun.workflowSlug, params.parentRunId, {
+      category: "workflow"
+    });
+    const parentVersionId = getVersionIdFromEvents(parentWorkflowEvents);
+    const timestamp = getMicrosecondTimestamp();
+    await this.appendEvent(parentRun.workflowSlug, newRunId, {
+      category: "workflow",
+      type: "WorkflowRerunFromStep",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug: parentRun.workflowSlug,
+      runId: newRunId,
+      parentRunId: params.parentRunId,
+      rerunFromStepId: params.fromStepId,
+      rerunStepIds: Array.from(rerunStepIds),
+      versionId: currentVersion.versionId,
+      parentVersionId
+    });
+    await this.submitRun({
+      workflowSlug: parentRun.workflowSlug,
+      runId: newRunId,
+      input: params.input
+    });
+    return {
+      runId: newRunId
+    };
+  }
   async saveStepScheduled(workflowSlug, runId, stepId, metadata) {
     const now = getMicrosecondTimestamp();
     const event = {
@@ -5802,8 +6399,7 @@ class PostgresBackend extends Backend {
     await this.db.appendEvent("step_events", event);
   }
   async saveStepComplete(workflowSlug, runId, stepId, output, metadata, exportOutput = false) {
-    const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
-    const attemptNumber = getCurrentAttemptNumber(events);
+    const attemptNumber = metadata.attemptNumber;
     if (attemptNumber === 0) {
       throw new Error(`Cannot complete step that hasn't started: ${stepId}`);
     }
@@ -5942,6 +6538,40 @@ class PostgresBackend extends Backend {
     };
     await this.db.appendEvent("step_events", event);
   }
+  async saveStepCheckpoint(workflowSlug, runId, stepId, checkpoint) {
+    const now = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      type: "StepCheckpoint",
+      eventId: this.generateEventId(now),
+      timestampUs: now,
+      workflowSlug,
+      runId,
+      stepId,
+      name: checkpoint.name,
+      sequenceNumber: checkpoint.sequenceNumber,
+      attemptNumber: checkpoint.attemptNumber,
+      data: checkpoint.data
+    };
+    await this.db.appendEvent("step_events", event);
+  }
+  async saveStepCheckpointFailed(workflowSlug, runId, stepId, checkpoint) {
+    const now = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      type: "StepCheckpointFailed",
+      eventId: this.generateEventId(now),
+      timestampUs: now,
+      workflowSlug,
+      runId,
+      stepId,
+      name: checkpoint.name,
+      sequenceNumber: checkpoint.sequenceNumber,
+      attemptNumber: checkpoint.attemptNumber,
+      error: checkpoint.error
+    };
+    await this.db.appendEvent("step_events", event);
+  }
   async saveStepHeartbeat(workflowSlug, runId, stepId, workerId, attemptNumber) {
     const now = getMicrosecondTimestamp();
     const event = {
@@ -6057,6 +6687,7 @@ class PostgresBackend extends Backend {
       timestampUs: timestamp,
       workflowSlug,
       runId,
+      versionId: metadata.versionId,
       originalRunId: metadata.originalRunId,
       resumedSteps: metadata.resumedSteps,
       pendingSteps: metadata.pendingSteps
@@ -6150,35 +6781,39 @@ class PostgresBackend extends Backend {
     return { runId, isNew: true };
   }
   async listRuns(options) {
+    const filteredRuns = await this.db.listRunsFiltered({
+      workflowSlug: options?.workflowSlug,
+      status: options?.status,
+      limit: options?.tags?.length ? undefined : options?.limit
+    });
+    let runsToLoad = filteredRuns;
+    if (options?.tags && options.tags.length > 0) {
+      runsToLoad = filteredRuns.filter((run) => {
+        const runTags = run.tags || [];
+        return options.tags.every((tag) => runTags.includes(tag));
+      });
+      if (options?.limit) {
+        runsToLoad = runsToLoad.slice(0, options.limit);
+      }
+    }
+    if (runsToLoad.length === 0) {
+      return [];
+    }
+    const eventsByRun = await this.db.loadWorkflowEventsForRuns(runsToLoad.map((r) => ({ workflowSlug: r.workflowSlug, runId: r.runId })));
     const allRuns = [];
-    const workflows = options?.workflowSlug ? [options.workflowSlug] : await this.db.listActiveWorkflows();
-    for (const workflowSlug of workflows) {
-      const runIds = await this.db.listRunIds(workflowSlug);
-      for (const runId of runIds) {
-        try {
-          const events = await this.db.loadAllRunEvents(workflowSlug, runId);
-          if (events.length === 0)
-            continue;
-          const workflowEvents = events.filter((e) => e.category === "workflow");
-          const state = projectRunStateFromEvents(workflowEvents, workflowSlug);
-          if (options?.status && options.status.length > 0) {
-            if (!options.status.includes(state.status))
-              continue;
-          }
-          if (options?.tags && options.tags.length > 0) {
-            const stateTags = state.tags || [];
-            const hasAllTags = options.tags.every((tag) => stateTags.includes(tag));
-            if (!hasAllTags)
-              continue;
-          }
-          allRuns.push(state);
-        } catch {
-          continue;
-        }
+    for (const run of runsToLoad) {
+      const key = `${run.workflowSlug}:${run.runId}`;
+      const events = eventsByRun.get(key);
+      if (!events || events.length === 0)
+        continue;
+      try {
+        const state = projectRunStateFromEvents(events, run.workflowSlug);
+        allRuns.push(state);
+      } catch {
+        continue;
       }
     }
-    allRuns.sort((a, b) => b.createdAt - a.createdAt);
-    return options?.limit ? allRuns.slice(0, options.limit) : allRuns;
+    return allRuns;
   }
   async cancelRun(runId, reason) {
     const allWorkflows = await this.db.listActiveWorkflows();
@@ -6208,8 +6843,7 @@ class PostgresBackend extends Backend {
     for (const workflowSlug of allWorkflows) {
       const runIds = await this.db.listRunIds(workflowSlug);
       if (runIds.includes(runId)) {
-        const events = await this.db.loadAllRunEvents(workflowSlug, runId);
-        const workflowEvents = events.filter((e) => e.category === "workflow");
+        const workflowEvents = await this.loadEvents(workflowSlug, runId, { category: "workflow" });
         return projectRunStateFromEvents(workflowEvents, workflowSlug);
       }
     }
@@ -6359,20 +6993,17 @@ class PostgresBackend extends Backend {
     ]);
   }
   async getWorkflowVersion(workflowSlug, versionId) {
-    const result = await this.db.getPool().query(`
-      SELECT * FROM ${this.db.getSchema()}.workflow_versions
-      WHERE workflow_slug = $1 AND version_id = $2
-    `, [workflowSlug, versionId]);
-    if (result.rows.length === 0)
+    const row = await this.db.getWorkflowVersion(workflowSlug, versionId);
+    if (!row)
       return null;
-    const row = result.rows[0];
     return {
       workflowSlug: row.workflow_slug,
       versionId: row.version_id,
+      versionNumber: parseInt(row.version_number.toString(), 10),
       createdAt: Math.floor(new Date(row.created_at).getTime() * 1000),
       stepManifest: row.step_manifest,
       totalSteps: row.total_steps,
-      git: row.git_commit ? {
+      git: row.git_commit && row.git_dirty !== null && row.git_branch !== null ? {
         commit: row.git_commit,
         dirty: row.git_dirty,
         branch: row.git_branch
@@ -6380,22 +7011,17 @@ class PostgresBackend extends Backend {
     };
   }
   async getCurrentWorkflowVersion(workflowSlug) {
-    const result = await this.db.getPool().query(`
-      SELECT * FROM ${this.db.getSchema()}.workflow_versions
-      WHERE workflow_slug = $1
-      ORDER BY created_at DESC
-      LIMIT 1
-    `, [workflowSlug]);
-    if (result.rows.length === 0)
+    const row = await this.db.getCurrentWorkflowVersion(workflowSlug);
+    if (!row)
       return null;
-    const row = result.rows[0];
     return {
       workflowSlug: row.workflow_slug,
       versionId: row.version_id,
+      versionNumber: parseInt(row.version_number.toString(), 10),
       createdAt: Math.floor(new Date(row.created_at).getTime() * 1000),
       stepManifest: row.step_manifest,
       totalSteps: row.total_steps,
-      git: row.git_commit ? {
+      git: row.git_commit && row.git_dirty !== null && row.git_branch !== null ? {
         commit: row.git_commit,
         dirty: row.git_dirty,
         branch: row.git_branch
@@ -6404,19 +7030,15 @@ class PostgresBackend extends Backend {
   }
   async listWorkflowVersions(workflowSlug, options) {
     const limit = options?.limit ?? 100;
-    const result = await this.db.getPool().query(`
-      SELECT * FROM ${this.db.getSchema()}.workflow_versions
-      WHERE workflow_slug = $1
-      ORDER BY created_at DESC
-      LIMIT $2
-    `, [workflowSlug, limit]);
-    return result.rows.map((row) => ({
+    const rows = await this.db.listWorkflowVersions(workflowSlug, limit);
+    return rows.map((row) => ({
       workflowSlug: row.workflow_slug,
       versionId: row.version_id,
+      versionNumber: parseInt(row.version_number.toString(), 10),
       createdAt: Math.floor(new Date(row.created_at).getTime() * 1000),
       stepManifest: row.step_manifest,
       totalSteps: row.total_steps,
-      git: row.git_commit ? {
+      git: row.git_commit && row.git_dirty !== null && row.git_branch !== null ? {
         commit: row.git_commit,
         dirty: row.git_dirty,
         branch: row.git_branch
@@ -6431,7 +7053,7 @@ class PostgresBackend extends Backend {
     const startUs = options?.startUs ?? now - 24 * 60 * 60 * 1000 * 1000;
     const endUs = options?.endUs ?? now;
     let stepQuery = `
-      SELECT event_data
+      SELECT event_data, event_id
       FROM ${this.db.getSchema()}.step_events
       WHERE timestamp_us >= $1 AND timestamp_us <= $2
     `;
@@ -6455,7 +7077,7 @@ class PostgresBackend extends Backend {
     }
     stepQuery += ` ORDER BY timestamp_us ASC`;
     let workflowQuery = `
-      SELECT event_data
+      SELECT event_data, event_id
       FROM ${this.db.getSchema()}.workflow_events
       WHERE timestamp_us >= $1 AND timestamp_us <= $2
     `;
@@ -6477,8 +7099,8 @@ class PostgresBackend extends Backend {
       this.db.getPool().query(stepQuery, stepParams),
       options?.stepId ? Promise.resolve({ rows: [] }) : this.db.getPool().query(workflowQuery, workflowParams)
     ]);
-    const stepEvents = stepResult.rows.map((row) => row.event_data);
-    const workflowEvents = workflowResult.rows.map((row) => row.event_data);
+    const stepEvents = stepResult.rows.map((row) => ({ ...row.event_data, eventId: row.event_id }));
+    const workflowEvents = workflowResult.rows.map((row) => ({ ...row.event_data, eventId: row.event_id }));
     return { stepEvents, workflowEvents };
   }
   async getErrorAnalysis(options) {
@@ -6666,113 +7288,34 @@ class PostgresBackend extends Backend {
     return computeThroughput(stepEvents, workflowEvents, timeRangeUs, options?.workflowSlug);
   }
   async getQueueDepth(options) {
-    const runs = await this.listRuns({
-      workflowSlug: options?.workflowSlug,
-      status: ["pending", "running"]
-    });
-    let pendingRuns = 0;
-    let runningRuns = 0;
-    let scheduledSteps = 0;
-    let runningSteps = 0;
-    let oldestScheduledStepUs;
-    let oldestPendingRunUs;
-    for (const run of runs) {
-      if (run.status === "pending") {
-        pendingRuns++;
-        if (!oldestPendingRunUs || run.createdAt < oldestPendingRunUs) {
-          oldestPendingRunUs = run.createdAt;
-        }
-      } else if (run.status === "running") {
-        runningRuns++;
-        try {
-          const stepEvents = await this.loadEvents(run.workflowSlug, run.runId, {
-            category: "step"
-          });
-          const eventsByStep = new Map;
-          for (const event of stepEvents) {
-            const events = eventsByStep.get(event.stepId) || [];
-            events.push(event);
-            eventsByStep.set(event.stepId, events);
-          }
-          for (const [stepId, events] of eventsByStep.entries()) {
-            const state = projectStepState(events, run.workflowSlug);
-            if (state.status === "scheduled") {
-              scheduledSteps++;
-              if (state.availableAt && (!oldestScheduledStepUs || state.availableAt < oldestScheduledStepUs)) {
-                oldestScheduledStepUs = state.availableAt;
-              }
-            } else if (state.status === "running") {
-              runningSteps++;
-            }
-          }
-        } catch (error) {
-          continue;
-        }
-      }
-    }
+    const result = await this.db.getQueueDepthAggregation(options?.workflowSlug);
     return {
       workflowSlug: options?.workflowSlug,
-      pendingRuns,
-      runningRuns,
-      scheduledSteps,
-      runningSteps,
-      oldestScheduledStepUs,
-      oldestPendingRunUs
+      pendingRuns: result.pendingRuns,
+      runningRuns: result.runningRuns,
+      scheduledSteps: result.scheduledSteps,
+      runningSteps: result.runningSteps,
+      oldestScheduledStepUs: result.oldestScheduledStepUs ?? undefined,
+      oldestPendingRunUs: result.oldestPendingRunUs ?? undefined
     };
   }
   async getQueueDepthByWorkflow() {
-    const runs = await this.listRuns({ status: ["pending", "running"] });
-    const workflowMap = new Map;
-    for (const run of runs) {
-      const existing = workflowMap.get(run.workflowSlug) || {
-        pendingRuns: 0,
-        scheduledSteps: 0
-      };
-      if (run.status === "pending") {
-        existing.pendingRuns++;
-        if (!existing.oldestPendingItemUs || run.createdAt < existing.oldestPendingItemUs) {
-          existing.oldestPendingItemUs = run.createdAt;
-        }
-      } else if (run.status === "running") {
-        try {
-          const stepEvents = await this.loadEvents(run.workflowSlug, run.runId, {
-            category: "step"
-          });
-          const eventsByStep = new Map;
-          for (const event of stepEvents) {
-            const events = eventsByStep.get(event.stepId) || [];
-            events.push(event);
-            eventsByStep.set(event.stepId, events);
-          }
-          for (const [stepId, events] of eventsByStep.entries()) {
-            const state = projectStepState(events, run.workflowSlug);
-            if (state.status === "scheduled") {
-              existing.scheduledSteps++;
-              if (state.availableAt && (!existing.oldestPendingItemUs || state.availableAt < existing.oldestPendingItemUs)) {
-                existing.oldestPendingItemUs = state.availableAt;
-              }
-            }
-          }
-        } catch (error) {
-          continue;
-        }
-      }
-      workflowMap.set(run.workflowSlug, existing);
-    }
-    const allMetadata = await this.listWorkflowMetadata();
+    const [aggregation, allMetadata] = await Promise.all([
+      this.db.getQueueDepthByWorkflowAggregation(),
+      this.listWorkflowMetadata()
+    ]);
     const metadataMap = new Map(allMetadata.map((m) => [m.slug, m]));
-    const result = Array.from(workflowMap.entries()).map(([workflowSlug, data]) => ({
-      workflowSlug,
-      workflowName: metadataMap.get(workflowSlug)?.name,
-      pendingRuns: data.pendingRuns,
-      scheduledSteps: data.scheduledSteps,
-      oldestPendingItemUs: data.oldestPendingItemUs
-    })).filter((item) => item.pendingRuns > 0 || item.scheduledSteps > 0).sort((a, b) => {
+    return aggregation.map((item) => ({
+      workflowSlug: item.workflowSlug,
+      workflowName: metadataMap.get(item.workflowSlug)?.name,
+      pendingRuns: item.pendingRuns,
+      scheduledSteps: item.scheduledSteps,
+      oldestPendingItemUs: item.oldestPendingItemUs ?? undefined
+    })).sort((a, b) => {
       const aTotal = a.pendingRuns + a.scheduledSteps;
       const bTotal = b.pendingRuns + b.scheduledSteps;
       return bTotal - aTotal;
     });
-    return result;
   }
   async getSuccessRate(options) {
     const { stepEvents, workflowEvents } = await this.loadEventsForAnalytics(options);
@@ -6825,4 +7368,4 @@ export {
   PostgresBackend
 };
 
-//# debugId=A0E144781C28BCEA64756E2164756E21
+//# debugId=E1D15906F1E05F4664756E2164756E21