tasker-engine 0.1.0

data/db/functions/get_slowest_tasks_v01.sql

@@ -0,0 +1,96 @@
+-- Slowest Tasks Analysis Function
+-- Returns the slowest tasks within a specified time period with performance metrics
+-- Input: since_timestamp, limit_count, and optional namespace/name/version filters
+-- Output: Ranked list of slowest tasks with duration and context
+
+CREATE OR REPLACE FUNCTION get_slowest_tasks_v01(
+    since_timestamp TIMESTAMPTZ DEFAULT NULL,
+    limit_count INTEGER DEFAULT 10,
+    namespace_filter TEXT DEFAULT NULL,
+    task_name_filter TEXT DEFAULT NULL,
+    version_filter TEXT DEFAULT NULL
+)
+RETURNS TABLE (
+    task_id BIGINT,
+    task_name VARCHAR(64),
+    namespace_name VARCHAR(64), 
+    version VARCHAR(64),
+    duration_seconds NUMERIC(10,3),
+    step_count BIGINT,
+    completed_steps BIGINT,
+    error_steps BIGINT,
+    created_at TIMESTAMPTZ,
+    completed_at TIMESTAMPTZ,
+    initiator VARCHAR(128),
+    source_system VARCHAR(128)
+) LANGUAGE plpgsql STABLE AS $$
+DECLARE
+    analysis_start TIMESTAMPTZ;
+BEGIN
+    -- Set analysis start time (default to 24 hours ago if not provided)
+    analysis_start := COALESCE(since_timestamp, NOW() - INTERVAL '24 hours');
+    
+    RETURN QUERY
+    WITH task_durations AS (
+        SELECT 
+            t.task_id,
+            nt.name as task_name,
+            tn.name as namespace_name,
+            nt.version,
+            t.created_at,
+            t.initiator,
+            t.source_system,
+            -- Find the latest completion time across all steps
+            MAX(wst.created_at) FILTER (
+                WHERE wst.to_state IN ('complete', 'error') AND wst.most_recent = true
+            ) as latest_completion,
+            -- Calculate duration from task creation to latest step completion
+            EXTRACT(EPOCH FROM (
+                MAX(wst.created_at) FILTER (
+                    WHERE wst.to_state IN ('complete', 'error') AND wst.most_recent = true
+                ) - t.created_at
+            )) as duration_seconds,
+            COUNT(ws.workflow_step_id) as total_steps,
+            COUNT(ws.workflow_step_id) FILTER (
+                WHERE complete_wst.to_state = 'complete' AND complete_wst.most_recent = true
+            ) as completed_step_count,
+            COUNT(ws.workflow_step_id) FILTER (
+                WHERE error_wst.to_state = 'error' AND error_wst.most_recent = true
+            ) as error_step_count
+        FROM tasker_tasks t
+        INNER JOIN tasker_named_tasks nt ON nt.named_task_id = t.named_task_id
+        INNER JOIN tasker_task_namespaces tn ON tn.task_namespace_id = nt.task_namespace_id
+        INNER JOIN tasker_workflow_steps ws ON ws.task_id = t.task_id
+        LEFT JOIN tasker_workflow_step_transitions wst ON wst.workflow_step_id = ws.workflow_step_id
+        LEFT JOIN tasker_workflow_step_transitions complete_wst ON complete_wst.workflow_step_id = ws.workflow_step_id
+            AND complete_wst.to_state = 'complete' AND complete_wst.most_recent = true
+        LEFT JOIN tasker_workflow_step_transitions error_wst ON error_wst.workflow_step_id = ws.workflow_step_id
+            AND error_wst.to_state = 'error' AND error_wst.most_recent = true
+        WHERE t.created_at > analysis_start
+          AND (namespace_filter IS NULL OR tn.name = namespace_filter)
+          AND (task_name_filter IS NULL OR nt.name = task_name_filter)
+          AND (version_filter IS NULL OR nt.version = version_filter)
+        GROUP BY t.task_id, nt.name, tn.name, nt.version, t.created_at, t.initiator, t.source_system
+        HAVING MAX(wst.created_at) FILTER (
+            WHERE wst.to_state IN ('complete', 'error') AND wst.most_recent = true
+        ) IS NOT NULL  -- Only include tasks that have at least one completed/failed step
+    )
+    SELECT 
+        td.task_id,
+        td.task_name,
+        td.namespace_name,
+        td.version,
+        ROUND(td.duration_seconds, 3),
+        td.total_steps,
+        td.completed_step_count,
+        td.error_step_count,
+        td.created_at,
+        td.latest_completion,
+        td.initiator,
+        td.source_system
+    FROM task_durations td
+    WHERE td.duration_seconds IS NOT NULL
+    ORDER BY td.duration_seconds DESC
+    LIMIT limit_count;
+END;
+$$;

data/db/functions/get_step_readiness_status_batch_v01.sql

@@ -0,0 +1,140 @@
+-- Batch Step Readiness Status Function
+-- Gets step readiness data for multiple tasks in a single query
+-- Input: Array of task_ids (gets all steps for each task)
+-- Output: Multiple rows with step readiness data, properly grouped by task
+
+CREATE OR REPLACE FUNCTION get_step_readiness_status_batch(input_task_ids BIGINT[])
+RETURNS TABLE(
+  workflow_step_id BIGINT,
+  task_id BIGINT,
+  named_step_id INTEGER,
+  name TEXT,
+  current_state TEXT,
+  dependencies_satisfied BOOLEAN,
+  retry_eligible BOOLEAN,
+  ready_for_execution BOOLEAN,
+  last_failure_at TIMESTAMP,
+  next_retry_at TIMESTAMP,
+  total_parents INTEGER,
+  completed_parents INTEGER,
+  attempts INTEGER,
+  retry_limit INTEGER,
+  backoff_request_seconds INTEGER,
+  last_attempted_at TIMESTAMP
+) LANGUAGE plpgsql STABLE AS $$
+BEGIN
+  RETURN QUERY
+  SELECT
+    ws.workflow_step_id,
+    ws.task_id,
+    ws.named_step_id,
+    ns.name::TEXT,
+
+    -- Current State Information (optimized using most_recent flag)
+    COALESCE(current_state.to_state, 'pending')::TEXT as current_state,
+
+    -- Dependency Analysis (calculated from direct joins)
+    CASE
+      WHEN dep_edges.to_step_id IS NULL THEN true  -- Root steps (no parents)
+      WHEN COUNT(dep_edges.from_step_id) = 0 THEN true  -- Steps with zero dependencies
+      WHEN COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id) THEN true
+      ELSE false
+    END as dependencies_satisfied,
+
+    -- Simplified Retry & Backoff Analysis
+    CASE
+      WHEN ws.attempts >= COALESCE(ws.retry_limit, 3) THEN false
+      WHEN ws.attempts > 0 AND COALESCE(ws.retryable, true) = false THEN false
+      WHEN last_failure.created_at IS NULL THEN true
+      WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+        ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second') <= NOW()
+      WHEN last_failure.created_at IS NOT NULL THEN
+        last_failure.created_at + (
+          LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds')
+        ) <= NOW()
+      ELSE true
+    END as retry_eligible,
+
+    -- Simplified Final Readiness Calculation
+    CASE
+      WHEN COALESCE(current_state.to_state, 'pending') IN ('pending', 'error')
+      AND (ws.processed = false OR ws.processed IS NULL)  -- CRITICAL: Only unprocessed steps can be ready
+      AND (dep_edges.to_step_id IS NULL OR
+           COUNT(dep_edges.from_step_id) = 0 OR
+           COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id))
+      AND (ws.attempts < COALESCE(ws.retry_limit, 3))
+      AND (COALESCE(ws.retryable, true) = true)
+      AND (ws.in_process = false OR ws.in_process IS NULL)
+      AND (
+        -- Check explicit backoff timing (most restrictive)
+        -- If backoff is set, the backoff period must have expired
+        CASE
+          WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+            ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second') <= NOW()
+          ELSE true  -- No explicit backoff set
+        END
+        AND
+        -- Then check failure-based backoff
+        (last_failure.created_at IS NULL OR
+         last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds')) <= NOW())
+      )
+      THEN true
+      ELSE false
+    END as ready_for_execution,
+
+    -- Timing Information
+    last_failure.created_at as last_failure_at,
+    CASE
+      WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+        ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second')
+      WHEN last_failure.created_at IS NOT NULL THEN
+        last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds'))
+      ELSE NULL
+    END as next_retry_at,
+
+    -- Dependency Context (calculated from joins)
+    COALESCE(COUNT(dep_edges.from_step_id), 0)::INTEGER as total_parents,
+    COALESCE(COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END), 0)::INTEGER as completed_parents,
+
+    -- Retry Context
+    ws.attempts,
+    COALESCE(ws.retry_limit, 3) as retry_limit,
+    ws.backoff_request_seconds,
+    ws.last_attempted_at
+
+  FROM tasker_workflow_steps ws
+  JOIN tasker_named_steps ns ON ns.named_step_id = ws.named_step_id
+
+  -- OPTIMIZED: Current State using most_recent flag instead of DISTINCT ON
+  LEFT JOIN tasker_workflow_step_transitions current_state
+    ON current_state.workflow_step_id = ws.workflow_step_id
+    AND current_state.most_recent = true
+
+  -- OPTIMIZED: Dependency check using direct joins (no subquery)
+  LEFT JOIN tasker_workflow_step_edges dep_edges
+    ON dep_edges.to_step_id = ws.workflow_step_id
+  LEFT JOIN tasker_workflow_step_transitions parent_states
+    ON parent_states.workflow_step_id = dep_edges.from_step_id
+    AND parent_states.most_recent = true
+
+  -- OPTIMIZED: Last failure using index-optimized approach
+  LEFT JOIN tasker_workflow_step_transitions last_failure
+    ON last_failure.workflow_step_id = ws.workflow_step_id
+    AND last_failure.to_state = 'error'
+    AND last_failure.most_recent = true
+
+  -- KEY PERFORMANCE IMPROVEMENT: Filter by multiple tasks at once
+  -- CRITICAL FIX: Include ALL steps for task execution context calculation
+  -- Only filter by processed status when specifically querying for ready steps
+  WHERE ws.task_id = ANY(input_task_ids)
+
+  GROUP BY
+    ws.workflow_step_id, ws.task_id, ws.named_step_id, ns.name,
+    current_state.to_state, last_failure.created_at,
+    ws.attempts, ws.retry_limit, ws.backoff_request_seconds, ws.last_attempted_at,
+    ws.in_process, ws.processed, ws.retryable, dep_edges.to_step_id
+
+  -- IMPORTANT: Order by task_id, then workflow_step_id for consistent grouping
+  ORDER BY ws.task_id, ws.workflow_step_id;
+END;
+$$;

data/db/functions/get_step_readiness_status_single_and_batch_v02.sql

@@ -0,0 +1,223 @@
+-- Fix step readiness logic for NULL attempts
+-- When attempts is NULL, it should be treated as 0 for comparison purposes
+
+-- Update get_step_readiness_status function
+CREATE OR REPLACE FUNCTION get_step_readiness_status(input_task_id bigint, step_ids bigint[] DEFAULT NULL::bigint[]) RETURNS TABLE(workflow_step_id bigint, task_id bigint, named_step_id integer, name text, current_state text, dependencies_satisfied boolean, retry_eligible boolean, ready_for_execution boolean, last_failure_at timestamp without time zone, next_retry_at timestamp without time zone, total_parents integer, completed_parents integer, attempts integer, retry_limit integer, backoff_request_seconds integer, last_attempted_at timestamp without time zone)
+    LANGUAGE plpgsql STABLE
+    AS $$
+BEGIN
+  RETURN QUERY
+  SELECT
+    ws.workflow_step_id,
+    ws.task_id,
+    ws.named_step_id,
+    ns.name::TEXT,
+
+    -- Current State Information (optimized using most_recent flag)
+    COALESCE(current_state.to_state, 'pending')::TEXT as current_state,
+
+    -- Dependency Satisfaction Analysis
+    CASE
+      WHEN dep_edges.to_step_id IS NULL OR
+           COUNT(dep_edges.from_step_id) = 0 THEN true
+      ELSE
+        COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id)
+    END as dependencies_satisfied,
+
+    -- Retry Eligibility
+    CASE
+      WHEN COALESCE(ws.attempts, 0) < COALESCE(ws.retry_limit, 3) THEN true
+      ELSE false
+    END as retry_eligible,
+
+    -- Overall Ready for Execution (complex business logic)
+    CASE
+      WHEN COALESCE(current_state.to_state, 'pending') IN ('pending', 'error')
+      AND (ws.processed = false OR ws.processed IS NULL)  -- CRITICAL: Only unprocessed steps can be ready
+      AND (dep_edges.to_step_id IS NULL OR
+           COUNT(dep_edges.from_step_id) = 0 OR
+           COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id))
+      AND (COALESCE(ws.attempts, 0) < COALESCE(ws.retry_limit, 3))  -- FIXED: Handle NULL attempts
+      AND (COALESCE(ws.retryable, true) = true)
+      AND (ws.in_process = false OR ws.in_process IS NULL)
+      AND (
+        -- Check explicit backoff timing (most restrictive)
+        -- If backoff is set, the backoff period must have expired
+        CASE
+          WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+            ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second') <= NOW()
+          ELSE true  -- No explicit backoff set
+        END
+        AND
+        -- Then check failure-based backoff
+        (last_failure.created_at IS NULL OR
+         last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds')) <= NOW())
+      )
+      THEN true
+      ELSE false
+    END as ready_for_execution,
+
+    -- Timing Information
+    last_failure.created_at as last_failure_at,
+    CASE
+      WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+        ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second')
+      WHEN last_failure.created_at IS NOT NULL THEN
+        last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds'))
+      ELSE NULL
+    END as next_retry_at,
+
+    -- Dependency Context (calculated from joins)
+    COALESCE(COUNT(dep_edges.from_step_id), 0)::INTEGER as total_parents,
+    COALESCE(COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END), 0)::INTEGER as completed_parents,
+
+    -- Retry Context
+    COALESCE(ws.attempts, 0)::INTEGER as attempts,  -- FIXED: Return 0 instead of NULL
+    COALESCE(ws.retry_limit, 3) as retry_limit,
+    ws.backoff_request_seconds,
+    ws.last_attempted_at
+
+  FROM tasker_workflow_steps ws
+  JOIN tasker_named_steps ns ON ns.named_step_id = ws.named_step_id
+
+  -- OPTIMIZED: Current State using most_recent flag instead of DISTINCT ON
+  LEFT JOIN tasker_workflow_step_transitions current_state
+    ON current_state.workflow_step_id = ws.workflow_step_id
+    AND current_state.most_recent = true
+
+  -- OPTIMIZED: Dependency check using direct joins (no subquery)
+  LEFT JOIN tasker_workflow_step_edges dep_edges
+    ON dep_edges.to_step_id = ws.workflow_step_id
+  LEFT JOIN tasker_workflow_step_transitions parent_states
+    ON parent_states.workflow_step_id = dep_edges.from_step_id
+    AND parent_states.most_recent = true
+
+  -- OPTIMIZED: Last failure using index-optimized approach
+  LEFT JOIN tasker_workflow_step_transitions last_failure
+    ON last_failure.workflow_step_id = ws.workflow_step_id
+    AND last_failure.to_state = 'error'
+    AND last_failure.most_recent = true
+
+  -- KEY PERFORMANCE IMPROVEMENT: Filter by task first, then optionally by step IDs
+  -- CRITICAL FIX: Include ALL steps for task execution context calculation
+  -- Only filter by processed status when specifically querying for ready steps
+  WHERE ws.task_id = input_task_id
+    AND (step_ids IS NULL OR ws.workflow_step_id = ANY(step_ids))
+
+  GROUP BY
+    ws.workflow_step_id, ws.task_id, ws.named_step_id, ns.name,
+    current_state.to_state, last_failure.created_at,
+    ws.attempts, ws.retry_limit, ws.backoff_request_seconds, ws.last_attempted_at,
+    ws.in_process, ws.processed, ws.retryable, dep_edges.to_step_id,
+    current_state.workflow_step_id, last_failure.workflow_step_id;
+END;
+$$;
+
+-- Also update the batch version
+CREATE OR REPLACE FUNCTION get_step_readiness_status_batch(input_task_ids bigint[]) RETURNS TABLE(workflow_step_id bigint, task_id bigint, named_step_id integer, name text, current_state text, dependencies_satisfied boolean, retry_eligible boolean, ready_for_execution boolean, last_failure_at timestamp without time zone, next_retry_at timestamp without time zone, total_parents integer, completed_parents integer, attempts integer, retry_limit integer, backoff_request_seconds integer, last_attempted_at timestamp without time zone)
+    LANGUAGE plpgsql STABLE
+    AS $$
+BEGIN
+  RETURN QUERY
+  SELECT
+    ws.workflow_step_id,
+    ws.task_id,
+    ws.named_step_id,
+    ns.name::TEXT,
+
+    -- Current State Information (optimized using most_recent flag)
+    COALESCE(current_state.to_state, 'pending')::TEXT as current_state,
+
+    -- Dependency Satisfaction Analysis
+    CASE
+      WHEN dep_edges.to_step_id IS NULL OR
+           COUNT(dep_edges.from_step_id) = 0 THEN true
+      ELSE
+        COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id)
+    END as dependencies_satisfied,
+
+    -- Retry Eligibility
+    CASE
+      WHEN COALESCE(ws.attempts, 0) < COALESCE(ws.retry_limit, 3) THEN true
+      ELSE false
+    END as retry_eligible,
+
+    -- Overall Ready for Execution (complex business logic)
+    CASE
+      WHEN COALESCE(current_state.to_state, 'pending') IN ('pending', 'error')
+      AND (ws.processed = false OR ws.processed IS NULL)
+      AND (dep_edges.to_step_id IS NULL OR
+           COUNT(dep_edges.from_step_id) = 0 OR
+           COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id))
+      AND (COALESCE(ws.attempts, 0) < COALESCE(ws.retry_limit, 3))  -- FIXED: Handle NULL attempts
+      AND (COALESCE(ws.retryable, true) = true)
+      AND (ws.in_process = false OR ws.in_process IS NULL)
+      AND (
+        -- Check explicit backoff timing (most restrictive)
+        -- If backoff is set, the backoff period must have expired
+        CASE
+          WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+            ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second') <= NOW()
+          ELSE true  -- No explicit backoff set
+        END
+        AND
+        -- Then check failure-based backoff
+        (last_failure.created_at IS NULL OR
+         last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds')) <= NOW())
+      )
+      THEN true
+      ELSE false
+    END as ready_for_execution,
+
+    -- Timing Information
+    last_failure.created_at as last_failure_at,
+    CASE
+      WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+        ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second')
+      WHEN last_failure.created_at IS NOT NULL THEN
+        last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds'))
+      ELSE NULL
+    END as next_retry_at,
+
+    -- Dependency Context (calculated from joins)
+    COALESCE(COUNT(dep_edges.from_step_id), 0)::INTEGER as total_parents,
+    COALESCE(COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END), 0)::INTEGER as completed_parents,
+
+    -- Retry Context
+    COALESCE(ws.attempts, 0)::INTEGER as attempts,  -- FIXED: Return 0 instead of NULL
+    COALESCE(ws.retry_limit, 3) as retry_limit,
+    ws.backoff_request_seconds,
+    ws.last_attempted_at
+
+  FROM tasker_workflow_steps ws
+  JOIN tasker_named_steps ns ON ns.named_step_id = ws.named_step_id
+
+  -- OPTIMIZED: Current State using most_recent flag instead of DISTINCT ON
+  LEFT JOIN tasker_workflow_step_transitions current_state
+    ON current_state.workflow_step_id = ws.workflow_step_id
+    AND current_state.most_recent = true
+
+  -- OPTIMIZED: Dependency check using direct joins (no subquery)
+  LEFT JOIN tasker_workflow_step_edges dep_edges
+    ON dep_edges.to_step_id = ws.workflow_step_id
+  LEFT JOIN tasker_workflow_step_transitions parent_states
+    ON parent_states.workflow_step_id = dep_edges.from_step_id
+    AND parent_states.most_recent = true
+
+  -- OPTIMIZED: Last failure using index-optimized approach
+  LEFT JOIN tasker_workflow_step_transitions last_failure
+    ON last_failure.workflow_step_id = ws.workflow_step_id
+    AND last_failure.to_state = 'error'
+    AND last_failure.most_recent = true
+
+  -- KEY PERFORMANCE IMPROVEMENT: Filter by task first, then optionally by step IDs
+  WHERE ws.task_id = ANY(input_task_ids)
+
+  GROUP BY
+    ws.workflow_step_id, ws.task_id, ws.named_step_id, ns.name,
+    current_state.to_state, last_failure.created_at,
+    ws.attempts, ws.retry_limit, ws.backoff_request_seconds, ws.last_attempted_at,
+    ws.in_process, ws.processed, ws.retryable, dep_edges.to_step_id,
+    current_state.workflow_step_id, last_failure.workflow_step_id;
+END;
+$$;

data/db/functions/get_step_readiness_status_v01.sql

@@ -0,0 +1,139 @@
+-- Step Readiness Status Function
+-- Converts the view logic to a parameterized function for targeted queries
+-- Input: Array of workflow_step_ids
+-- Output: Readiness data for specified steps only
+
+CREATE OR REPLACE FUNCTION get_step_readiness_status(input_task_id BIGINT, step_ids BIGINT[] DEFAULT NULL)
+RETURNS TABLE(
+  workflow_step_id BIGINT,
+  task_id BIGINT,
+  named_step_id INTEGER,
+  name TEXT,
+  current_state TEXT,
+  dependencies_satisfied BOOLEAN,
+  retry_eligible BOOLEAN,
+  ready_for_execution BOOLEAN,
+  last_failure_at TIMESTAMP,
+  next_retry_at TIMESTAMP,
+  total_parents INTEGER,
+  completed_parents INTEGER,
+  attempts INTEGER,
+  retry_limit INTEGER,
+  backoff_request_seconds INTEGER,
+  last_attempted_at TIMESTAMP
+) LANGUAGE plpgsql STABLE AS $$
+BEGIN
+  RETURN QUERY
+  SELECT
+    ws.workflow_step_id,
+    ws.task_id,
+    ws.named_step_id,
+    ns.name::TEXT,
+
+    -- Current State Information (optimized using most_recent flag)
+    COALESCE(current_state.to_state, 'pending')::TEXT as current_state,
+
+    -- Dependency Analysis (calculated from direct joins)
+    CASE
+      WHEN dep_edges.to_step_id IS NULL THEN true  -- Root steps (no parents)
+      WHEN COUNT(dep_edges.from_step_id) = 0 THEN true  -- Steps with zero dependencies
+      WHEN COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id) THEN true
+      ELSE false
+    END as dependencies_satisfied,
+
+    -- Simplified Retry & Backoff Analysis
+    CASE
+      WHEN ws.attempts >= COALESCE(ws.retry_limit, 3) THEN false
+      WHEN ws.attempts > 0 AND COALESCE(ws.retryable, true) = false THEN false
+      WHEN last_failure.created_at IS NULL THEN true
+      WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+        ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second') <= NOW()
+      WHEN last_failure.created_at IS NOT NULL THEN
+        last_failure.created_at + (
+          LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds')
+        ) <= NOW()
+      ELSE true
+    END as retry_eligible,
+
+    -- Simplified Final Readiness Calculation
+    CASE
+      WHEN COALESCE(current_state.to_state, 'pending') IN ('pending', 'error')
+      AND (ws.processed = false OR ws.processed IS NULL)  -- CRITICAL: Only unprocessed steps can be ready
+      AND (dep_edges.to_step_id IS NULL OR
+           COUNT(dep_edges.from_step_id) = 0 OR
+           COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id))
+      AND (ws.attempts < COALESCE(ws.retry_limit, 3))
+      AND (COALESCE(ws.retryable, true) = true)
+      AND (ws.in_process = false OR ws.in_process IS NULL)
+      AND (
+        -- Check explicit backoff timing (most restrictive)
+        -- If backoff is set, the backoff period must have expired
+        CASE
+          WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+            ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second') <= NOW()
+          ELSE true  -- No explicit backoff set
+        END
+        AND
+        -- Then check failure-based backoff
+        (last_failure.created_at IS NULL OR
+         last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds')) <= NOW())
+      )
+      THEN true
+      ELSE false
+    END as ready_for_execution,
+
+    -- Timing Information
+    last_failure.created_at as last_failure_at,
+    CASE
+      WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
+        ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second')
+      WHEN last_failure.created_at IS NOT NULL THEN
+        last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds'))
+      ELSE NULL
+    END as next_retry_at,
+
+    -- Dependency Context (calculated from joins)
+    COALESCE(COUNT(dep_edges.from_step_id), 0)::INTEGER as total_parents,
+    COALESCE(COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END), 0)::INTEGER as completed_parents,
+
+    -- Retry Context
+    ws.attempts,
+    COALESCE(ws.retry_limit, 3) as retry_limit,
+    ws.backoff_request_seconds,
+    ws.last_attempted_at
+
+  FROM tasker_workflow_steps ws
+  JOIN tasker_named_steps ns ON ns.named_step_id = ws.named_step_id
+
+  -- OPTIMIZED: Current State using most_recent flag instead of DISTINCT ON
+  LEFT JOIN tasker_workflow_step_transitions current_state
+    ON current_state.workflow_step_id = ws.workflow_step_id
+    AND current_state.most_recent = true
+
+  -- OPTIMIZED: Dependency check using direct joins (no subquery)
+  LEFT JOIN tasker_workflow_step_edges dep_edges
+    ON dep_edges.to_step_id = ws.workflow_step_id
+  LEFT JOIN tasker_workflow_step_transitions parent_states
+    ON parent_states.workflow_step_id = dep_edges.from_step_id
+    AND parent_states.most_recent = true
+
+  -- OPTIMIZED: Last failure using index-optimized approach
+  LEFT JOIN tasker_workflow_step_transitions last_failure
+    ON last_failure.workflow_step_id = ws.workflow_step_id
+    AND last_failure.to_state = 'error'
+    AND last_failure.most_recent = true
+
+  -- KEY PERFORMANCE IMPROVEMENT: Filter by task first, then optionally by step IDs
+  -- CRITICAL FIX: Include ALL steps for task execution context calculation
+  -- Only filter by processed status when specifically querying for ready steps
+  WHERE ws.task_id = input_task_id
+    AND (step_ids IS NULL OR ws.workflow_step_id = ANY(step_ids))
+
+  GROUP BY
+    ws.workflow_step_id, ws.task_id, ws.named_step_id, ns.name,
+    current_state.to_state, last_failure.created_at,
+    ws.attempts, ws.retry_limit, ws.backoff_request_seconds, ws.last_attempted_at,
+    ws.in_process, ws.processed, ws.retryable, dep_edges.to_step_id,
+    current_state.workflow_step_id, last_failure.workflow_step_id;
+END;
+$$;