tasker-engine 1.0.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_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;
+$$;

data/db/functions/get_system_health_counts_v01.sql

@@ -0,0 +1,108 @@
+-- System Health Counts Function
+-- Returns comprehensive system health metrics in a single query
+-- No input parameters needed - returns system-wide counts
+-- Output: Single row with all health counts and metrics
+
+CREATE OR REPLACE FUNCTION get_system_health_counts_v01()
+RETURNS TABLE (
+    -- Task counts
+    total_tasks BIGINT,
+    pending_tasks BIGINT,
+    in_progress_tasks BIGINT,
+    complete_tasks BIGINT,
+    error_tasks BIGINT,
+    cancelled_tasks BIGINT,
+
+    -- Step counts
+    total_steps BIGINT,
+    pending_steps BIGINT,
+    in_progress_steps BIGINT,
+    complete_steps BIGINT,
+    error_steps BIGINT,
+
+    -- Retry-specific counts
+    retryable_error_steps BIGINT,
+    exhausted_retry_steps BIGINT,
+    in_backoff_steps BIGINT,
+
+    -- Database metrics
+    active_connections BIGINT,
+    max_connections BIGINT
+) LANGUAGE plpgsql STABLE AS $$
+BEGIN
+    RETURN QUERY
+    WITH task_counts AS (
+        SELECT
+            COUNT(*) as total_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'pending') as pending_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'in_progress') as in_progress_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'complete') as complete_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'error') as error_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'cancelled') as cancelled_tasks
+        FROM tasker_tasks t
+        LEFT JOIN tasker_task_transitions task_state ON task_state.task_id = t.task_id
+            AND task_state.most_recent = true
+    ),
+    step_counts AS (
+        SELECT
+            COUNT(*) as total_steps,
+            COUNT(*) FILTER (WHERE step_state.to_state = 'pending') as pending_steps,
+            COUNT(*) FILTER (WHERE step_state.to_state = 'in_progress') as in_progress_steps,
+            COUNT(*) FILTER (WHERE step_state.to_state = 'complete') as complete_steps,
+            COUNT(*) FILTER (WHERE step_state.to_state = 'error') as error_steps,
+
+            -- Retry-specific logic - retryable errors
+            COUNT(*) FILTER (
+                WHERE step_state.to_state = 'error'
+                AND ws.attempts < ws.retry_limit
+                AND COALESCE(ws.retryable, true) = true
+            ) as retryable_error_steps,
+
+            -- Exhausted retries
+            COUNT(*) FILTER (
+                WHERE step_state.to_state = 'error'
+                AND ws.attempts >= ws.retry_limit
+            ) as exhausted_retry_steps,
+
+            -- In backoff (error state but not exhausted retries and has last_attempted_at)
+            COUNT(*) FILTER (
+                WHERE step_state.to_state = 'error'
+                AND ws.attempts < ws.retry_limit
+                AND COALESCE(ws.retryable, true) = true
+                AND ws.last_attempted_at IS NOT NULL
+            ) as in_backoff_steps
+
+        FROM tasker_workflow_steps ws
+        LEFT JOIN tasker_workflow_step_transitions step_state ON step_state.workflow_step_id = ws.workflow_step_id
+            AND step_state.most_recent = true
+    ),
+    connection_info AS (
+        SELECT
+            COUNT(*) as active_connections,
+            COALESCE((SELECT setting::BIGINT FROM pg_settings WHERE name = 'max_connections'), 0) as max_connections
+        FROM pg_stat_activity
+        WHERE datname = current_database()
+            AND state = 'active'
+    )
+    SELECT
+        tc.total_tasks,
+        tc.pending_tasks,
+        tc.in_progress_tasks,
+        tc.complete_tasks,
+        tc.error_tasks,
+        tc.cancelled_tasks,
+        sc.total_steps,
+        sc.pending_steps,
+        sc.in_progress_steps,
+        sc.complete_steps,
+        sc.error_steps,
+        sc.retryable_error_steps,
+        sc.exhausted_retry_steps,
+        sc.in_backoff_steps,
+        ci.active_connections,
+        ci.max_connections
+    FROM task_counts tc
+    CROSS JOIN step_counts sc
+    CROSS JOIN connection_info ci;
+END;
+$$;

data/db/functions/get_task_execution_context_v01.sql

@@ -0,0 +1,108 @@
+-- Task Execution Context Function
+-- Uses the step readiness function to build aggregated task context
+-- Input: Single task_id
+-- Output: Single row with task execution context
+
+CREATE OR REPLACE FUNCTION get_task_execution_context(input_task_id BIGINT)
+RETURNS TABLE(
+  task_id BIGINT,
+  named_task_id INTEGER,
+  status TEXT,
+  total_steps BIGINT,
+  pending_steps BIGINT,
+  in_progress_steps BIGINT,
+  completed_steps BIGINT,
+  failed_steps BIGINT,
+  ready_steps BIGINT,
+  execution_status TEXT,
+  recommended_action TEXT,
+  completion_percentage DECIMAL,
+  health_status TEXT
+) LANGUAGE plpgsql STABLE AS $$
+BEGIN
+  -- Use the step readiness function to get step data, then aggregate
+  -- The step readiness function handles the case where no steps exist
+  RETURN QUERY
+  WITH step_data AS (
+    SELECT * FROM get_step_readiness_status(input_task_id, NULL)
+  ),
+  task_info AS (
+    SELECT
+      t.task_id,
+      t.named_task_id,
+      COALESCE(task_state.to_state, 'pending')::TEXT as current_status
+    FROM tasker_tasks t
+    LEFT JOIN tasker_task_transitions task_state
+      ON task_state.task_id = t.task_id
+      AND task_state.most_recent = true
+    WHERE t.task_id = input_task_id
+  ),
+  aggregated_stats AS (
+    SELECT
+      COUNT(*) as total_steps,
+      COUNT(CASE WHEN sd.current_state = 'pending' THEN 1 END) as pending_steps,
+      COUNT(CASE WHEN sd.current_state = 'in_progress' THEN 1 END) as in_progress_steps,
+      COUNT(CASE WHEN sd.current_state IN ('complete', 'resolved_manually') THEN 1 END) as completed_steps,
+      COUNT(CASE WHEN sd.current_state = 'error' THEN 1 END) as failed_steps,
+      COUNT(CASE WHEN sd.ready_for_execution = true THEN 1 END) as ready_steps,
+      -- Count PERMANENTLY blocked failures (exhausted retries OR explicitly marked as not retryable)
+      COUNT(CASE WHEN sd.current_state = 'error'
+                  AND (sd.attempts >= sd.retry_limit) THEN 1 END) as permanently_blocked_steps
+    FROM step_data sd
+  )
+  SELECT
+    ti.task_id,
+    ti.named_task_id,
+    ti.current_status as status,
+
+    -- Step Statistics
+    COALESCE(ast.total_steps, 0) as total_steps,
+    COALESCE(ast.pending_steps, 0) as pending_steps,
+    COALESCE(ast.in_progress_steps, 0) as in_progress_steps,
+    COALESCE(ast.completed_steps, 0) as completed_steps,
+    COALESCE(ast.failed_steps, 0) as failed_steps,
+    COALESCE(ast.ready_steps, 0) as ready_steps,
+
+    -- FIXED: Execution State Logic
+    CASE
+      WHEN COALESCE(ast.ready_steps, 0) > 0 THEN 'has_ready_steps'
+      WHEN COALESCE(ast.in_progress_steps, 0) > 0 THEN 'processing'
+      -- OLD BUG: WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'blocked_by_failures'
+      -- NEW FIX: Only blocked if failed steps are NOT retry-eligible
+      WHEN COALESCE(ast.permanently_blocked_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'blocked_by_failures'
+      WHEN COALESCE(ast.completed_steps, 0) = COALESCE(ast.total_steps, 0) AND COALESCE(ast.total_steps, 0) > 0 THEN 'all_complete'
+      ELSE 'waiting_for_dependencies'
+    END as execution_status,
+
+    -- FIXED: Recommended Action Logic
+    CASE
+      WHEN COALESCE(ast.ready_steps, 0) > 0 THEN 'execute_ready_steps'
+      WHEN COALESCE(ast.in_progress_steps, 0) > 0 THEN 'wait_for_completion'
+      -- OLD BUG: WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'handle_failures'
+      -- NEW FIX: Only handle failures if they're truly blocked
+      WHEN COALESCE(ast.permanently_blocked_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'handle_failures'
+      WHEN COALESCE(ast.completed_steps, 0) = COALESCE(ast.total_steps, 0) AND COALESCE(ast.total_steps, 0) > 0 THEN 'finalize_task'
+      ELSE 'wait_for_dependencies'
+    END as recommended_action,
+
+    -- Progress Metrics
+    CASE
+      WHEN COALESCE(ast.total_steps, 0) = 0 THEN 0.0
+      ELSE ROUND((COALESCE(ast.completed_steps, 0)::decimal / COALESCE(ast.total_steps, 1)::decimal) * 100, 2)
+    END as completion_percentage,
+
+    -- FIXED: Health Status Logic
+    CASE
+      WHEN COALESCE(ast.failed_steps, 0) = 0 THEN 'healthy'
+      WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) > 0 THEN 'recovering'
+      -- NEW FIX: Only blocked if failures are truly not retry-eligible
+      WHEN COALESCE(ast.permanently_blocked_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'blocked'
+      -- NEW: Waiting state for retry-eligible failures with backoff
+      WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.permanently_blocked_steps, 0) = 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'recovering'
+      ELSE 'unknown'
+    END as health_status
+
+  FROM task_info ti
+  CROSS JOIN aggregated_stats ast;
+END;
+$$;