@cascade-flow/backend-postgres 0.2.17 → 0.2.20

package/dist/index.js

@@ -5125,13 +5125,15 @@ class DatabaseClient {
       client.release();
     }
   }
-  async claimScheduledStep(workflowSlug, runId, stepId, workerId, eventToWrite) {
+  async claimScheduledStep(workflowSlug, runId, stepId, eventToWrite) {
     const client = await this.pool.connect();
     try {
       await client.query("BEGIN");
+      const currentTimeUs = Date.now() * 1000;
       const checkQuery = `
-      SELECT event_data FROM ${this.schema}.step_events
+      SELECT event_data, attempt_number, available_at_us FROM ${this.schema}.step_events
       WHERE workflow_slug = $1 AND run_id = $2 AND step_id = $3
+        AND type NOT IN ('LogEntry', 'StepCheckpoint', 'StepCheckpointFailed')
       ORDER BY timestamp_us DESC, event_id DESC
       LIMIT 1
       FOR UPDATE SKIP LOCKED
@@ -5139,14 +5141,22 @@ class DatabaseClient {
       const checkResult = await client.query(checkQuery, [workflowSlug, runId, stepId]);
       if (checkResult.rows.length === 0) {
         await client.query("ROLLBACK");
-        return false;
+        return null;
       }
-      const latestEvent = checkResult.rows[0].event_data;
+      const latestRow = checkResult.rows[0];
+      const latestEvent = latestRow.event_data;
       if (latestEvent.type !== "StepScheduled" && latestEvent.type !== "StepReclaimed" && latestEvent.type !== "StepRetrying") {
         await client.query("ROLLBACK");
-        return false;
+        return null;
+      }
+      const availableAtUs = latestRow.available_at_us ?? latestEvent.availableAtUs ?? null;
+      if (availableAtUs !== null && availableAtUs > currentTimeUs) {
+        await client.query("ROLLBACK");
+        return null;
       }
-      let workerId2 = null;
+      const resolvedAttemptNumber = latestRow.attempt_number ?? latestEvent.attemptNumber ?? (eventToWrite.type === "StepStarted" ? eventToWrite.attemptNumber : null) ?? 1;
+      const eventPayload = eventToWrite.type === "StepStarted" ? { ...eventToWrite, attemptNumber: resolvedAttemptNumber } : eventToWrite;
+      let eventWorkerId = null;
       let attemptNumber = null;
       let slotIndex = null;
       let workerConcurrency = null;
@@ -5155,18 +5165,18 @@ class DatabaseClient {
       let errorStackExactHash = "";
       let errorStackNormalizedHash = "";
       let errorStackPortableHash = "";
-      if (eventToWrite.type === "StepStarted") {
-        workerId2 = eventToWrite.workerId;
-        attemptNumber = eventToWrite.attemptNumber;
-        slotIndex = eventToWrite.slotIndex ?? null;
-        workerConcurrency = eventToWrite.workerConcurrency ?? null;
-      }
-      if (eventToWrite.type === "StepFailed") {
-        errorNameHash = eventToWrite.errorFingerprints.nameHash;
-        errorMessageHash = eventToWrite.errorFingerprints.messageHash;
-        errorStackExactHash = eventToWrite.errorFingerprints.stackExactHash;
-        errorStackNormalizedHash = eventToWrite.errorFingerprints.stackNormalizedHash;
-        errorStackPortableHash = eventToWrite.errorFingerprints.stackPortableHash;
+      if (eventPayload.type === "StepStarted") {
+        eventWorkerId = eventPayload.workerId;
+        attemptNumber = eventPayload.attemptNumber;
+        slotIndex = eventPayload.slotIndex ?? null;
+        workerConcurrency = eventPayload.workerConcurrency ?? null;
+      }
+      if (eventPayload.type === "StepFailed") {
+        errorNameHash = eventPayload.errorFingerprints.nameHash;
+        errorMessageHash = eventPayload.errorFingerprints.messageHash;
+        errorStackExactHash = eventPayload.errorFingerprints.stackExactHash;
+        errorStackNormalizedHash = eventPayload.errorFingerprints.stackNormalizedHash;
+        errorStackPortableHash = eventPayload.errorFingerprints.stackPortableHash;
       }
       const versionResult = await client.query(`SELECT version_id FROM ${this.schema}.workflow_events
          WHERE workflow_slug = $1 AND run_id = $2
@@ -5183,15 +5193,15 @@ class DatabaseClient {
           slot_index, worker_concurrency
         )
          VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20)`, [
-        eventToWrite.eventId,
-        eventToWrite.workflowSlug,
-        eventToWrite.runId,
-        eventToWrite.stepId,
-        eventToWrite.timestampUs,
-        eventToWrite.category,
-        eventToWrite.type,
-        JSON.stringify(stripEventIdFromJson(eventToWrite)),
-        workerId2,
+        eventPayload.eventId,
+        eventPayload.workflowSlug,
+        eventPayload.runId,
+        eventPayload.stepId,
+        eventPayload.timestampUs,
+        eventPayload.category,
+        eventPayload.type,
+        JSON.stringify(stripEventIdFromJson(eventPayload)),
+        eventWorkerId,
         attemptNumber,
         null,
         null,
@@ -5205,7 +5215,7 @@ class DatabaseClient {
         workerConcurrency
       ]);
       await client.query("COMMIT");
-      return true;
+      return resolvedAttemptNumber;
     } catch (error) {
       await client.query("ROLLBACK");
       throw error;
@@ -5218,31 +5228,55 @@ class DatabaseClient {
     try {
       const currentTimeUs = Date.now() * 1000;
       const scheduledTypes = ["StepScheduled", "StepReclaimed", "StepRetrying"];
-      let query = `
-      WITH latest_step_events AS (
-        SELECT DISTINCT ON (workflow_slug, run_id, step_id)
-          workflow_slug, run_id, step_id, type, available_at_us, priority
-        FROM ${this.schema}.step_events
-        ${options?.workflowSlugs ? "WHERE workflow_slug = ANY($1)" : ""}
-        ORDER BY workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC
-      )
-      SELECT workflow_slug, run_id, step_id
-      FROM latest_step_events
-      WHERE type = ANY($${options?.workflowSlugs ? "2" : "1"})
-        AND (available_at_us IS NULL OR available_at_us <= $${options?.workflowSlugs ? "3" : "2"})
-      ORDER BY priority DESC NULLS LAST, available_at_us ASC
-      ${options?.limit ? `LIMIT $${options?.workflowSlugs ? "4" : "3"}` : ""}
-    `;
-      const params = [];
-      if (options?.workflowSlugs) {
-        params.push(options.workflowSlugs);
-      }
-      params.push(scheduledTypes);
-      params.push(currentTimeUs);
-      if (options?.limit) {
-        params.push(options.limit);
-      }
-      const result = await client.query(query, params);
+      const result = await client.query(`WITH latest_workflow_events AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            type
+          FROM ${this.schema}.workflow_events
+          WHERE ($1::text[] IS NULL OR workflow_slug = ANY($1))
+            AND type IN (
+              'RunSubmitted',
+              'WorkflowRetryStarted',
+              'WorkflowStarted',
+              'WorkflowResumed',
+              'WorkflowCompleted',
+              'WorkflowFailed',
+              'WorkflowCancelled'
+            )
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
+        ),
+        active_runs AS (
+          SELECT workflow_slug, run_id
+          FROM latest_workflow_events
+          WHERE type IN ('RunSubmitted', 'WorkflowRetryStarted', 'WorkflowStarted', 'WorkflowResumed')
+        ),
+        latest_step_events AS (
+          SELECT DISTINCT ON (se.workflow_slug, se.run_id, se.step_id)
+            se.workflow_slug,
+            se.run_id,
+            se.step_id,
+            se.type,
+            se.available_at_us,
+            se.priority
+          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
+          WHERE se.type NOT IN ('LogEntry', 'StepCheckpoint', 'StepCheckpointFailed')
+          ORDER BY se.workflow_slug, se.run_id, se.step_id, se.timestamp_us DESC, se.event_id DESC
+        )
+        SELECT workflow_slug, run_id, step_id
+        FROM latest_step_events
+        WHERE type = ANY($2)
+          AND (available_at_us IS NULL OR available_at_us <= $3)
+        ORDER BY priority DESC NULLS LAST, available_at_us ASC
+        LIMIT COALESCE($4::int, 2147483647)`, [
+        options?.workflowSlugs ?? null,
+        scheduledTypes,
+        currentTimeUs,
+        options?.limit ?? null
+      ]);
       return result.rows.map((row) => ({
         workflowSlug: row.workflow_slug,
         runId: row.run_id,
@@ -5256,24 +5290,56 @@ class DatabaseClient {
     const client = await this.pool.connect();
     try {
       const currentTimeUs = Date.now() * 1000;
-      const query = `
-      WITH latest_step_events AS (
-        SELECT DISTINCT ON (workflow_slug, run_id, step_id)
-          workflow_slug, run_id, step_id, type, timestamp_us, worker_id
-        FROM ${this.schema}.step_events
+      const result = await client.query(`WITH latest_workflow_events AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            type
+          FROM ${this.schema}.workflow_events
+          WHERE type IN (
+            'RunSubmitted',
+            'WorkflowRetryStarted',
+            'WorkflowStarted',
+            'WorkflowResumed',
+            'WorkflowCompleted',
+            'WorkflowFailed',
+            'WorkflowCancelled'
+          )
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
+        ),
+        running_runs AS (
+          SELECT workflow_slug, run_id
+          FROM latest_workflow_events
+          WHERE type IN ('WorkflowStarted', 'WorkflowResumed')
+        ),
+        latest_step_events AS (
+          SELECT DISTINCT ON (se.workflow_slug, se.run_id, se.step_id)
+            se.workflow_slug,
+            se.run_id,
+            se.step_id,
+            se.type,
+            se.timestamp_us,
+            se.worker_id,
+            se.attempt_number
+          FROM ${this.schema}.step_events se
+          INNER JOIN running_runs rr
+            ON rr.workflow_slug = se.workflow_slug
+            AND rr.run_id = se.run_id
+          WHERE se.type NOT IN ('LogEntry', 'StepCheckpoint', 'StepCheckpointFailed')
+          ORDER BY se.workflow_slug, se.run_id, se.step_id, se.timestamp_us DESC, se.event_id DESC
+        )
+        SELECT workflow_slug, run_id, step_id, worker_id, attempt_number, timestamp_us
+        FROM latest_step_events
         WHERE type IN ('StepStarted', 'StepHeartbeat')
-        ORDER BY workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC
-      )
-      SELECT workflow_slug, run_id, step_id, worker_id
-      FROM latest_step_events
-      WHERE timestamp_us < $1 AND worker_id IS NOT NULL
-    `;
-      const result = await client.query(query, [currentTimeUs - staleThresholdUs]);
+          AND timestamp_us < $1
+          AND worker_id IS NOT NULL`, [currentTimeUs - staleThresholdUs]);
       return result.rows.map((row) => ({
         workflowSlug: row.workflow_slug,
         runId: row.run_id,
         stepId: row.step_id,
-        workerId: row.worker_id
+        workerId: row.worker_id,
+        attemptNumber: row.attempt_number ?? 1,
+        lastHeartbeatUs: Number(row.timestamp_us)
       }));
     } finally {
       client.release();
@@ -5480,16 +5546,27 @@ class DatabaseClient {
   async listActiveWorkflows() {
     const client = await this.pool.connect();
     try {
-      const result = await client.query(`
-      SELECT DISTINCT workflow_slug FROM (
-        SELECT DISTINCT workflow_slug FROM ${this.schema}.workflow_events
-        WHERE type IN ('RunSubmitted', 'WorkflowStarted', 'WorkflowResumed')
-        UNION
-        SELECT DISTINCT workflow_slug FROM ${this.schema}.step_events
-        WHERE type IN ('StepScheduled', 'StepStarted', 'StepReclaimed', 'StepRetrying')
-      ) AS active
-      ORDER BY workflow_slug ASC
-    `);
+      const result = await client.query(`WITH latest_workflow_events AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            type
+          FROM ${this.schema}.workflow_events
+          WHERE type IN (
+            'RunSubmitted',
+            'WorkflowRetryStarted',
+            'WorkflowStarted',
+            'WorkflowResumed',
+            'WorkflowCompleted',
+            'WorkflowFailed',
+            'WorkflowCancelled'
+          )
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
+        )
+        SELECT DISTINCT workflow_slug
+        FROM latest_workflow_events
+        WHERE type IN ('RunSubmitted', 'WorkflowRetryStarted', 'WorkflowStarted', 'WorkflowResumed')
+        ORDER BY workflow_slug ASC`);
       return result.rows.map((row) => row.workflow_slug);
     } finally {
       client.release();
@@ -5630,6 +5707,15 @@ class DatabaseClient {
             type
           FROM ${this.schema}.workflow_events
           WHERE ($1::text IS NULL OR workflow_slug = $1)
+            AND type IN (
+              'RunSubmitted',
+              'WorkflowRetryStarted',
+              'WorkflowStarted',
+              'WorkflowResumed',
+              'WorkflowCompleted',
+              'WorkflowFailed',
+              'WorkflowCancelled'
+            )
           ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
         )
         SELECT
@@ -5767,90 +5853,33 @@ class DatabaseClient {
       client.release();
     }
   }
-  async getActiveWorkersAggregation(options) {
+  async getActiveWorkersAggregation(_options) {
     const client = await this.pool.connect();
     try {
-      const nowUs = Date.now() * 1000;
-      const staleThresholdUs = options?.staleThresholdUs ?? 30 * 1000 * 1000;
-      const includeInactive = options?.includeInactive ?? false;
-      const staleTimestamp = nowUs - staleThresholdUs;
-      const workerStatsResult = await client.query(`
-        WITH worker_activity AS (
-          -- All worker activity from StepStarted and StepHeartbeat events
-          SELECT
-            worker_id,
-            MAX(timestamp_us) AS last_seen_us
-          FROM ${this.schema}.step_events
-          WHERE worker_id IS NOT NULL
-            AND type IN ('StepStarted', 'StepHeartbeat')
-            ${options?.timeRange ? `AND timestamp_us >= $1 AND timestamp_us <= $2` : ""}
-          GROUP BY worker_id
-        ),
-        -- Steps started by each worker
-        steps_started AS (
-          SELECT DISTINCT
-            se.worker_id,
-            se.workflow_slug,
-            se.run_id,
-            se.step_id,
-            se.attempt_number
-          FROM ${this.schema}.step_events se
-          WHERE se.type = 'StepStarted'
-            AND se.worker_id IS NOT NULL
-        ),
-        -- Steps completed
-        completed_steps AS (
-          SELECT
-            ss.worker_id,
-            COUNT(*) AS completed_count
-          FROM steps_started ss
-          INNER JOIN ${this.schema}.step_events se
-            ON se.workflow_slug = ss.workflow_slug
-            AND se.run_id = ss.run_id
-            AND se.step_id = ss.step_id
-            AND se.attempt_number = ss.attempt_number
-            AND se.type = 'StepCompleted'
-          GROUP BY ss.worker_id
-        ),
-        -- Steps failed
-        failed_steps AS (
-          SELECT
-            ss.worker_id,
-            COUNT(*) AS failed_count
-          FROM steps_started ss
-          INNER JOIN ${this.schema}.step_events se
-            ON se.workflow_slug = ss.workflow_slug
-            AND se.run_id = ss.run_id
-            AND se.step_id = ss.step_id
-            AND se.attempt_number = ss.attempt_number
-            AND se.type = 'StepFailed'
-          GROUP BY ss.worker_id
-        ),
-        -- Reclamation counts (times this worker's steps were reclaimed)
-        reclaimed_counts AS (
-          SELECT
-            (event_data->>'originalWorkerId') AS worker_id,
-            COUNT(*) AS reclaimed_count
-          FROM ${this.schema}.step_events
-          WHERE type = 'StepReclaimed'
-          GROUP BY (event_data->>'originalWorkerId')
+      const runningRunsResult = await client.query(`
+        WITH latest_workflow_events AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            type
+          FROM ${this.schema}.workflow_events
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
         )
-        SELECT
-          wa.worker_id,
-          wa.last_seen_us,
-          COALESCE(cs.completed_count, 0) AS total_steps_processed,
-          COALESCE(fs.failed_count, 0) AS failed_steps,
-          COALESCE(rc.reclaimed_count, 0) AS reclaimed_from_count
-        FROM worker_activity wa
-        LEFT JOIN completed_steps cs ON wa.worker_id = cs.worker_id
-        LEFT JOIN failed_steps fs ON wa.worker_id = fs.worker_id
-        LEFT JOIN reclaimed_counts rc ON wa.worker_id = rc.worker_id
-        ${!includeInactive ? `WHERE wa.last_seen_us >= ${staleTimestamp}` : ""}
-        ORDER BY wa.last_seen_us DESC
-      `, options?.timeRange ? [options.timeRange.startUs, options.timeRange.endUs] : []);
+        SELECT workflow_slug, run_id
+        FROM latest_workflow_events
+        WHERE type IN ('WorkflowStarted', 'WorkflowResumed')
+        LIMIT 500
+      `);
+      if (runningRunsResult.rows.length === 0) {
+        return {
+          workers: [],
+          totalActiveWorkers: 0,
+          totalRunningSteps: 0
+        };
+      }
+      const runIds = runningRunsResult.rows.map((r) => r.run_id);
       const runningStepsResult = await client.query(`
         WITH latest_step_events AS (
-          -- Get the latest event per step (excluding LogEntry)
           SELECT DISTINCT ON (workflow_slug, run_id, step_id)
             workflow_slug,
             run_id,
@@ -5861,78 +5890,24 @@ class DatabaseClient {
             slot_index,
             worker_concurrency
           FROM ${this.schema}.step_events
-          WHERE type NOT IN ('LogEntry', 'StepCheckpoint', 'StepCheckpointFailed')
+          WHERE run_id = ANY($1)
+            AND type NOT IN ('LogEntry', 'StepCheckpoint', 'StepCheckpointFailed')
           ORDER BY workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC
-        ),
-        -- Steps currently running (latest event is StepStarted or StepHeartbeat)
-        running_steps AS (
-          SELECT
-            workflow_slug,
-            run_id,
-            step_id,
-            worker_id,
-            slot_index,
-            worker_concurrency
-          FROM latest_step_events
-          WHERE type IN ('StepStarted', 'StepHeartbeat')
-            AND worker_id IS NOT NULL
-        ),
-        -- Get start time and last heartbeat for each running step
-        step_times AS (
-          SELECT
-            rs.workflow_slug,
-            rs.run_id,
-            rs.step_id,
-            rs.worker_id,
-            rs.slot_index,
-            rs.worker_concurrency,
-            MIN(se.timestamp_us) FILTER (WHERE se.type = 'StepStarted') AS started_at_us,
-            MAX(se.timestamp_us) FILTER (WHERE se.type IN ('StepStarted', 'StepHeartbeat')) AS last_heartbeat_us
-          FROM running_steps rs
-          INNER JOIN ${this.schema}.step_events se
-            ON se.workflow_slug = rs.workflow_slug
-            AND se.run_id = rs.run_id
-            AND se.step_id = rs.step_id
-            AND se.type IN ('StepStarted', 'StepHeartbeat')
-          GROUP BY rs.workflow_slug, rs.run_id, rs.step_id, rs.worker_id, rs.slot_index, rs.worker_concurrency
         )
         SELECT
           worker_id,
           workflow_slug,
           run_id,
           step_id,
-          started_at_us,
-          last_heartbeat_us,
+          timestamp_us as last_heartbeat_us,
           slot_index,
           worker_concurrency
-        FROM step_times
-        ORDER BY worker_id, last_heartbeat_us DESC
-      `);
-      const workerConcurrencyResult = await client.query(`
-        SELECT DISTINCT ON (worker_id)
-          worker_id,
-          worker_concurrency
-        FROM ${this.schema}.step_events
-        WHERE worker_id IS NOT NULL
-          AND worker_concurrency IS NOT NULL
-          AND type IN ('StepStarted', 'StepHeartbeat')
-        ORDER BY worker_id, timestamp_us DESC
-      `);
-      const workerConcurrencyMap = new Map;
-      for (const row of workerConcurrencyResult.rows) {
-        workerConcurrencyMap.set(row.worker_id, row.worker_concurrency);
-      }
+        FROM latest_step_events
+        WHERE type IN ('StepStarted', 'StepHeartbeat')
+          AND worker_id IS NOT NULL
+        LIMIT 1000
+      `, [runIds]);
       const workerMap = new Map;
-      for (const row of workerStatsResult.rows) {
-        workerMap.set(row.worker_id, {
-          workerId: row.worker_id,
-          lastSeenUs: parseInt(row.last_seen_us, 10),
-          totalStepsProcessed: parseInt(row.total_steps_processed, 10),
-          failedSteps: parseInt(row.failed_steps, 10),
-          reclaimedFromCount: parseInt(row.reclaimed_from_count, 10),
-          activeSteps: []
-        });
-      }
       for (const row of runningStepsResult.rows) {
         let worker = workerMap.get(row.worker_id);
         if (!worker) {
@@ -5942,10 +5917,15 @@ class DatabaseClient {
             totalStepsProcessed: 0,
             failedSteps: 0,
             reclaimedFromCount: 0,
+            workerConcurrency: row.worker_concurrency ?? undefined,
             activeSteps: []
           };
           workerMap.set(row.worker_id, worker);
         }
+        const lastHeartbeatUs = parseInt(row.last_heartbeat_us, 10);
+        if (lastHeartbeatUs > worker.lastSeenUs) {
+          worker.lastSeenUs = lastHeartbeatUs;
+        }
         if (row.worker_concurrency != null && worker.workerConcurrency == null) {
           worker.workerConcurrency = row.worker_concurrency;
         }
@@ -5953,19 +5933,11 @@ class DatabaseClient {
           workflowSlug: row.workflow_slug,
           runId: row.run_id,
           stepId: row.step_id,
-          startedAtUs: parseInt(row.started_at_us, 10),
-          lastHeartbeatUs: parseInt(row.last_heartbeat_us, 10),
+          startedAtUs: lastHeartbeatUs,
+          lastHeartbeatUs,
           slotIndex: row.slot_index ?? undefined
         });
       }
-      for (const worker of workerMap.values()) {
-        if (worker.workerConcurrency == null) {
-          const historicalConcurrency = workerConcurrencyMap.get(worker.workerId);
-          if (historicalConcurrency != null) {
-            worker.workerConcurrency = historicalConcurrency;
-          }
-        }
-      }
       const workers = Array.from(workerMap.values()).sort((a, b) => {
         if (b.activeSteps.length !== a.activeSteps.length) {
           return b.activeSteps.length - a.activeSteps.length;
@@ -5973,7 +5945,7 @@ class DatabaseClient {
         return b.lastSeenUs - a.lastSeenUs;
       });
       const totalRunningSteps = workers.reduce((sum, w) => sum + w.activeSteps.length, 0);
-      const totalActiveWorkers = workers.filter((w) => w.activeSteps.length > 0).length;
+      const totalActiveWorkers = workers.length;
       return {
         workers,
         totalActiveWorkers,
@@ -5983,6 +5955,112 @@ class DatabaseClient {
       client.release();
     }
   }
+  async getWorkerById(workerId) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`
+        WITH worker_step_events AS (
+          -- Get all step events for this worker
+          SELECT
+            workflow_slug,
+            run_id,
+            step_id,
+            type,
+            timestamp_us,
+            slot_index,
+            worker_concurrency
+          FROM ${this.schema}.step_events
+          WHERE worker_id = $1
+            AND type IN ('StepStarted', 'StepHeartbeat')
+        ),
+        latest_per_step AS (
+          -- For each step this worker touched, get the latest event
+          SELECT DISTINCT ON (workflow_slug, run_id, step_id)
+            workflow_slug,
+            run_id,
+            step_id,
+            timestamp_us,
+            slot_index,
+            worker_concurrency
+          FROM worker_step_events
+          ORDER BY workflow_slug, run_id, step_id, timestamp_us DESC
+        ),
+        -- Check if these steps are still running (no completion/failure after our heartbeat)
+        still_running AS (
+          SELECT
+            lps.workflow_slug,
+            lps.run_id,
+            lps.step_id,
+            lps.timestamp_us as last_heartbeat_us,
+            lps.slot_index,
+            lps.worker_concurrency
+          FROM latest_per_step lps
+          WHERE NOT EXISTS (
+            SELECT 1 FROM ${this.schema}.step_events se
+            WHERE se.workflow_slug = lps.workflow_slug
+              AND se.run_id = lps.run_id
+              AND se.step_id = lps.step_id
+              AND se.timestamp_us > lps.timestamp_us
+              AND se.type IN ('StepCompleted', 'StepFailed', 'StepSkipped', 'StepReclaimed')
+          )
+        )
+        SELECT * FROM still_running
+        ORDER BY last_heartbeat_us DESC
+        LIMIT 100
+      `, [workerId]);
+      if (result.rows.length === 0) {
+        const lastSeenResult = await client.query(`
+          SELECT MAX(timestamp_us) as last_seen_us, MAX(worker_concurrency) as worker_concurrency
+          FROM ${this.schema}.step_events
+          WHERE worker_id = $1
+            AND type IN ('StepStarted', 'StepHeartbeat')
+        `, [workerId]);
+        if (!lastSeenResult.rows[0]?.last_seen_us) {
+          return null;
+        }
+        return {
+          workerId,
+          lastSeenUs: parseInt(lastSeenResult.rows[0].last_seen_us, 10),
+          totalStepsProcessed: 0,
+          failedSteps: 0,
+          reclaimedFromCount: 0,
+          workerConcurrency: lastSeenResult.rows[0].worker_concurrency ?? undefined,
+          activeSteps: []
+        };
+      }
+      let lastSeenUs = 0;
+      let workerConcurrency;
+      const activeSteps = [];
+      for (const row of result.rows) {
+        const heartbeatUs = parseInt(row.last_heartbeat_us, 10);
+        if (heartbeatUs > lastSeenUs) {
+          lastSeenUs = heartbeatUs;
+        }
+        if (row.worker_concurrency != null && workerConcurrency == null) {
+          workerConcurrency = row.worker_concurrency;
+        }
+        activeSteps.push({
+          workflowSlug: row.workflow_slug,
+          runId: row.run_id,
+          stepId: row.step_id,
+          startedAtUs: heartbeatUs,
+          lastHeartbeatUs: heartbeatUs,
+          slotIndex: row.slot_index ?? undefined
+        });
+      }
+      return {
+        workerId,
+        lastSeenUs,
+        totalStepsProcessed: 0,
+        failedSteps: 0,
+        reclaimedFromCount: 0,
+        workerConcurrency,
+        activeSteps
+      };
+    } finally {
+      client.release();
+    }
+  }
 }
 function createPool(connectionString) {
   return new Pool2({ connectionString });
@@ -6384,6 +6462,87 @@ async function migration011_addWorkerConcurrencyIndex(pool, schema) {
     client.release();
   }
 }
+async function migration012_addWorkerAnalyticsIndexes(pool, schema) {
+  const client = await pool.connect();
+  try {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_worker_activity
+      ON ${schema}.step_events (timestamp_us, type, worker_id)
+      WHERE worker_id IS NOT NULL
+        AND type IN ('StepStarted', 'StepHeartbeat')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_recent_by_step
+      ON ${schema}.step_events (timestamp_us DESC, workflow_slug, run_id, step_id, type, event_id DESC)
+      WHERE type NOT IN ('LogEntry', 'StepCheckpoint', 'StepCheckpointFailed')
+    `);
+    console.log("[Migration 012] Worker analytics indexes added successfully");
+  } catch (error) {
+    console.error("[Migration 012] Error adding worker analytics indexes:", error);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function migration013_addWorkersObservabilityIndexes(pool, schema) {
+  const client = await pool.connect();
+  try {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_run_status
+      ON ${schema}.workflow_events (run_id, timestamp_us DESC, event_id DESC)
+      INCLUDE (workflow_slug, type)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_by_run
+      ON ${schema}.step_events (run_id, workflow_slug, step_id, timestamp_us DESC, event_id DESC)
+      INCLUDE (type, worker_id, slot_index, worker_concurrency)
+      WHERE type NOT IN ('LogEntry', 'StepCheckpoint', 'StepCheckpointFailed')
+    `);
+    console.log("[Migration 013] Workers observability indexes added successfully");
+  } catch (error) {
+    console.error("[Migration 013] Error adding workers observability indexes:", error);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function migration014_addWorkerHotPathIndexes(pool, schema) {
+  const client = await pool.connect();
+  try {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_latest_cover
+      ON ${schema}.step_events (workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC)
+      INCLUDE (type, available_at_us, worker_id, attempt_number, priority)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_terminal_latest
+      ON ${schema}.step_events (workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC)
+      WHERE type IN ('StepCompleted', 'StepFailed', 'StepSkipped', 'StepReclaimed')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_active_latest
+      ON ${schema}.workflow_events (type, workflow_slug, run_id, timestamp_us DESC, event_id DESC)
+      WHERE type IN ('RunSubmitted', 'WorkflowRetryStarted', 'WorkflowStarted', 'WorkflowResumed')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_run_chrono
+      ON ${schema}.workflow_events (workflow_slug, run_id, timestamp_us ASC, event_id ASC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_version_lookup
+      ON ${schema}.workflow_events (workflow_slug, run_id, timestamp_us DESC, event_id DESC)
+      INCLUDE (version_id)
+      WHERE type IN ('WorkflowStarted', 'RunSubmitted')
+        AND version_id IS NOT NULL
+    `);
+    console.log("[Migration 014] Worker hot-path indexes added successfully");
+  } catch (error) {
+    console.error("[Migration 014] Error adding worker hot-path indexes:", error);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
 async function runMigrations(pool, schema = "cascadeflow") {
   console.log(`[Migrations] Starting database migrations in schema '${schema}'...`);
   try {
@@ -6399,6 +6558,9 @@ async function runMigrations(pool, schema = "cascadeflow") {
     await migration009_addStepPriority(pool, schema);
     await migration010_addSlotTracking(pool, schema);
     await migration011_addWorkerConcurrencyIndex(pool, schema);
+    await migration012_addWorkerAnalyticsIndexes(pool, schema);
+    await migration013_addWorkersObservabilityIndexes(pool, schema);
+    await migration014_addWorkerHotPathIndexes(pool, schema);
     console.log("[Migrations] All migrations completed successfully");
   } catch (error) {
     console.error("[Migrations] Migration failed:", error);
@@ -7264,16 +7426,6 @@ class PostgresBackend extends Backend {
     return !!(latestEvent && (latestEvent.type === "StepScheduled" || latestEvent.type === "StepReclaimed" || latestEvent.type === "StepRetrying"));
   }
   async claimScheduledStep(workflowSlug, runId, stepId, workerId, metadata) {
-    const initialEvents = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
-    if (initialEvents.length === 0) {
-      return null;
-    }
-    const now = getMicrosecondTimestamp();
-    const initialState = projectStepState(initialEvents, workflowSlug);
-    if (initialState.status !== "scheduled" || initialState.availableAt === undefined || initialState.availableAt > now) {
-      return null;
-    }
-    const attemptNumber = initialState.attemptNumber;
     const timestamp = getMicrosecondTimestamp();
     const event = {
       category: "step",
@@ -7285,43 +7437,34 @@ class PostgresBackend extends Backend {
       stepId,
       workerId,
       dependencies: metadata.dependencies,
-      attemptNumber,
+      attemptNumber: metadata.attemptNumber,
       slotIndex: metadata.slotIndex,
       workerConcurrency: metadata.workerConcurrency
     };
-    const claimed = await this.db.claimScheduledStep(workflowSlug, runId, stepId, workerId, event);
-    return claimed ? { attemptNumber } : null;
+    const claimedAttemptNumber = await this.db.claimScheduledStep(workflowSlug, runId, stepId, event);
+    return claimedAttemptNumber !== null ? { attemptNumber: claimedAttemptNumber } : null;
   }
   async reclaimStaleSteps(staleThreshold, reclaimedBy) {
     const reclaimed = [];
     const now = getMicrosecondTimestamp();
     const staleSteps = await this.db.findStaleSteps(staleThreshold);
     for (const step of staleSteps) {
-      const events = await this.loadEvents(step.workflowSlug, step.runId, { category: "step", stepId: step.stepId });
-      if (events.length === 0)
-        continue;
-      const state = projectStepState(events, step.workflowSlug);
-      if (state.status !== "running")
-        continue;
-      const lastHeartbeat = state.lastHeartbeat || state.startTime || 0;
-      const staleDuration = now - lastHeartbeat;
-      if (staleDuration > staleThreshold) {
-        await this.saveStepReclaimed(step.workflowSlug, step.runId, step.stepId, {
-          originalWorkerId: state.claimedBy || "unknown",
-          reclaimedBy,
-          lastHeartbeat,
-          staleThreshold,
-          staleDuration,
-          attemptNumber: state.attemptNumber
-        });
-        await this.saveStepScheduled(step.workflowSlug, step.runId, step.stepId, {
-          availableAt: now,
-          reason: "retry",
-          attemptNumber: state.attemptNumber + 1,
-          retryDelayMs: 0
-        });
-        reclaimed.push({ workflowSlug: step.workflowSlug, runId: step.runId, stepId: step.stepId });
-      }
+      const staleDuration = now - step.lastHeartbeatUs;
+      await this.saveStepReclaimed(step.workflowSlug, step.runId, step.stepId, {
+        originalWorkerId: step.workerId,
+        reclaimedBy,
+        lastHeartbeat: step.lastHeartbeatUs,
+        staleThreshold,
+        staleDuration,
+        attemptNumber: step.attemptNumber
+      });
+      await this.saveStepScheduled(step.workflowSlug, step.runId, step.stepId, {
+        availableAt: now,
+        reason: "retry",
+        attemptNumber: step.attemptNumber + 1,
+        retryDelayMs: 0
+      });
+      reclaimed.push({ workflowSlug: step.workflowSlug, runId: step.runId, stepId: step.stepId });
     }
     return reclaimed;
   }
@@ -7754,9 +7897,25 @@ class PostgresBackend extends Backend {
       staleThresholdUs
     };
   }
+  async getWorkerById(workerId) {
+    const result = await this.db.getWorkerById(workerId);
+    if (!result) {
+      return null;
+    }
+    return {
+      workerId: result.workerId,
+      lastSeenUs: result.lastSeenUs,
+      currentlyRunningSteps: result.activeSteps.length,
+      totalStepsProcessed: result.totalStepsProcessed,
+      failedSteps: result.failedSteps,
+      reclaimedFromCount: result.reclaimedFromCount,
+      workerConcurrency: result.workerConcurrency,
+      activeSteps: result.activeSteps
+    };
+  }
 }
 export {
   PostgresBackend
 };
 
-//# debugId=9C62728A85A6463664756E2164756E21
+//# debugId=70613711DE018DE364756E2164756E21