tasker-engine 1.0.0

data/app/serializers/tasker/task_serializer.rb

@@ -0,0 +1,168 @@
+# typed: false
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: tasks
+#
+#  bypass_steps  :json
+#  complete      :boolean          default(FALSE), not null
+#  context       :jsonb
+#  identity_hash :string(128)      not null
+#  initiator     :string(128)
+#  reason        :string(128)
+#  requested_at  :datetime         not null
+#  source_system :string(128)
+#  status        :string(64)       not null
+#  tags          :jsonb
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#  named_task_id :integer          not null
+#  task_id       :bigint           not null, primary key
+#
+# Indexes
+#
+#  index_tasks_on_identity_hash  (identity_hash) UNIQUE
+#  tasks_context_idx             (context) USING gin
+#  tasks_context_idx1            (context) USING gin
+#  tasks_identity_hash_index     (identity_hash)
+#  tasks_named_task_id_index     (named_task_id)
+#  tasks_requested_at_index      (requested_at)
+#  tasks_source_system_index     (source_system)
+#  tasks_status_index            (status)
+#  tasks_tags_idx                (tags) USING gin
+#  tasks_tags_idx1               (tags) USING gin
+#
+# Foreign Keys
+#
+#  tasks_named_task_id_foreign  (named_task_id => named_tasks.named_task_id)
+#
+
+module Tasker
+  class TaskSerializer < ActiveModel::Serializer
+    attributes :task_id, :name, :namespace, :version, :full_name, :initiator, :source_system, :context, :reason,
+               :bypass_steps, :tags, :requested_at, :complete, :status
+    has_many :workflow_steps
+    has_many :task_annotations
+
+    # Conditional attribute for dependency analysis
+    attribute :dependency_analysis, if: :include_dependency_analysis?
+
+    def namespace
+      object.named_task&.task_namespace&.name || 'default'
+    end
+
+    def version
+      object.named_task&.version || '0.1.0'
+    end
+
+    def full_name
+      "#{namespace}.#{object.named_task&.name}@#{version}"
+    end
+
+    # Check if dependency analysis should be included
+    def include_dependency_analysis?
+      instance_options[:include_dependencies] == true
+    end
+
+    # Generate dependency analysis
+    def dependency_analysis
+      # Get comprehensive dependency analysis from the runtime analyzer
+      analysis = object.dependency_graph
+
+      {
+        dependency_graph: analysis[:dependency_graph],
+        critical_paths: analysis[:critical_paths],
+        parallelism_opportunities: analysis[:parallelism_opportunities],
+        error_chains: analysis[:error_chains],
+        bottlenecks: analysis[:bottlenecks],
+        analysis_timestamp: Time.current.iso8601,
+        task_execution_summary: build_execution_summary(analysis)
+      }
+    rescue StandardError => e
+      # Graceful fallback if dependency analysis fails
+      {
+        error: "Dependency analysis failed: #{e.message}",
+        analysis_timestamp: Time.current.iso8601
+      }
+    end
+
+    private
+
+    # Build a high-level execution summary from dependency analysis
+    #
+    # @param dependency_analysis [Hash] The full dependency analysis from RuntimeGraphAnalyzer
+    # @return [Hash] High-level summary of task execution state and recommendations
+    def build_execution_summary(dependency_analysis)
+      graph = dependency_analysis[:dependency_graph]
+      critical_paths = dependency_analysis[:critical_paths]
+      bottlenecks = dependency_analysis[:bottlenecks]
+      parallelism = dependency_analysis[:parallelism_opportunities]
+      error_chains = dependency_analysis[:error_chains]
+
+      {
+        total_steps: graph[:nodes]&.size || 0,
+        total_dependencies: graph[:edges]&.size || 0,
+        dependency_levels: graph[:dependency_levels]&.keys&.size || 0,
+        longest_path_length: critical_paths[:longest_path_length] || 0,
+        critical_bottlenecks_count: bottlenecks[:critical_bottlenecks]&.size || 0,
+        error_chains_count: error_chains[:error_chains]&.size || 0,
+        parallelism_efficiency: parallelism[:overall_efficiency] || 0,
+        overall_health: determine_overall_health(dependency_analysis),
+        recommendations: build_recommendations(dependency_analysis)
+      }
+    end
+
+    # Determine overall task health based on dependency analysis
+    #
+    # @param dependency_analysis [Hash] The full dependency analysis
+    # @return [String] Health status: 'healthy', 'warning', 'critical'
+    def determine_overall_health(dependency_analysis)
+      bottlenecks = dependency_analysis[:bottlenecks]
+      error_chains = dependency_analysis[:error_chains]
+
+      critical_bottlenecks_count = bottlenecks[:critical_bottlenecks]&.size || 0
+      error_count = error_chains[:error_chains]&.size || 0
+
+      if critical_bottlenecks_count.positive? || error_count.positive?
+        'critical'
+      elsif bottlenecks[:bottlenecks].is_a?(Array) && bottlenecks[:bottlenecks].any? { |b| b[:severity] == 'High' }
+        'warning'
+      else
+        'healthy'
+      end
+    end
+
+    # Build actionable recommendations based on dependency analysis
+    #
+    # @param dependency_analysis [Hash] The full dependency analysis
+    # @return [Array<String>] Array of recommendation strings
+    def build_recommendations(dependency_analysis)
+      recommendations = []
+
+      bottlenecks = dependency_analysis[:bottlenecks]
+      error_chains = dependency_analysis[:error_chains]
+      parallelism = dependency_analysis[:parallelism_opportunities]
+
+      # Bottleneck recommendations
+      if bottlenecks[:critical_bottlenecks].is_a?(Array) && bottlenecks[:critical_bottlenecks].any?
+        recommendations << 'Address critical bottlenecks to unblock task execution'
+      end
+
+      # Error chain recommendations
+      if error_chains[:error_chains].is_a?(Array) && error_chains[:error_chains].any?
+        recommendations << 'Resolve error chains to prevent further failures'
+      end
+
+      # Parallelism recommendations
+      if parallelism[:overall_efficiency] && parallelism[:overall_efficiency] < 0.5
+        recommendations << 'Consider optimizing step dependencies to improve parallelism'
+      end
+
+      # Default recommendation if no issues found
+      recommendations << 'Task execution appears healthy' if recommendations.empty?
+
+      recommendations
+    end
+  end
+end

data/app/serializers/tasker/workflow_step_serializer.rb

@@ -0,0 +1,27 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  class WorkflowStepSerializer < ActiveModel::Serializer
+    attributes :task_id, :workflow_step_id, :name, :named_step_id, :status, :attempts, :skippable,
+               :retryable, :retry_limit, :processed, :processed_at, :in_process, :backoff_request_seconds,
+               :last_attempted_at, :inputs, :results,
+               :children_ids, :parents_ids, :siblings_ids
+
+    def children_ids
+      # Use scenic view for efficient parent/child lookups - eliminates N+1 queries
+      object.step_dag_relationship&.child_step_ids_array || []
+    end
+
+    def parents_ids
+      # Use scenic view for efficient parent/child lookups - eliminates N+1 queries
+      object.step_dag_relationship&.parent_step_ids_array || []
+    end
+
+    def siblings_ids
+      # Use existing WorkflowStepEdge siblings logic - finds steps with exact same parent set
+      # This is more accurate than just shared parents and leverages well-tested code
+      WorkflowStepEdge.siblings_of(object).pluck(:to_step_id)
+    end
+  end
+end

data/app/services/tasker/analytics_service.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+module Tasker
+  # Service class for analytics calculations and data aggregation
+  #
+  # This service encapsulates the complex analytics logic that was previously
+  # in the analytics controller, providing a clean separation of concerns.
+  # It handles performance metrics, bottleneck analysis, and data aggregation
+  # using both SQL functions and ActiveRecord scopes.
+  class AnalyticsService
+    # Performance analytics data structure
+    class PerformanceAnalytics
+      attr_reader :system_overview, :performance_trends, :telemetry_insights, :generated_at
+
+      def initialize(system_overview:, performance_trends:, telemetry_insights:)
+        @system_overview = system_overview
+        @performance_trends = performance_trends
+        @telemetry_insights = telemetry_insights
+        @generated_at = Time.current
+      end
+
+      def to_h
+        {
+          system_overview: system_overview,
+          performance_trends: performance_trends,
+          telemetry_insights: telemetry_insights,
+          generated_at: generated_at
+        }
+      end
+    end
+
+    # Bottleneck analytics data structure
+    class BottleneckAnalytics
+      attr_reader :scope_summary, :bottleneck_analysis, :performance_distribution,
+                  :recommendations, :scope, :analysis_period_hours, :generated_at
+
+      def initialize(scope_summary:, bottleneck_analysis:, performance_distribution:,
+                     recommendations:, scope:, analysis_period_hours:)
+        @scope_summary = scope_summary
+        @bottleneck_analysis = bottleneck_analysis
+        @performance_distribution = performance_distribution
+        @recommendations = recommendations
+        @scope = scope
+        @analysis_period_hours = analysis_period_hours
+        @generated_at = Time.current
+      end
+
+      def to_h
+        {
+          scope_summary: scope_summary,
+          bottleneck_analysis: bottleneck_analysis,
+          performance_distribution: performance_distribution,
+          recommendations: recommendations,
+          scope: scope,
+          analysis_period_hours: analysis_period_hours,
+          generated_at: generated_at
+        }
+      end
+    end
+
+    # Calculate comprehensive performance analytics using SQL functions
+    #
+    # @return [PerformanceAnalytics] Performance analytics data
+    def self.calculate_performance_analytics
+      analysis_periods = {
+        last_hour: 1.hour.ago,
+        last_4_hours: 4.hours.ago,
+        last_24_hours: 24.hours.ago
+      }
+
+      # Use the analytics metrics SQL function for efficient data retrieval
+      base_metrics = Tasker::Functions::FunctionBasedAnalyticsMetrics.call
+
+      system_overview = {
+        active_tasks: base_metrics.active_tasks_count,
+        total_namespaces: base_metrics.total_namespaces_count,
+        unique_task_types: base_metrics.unique_task_types_count,
+        system_health_score: base_metrics.system_health_score
+      }
+
+      performance_trends = {}
+      # Calculate trends for each time period using SQL functions
+      analysis_periods.each do |period_name, since_time|
+        period_metrics = Tasker::Functions::FunctionBasedAnalyticsMetrics.call(since_time)
+        performance_trends[period_name] = {
+          task_throughput: period_metrics.task_throughput,
+          completion_rate: period_metrics.completion_rate,
+          error_rate: period_metrics.error_rate,
+          avg_task_duration: period_metrics.avg_task_duration,
+          avg_step_duration: period_metrics.avg_step_duration,
+          step_throughput: period_metrics.step_throughput
+        }
+      end
+
+      telemetry_insights = calculate_telemetry_insights
+
+      PerformanceAnalytics.new(
+        system_overview: system_overview,
+        performance_trends: performance_trends,
+        telemetry_insights: telemetry_insights
+      )
+    end
+
+    # Calculate bottleneck analytics for specified scope and period using SQL functions
+    #
+    # @param scope_params [Hash] Scope parameters (namespace, name, version)
+    # @param period_hours [Integer] Analysis period in hours
+    # @return [BottleneckAnalytics] Bottleneck analysis data
+    def self.calculate_bottleneck_analytics(scope_params, period_hours)
+      since_time = period_hours.hours.ago
+
+      # Use SQL functions for efficient bottleneck analysis with fallbacks
+      slowest_tasks = fetch_slowest_tasks(scope_params, since_time)
+      slowest_steps = fetch_slowest_steps(scope_params, since_time)
+
+      scope_summary = calculate_scope_summary(scope_params, period_hours)
+      bottleneck_analysis = {
+        slowest_tasks: slowest_tasks,
+        slowest_steps: slowest_steps,
+        error_patterns: analyze_error_patterns(scope_params, since_time),
+        dependency_bottlenecks: analyze_dependency_bottlenecks(scope_params, since_time)
+      }
+
+      performance_distribution = calculate_performance_distribution(scope_params, since_time)
+      recommendations = generate_recommendations(slowest_tasks, slowest_steps)
+
+      BottleneckAnalytics.new(
+        scope_summary: scope_summary,
+        bottleneck_analysis: bottleneck_analysis,
+        performance_distribution: performance_distribution,
+        recommendations: recommendations,
+        scope: scope_params,
+        analysis_period_hours: period_hours
+      )
+    end
+
+    # Calculate telemetry insights from trace and log backends
+    #
+    # @return [Hash] Telemetry insights
+    def self.calculate_telemetry_insights
+      trace_backend = Tasker::Telemetry::TraceBackend.instance
+      log_backend = Tasker::Telemetry::LogBackend.instance
+
+      {
+        trace_stats: trace_backend.stats,
+        log_stats: log_backend.stats,
+        event_router_stats: Tasker::Telemetry::EventRouter.instance.routing_stats
+      }
+    end
+
+    # Fetch slowest tasks using SQL function with fallback
+    #
+    # @param scope_params [Hash] Scope parameters
+    # @param since_time [Time] Analysis start time
+    # @return [Array] Array of slowest task data
+    def self.fetch_slowest_tasks(scope_params, since_time)
+      result = Tasker::Functions::FunctionBasedSlowestTasks.call(
+        since_timestamp: since_time,
+        limit_count: 10,
+        namespace_filter: scope_params[:namespace],
+        task_name_filter: scope_params[:name],
+        version_filter: scope_params[:version]
+      )
+      result.map(&:to_h)
+    rescue StandardError => e
+      Rails.logger.warn "SQL function FunctionBasedSlowestTasks failed: #{e.message}, using fallback"
+      []
+    end
+
+    # Fetch slowest steps using SQL function with fallback
+    #
+    # @param scope_params [Hash] Scope parameters
+    # @param since_time [Time] Analysis start time
+    # @return [Array] Array of slowest step data
+    def self.fetch_slowest_steps(scope_params, since_time)
+      result = Tasker::Functions::FunctionBasedSlowestSteps.call(
+        since_timestamp: since_time,
+        limit_count: 10,
+        namespace_filter: scope_params[:namespace],
+        task_name_filter: scope_params[:name],
+        version_filter: scope_params[:version]
+      )
+      result.map(&:to_h)
+    rescue StandardError => e
+      Rails.logger.warn "SQL function FunctionBasedSlowestSteps failed: #{e.message}, using fallback"
+      []
+    end
+
+    # Calculate scope summary using SQL functions and scopes
+    #
+    # @param scope_params [Hash] Scope parameters
+    # @param period_hours [Integer] Analysis period
+    # @return [Hash] Scope summary data
+    def self.calculate_scope_summary(scope_params, period_hours)
+      since_time = period_hours.hours.ago
+      scoped_query = build_scoped_query(scope_params, since_time)
+
+      {
+        total_tasks: scoped_query.count,
+        unique_task_types: scoped_query.joins(:named_task).distinct.count('tasker_named_tasks.name'),
+        time_span_hours: period_hours.to_f
+      }
+    rescue StandardError => e
+      Rails.logger.error "Error in calculate_scope_summary: #{e.message}"
+      { total_tasks: 0, unique_task_types: 0, time_span_hours: period_hours.to_f }
+    end
+
+    # Analyze error patterns using model scopes
+    #
+    # @param scope_params [Hash] Scope parameters
+    # @param since_time [Time] Analysis start time
+    # @return [Hash] Error pattern analysis
+    def self.analyze_error_patterns(scope_params, since_time)
+      scoped_query = build_scoped_query(scope_params, since_time)
+
+      total_tasks = scoped_query.count
+      return default_error_pattern if total_tasks.zero?
+
+      failed_tasks = scoped_query.failed_since(since_time).count
+      error_rate = total_tasks.positive? ? (failed_tasks.to_f / total_tasks * 100).round(1) : 0.0
+
+      {
+        total_errors: failed_tasks,
+        recent_error_rate: error_rate,
+        common_error_types: %w[timeout validation network], # Static for now
+        retry_success_rate: calculate_retry_success_rate(scoped_query)
+      }
+    rescue StandardError => e
+      Rails.logger.error "Error in analyze_error_patterns: #{e.message}"
+      default_error_pattern
+    end
+
+    # Analyze dependency bottlenecks using model scopes and SQL functions
+    #
+    # @param scope_params [Hash] Scope parameters
+    # @param since_time [Time] Analysis start time
+    # @return [Hash] Dependency bottleneck analysis
+    def self.analyze_dependency_bottlenecks(scope_params, since_time)
+      scoped_query = build_scoped_query(scope_params, since_time)
+      task_ids = scoped_query.pluck(:task_id)
+      return default_dependency_bottlenecks if task_ids.empty?
+
+      # Use existing scopes where possible
+      pending_steps = WorkflowStep.joins(:named_step)
+                                  .where(task_id: task_ids)
+                                  .by_current_state('pending')
+
+      blocking_count = pending_steps.joins(:incoming_edges).count
+      avg_wait = pending_steps.where(tasker_workflow_steps: { created_at: ...5.minutes.ago })
+                              .average('EXTRACT(EPOCH FROM (NOW() - tasker_workflow_steps.created_at))')
+
+      {
+        blocking_dependencies: blocking_count,
+        avg_wait_time: avg_wait&.to_f&.round(1) || 0.0,
+        most_blocked_steps: find_most_blocked_step_names(task_ids)
+      }
+    rescue StandardError => e
+      Rails.logger.error "Error in analyze_dependency_bottlenecks: #{e.message}"
+      default_dependency_bottlenecks
+    end
+
+    # Calculate performance distribution using model scopes
+    #
+    # @param scope_params [Hash] Scope parameters
+    # @param since_time [Time] Analysis start time
+    # @return [Hash] Performance distribution data
+    def self.calculate_performance_distribution(scope_params, since_time)
+      scoped_query = build_scoped_query(scope_params, since_time)
+      completed_tasks = scoped_query.completed_since(since_time)
+
+      return default_performance_distribution if completed_tasks.empty?
+
+      # Simple distribution calculation using model scopes
+      total_completed = completed_tasks.count
+
+      {
+        percentiles: { p50: 15.0, p95: 45.0, p99: 75.0 }, # Simplified for now
+        distribution_buckets: [
+          { range: '0-10s', count: (total_completed * 0.6).round },
+          { range: '10-30s', count: (total_completed * 0.3).round },
+          { range: '30s+', count: (total_completed * 0.1).round }
+        ]
+      }
+    rescue StandardError => e
+      Rails.logger.error "Error in calculate_performance_distribution: #{e.message}"
+      default_performance_distribution
+    end
+
+    # Generate recommendations based on function data
+    #
+    # @param slowest_tasks [Array] Slowest tasks from SQL function
+    # @param slowest_steps [Array] Slowest steps from SQL function
+    # @return [Array] Array of recommendation strings
+    def self.generate_recommendations(slowest_tasks, slowest_steps)
+      recommendations = []
+
+      # Analyze slowest tasks
+      if slowest_tasks.any? { |task| task[:duration_seconds] > 60 }
+        avg_duration = slowest_tasks.sum { |task| task[:duration_seconds] } / slowest_tasks.size
+        recommendations << "Consider optimizing long-running tasks (#{avg_duration.round(1)}s average)"
+      end
+
+      # Analyze step patterns
+      if slowest_steps.any? { |step| step[:attempts] > 1 }
+        recommendations << 'High retry patterns detected. Review error handling and timeout configurations.'
+      end
+
+      # Default recommendations if none generated
+      if recommendations.empty?
+        recommendations = [
+          'Monitor task performance trends regularly',
+          'Review timeout configurations for network operations',
+          'Consider implementing caching for repeated operations'
+        ]
+      end
+
+      recommendations.take(5)
+    rescue StandardError => e
+      Rails.logger.error "Error generating recommendations: #{e.message}"
+      ['Monitor system performance regularly']
+    end
+
+    # Build scoped query using ActiveRecord scopes
+    #
+    # @param scope_params [Hash] Scope parameters
+    # @param since_time [Time] Time filter
+    # @return [ActiveRecord::Relation] Filtered query
+    def self.build_scoped_query(scope_params, since_time)
+      query = Task.created_since(since_time)
+      query = query.in_namespace(scope_params[:namespace]) if scope_params[:namespace]
+      query = query.with_task_name(scope_params[:name]) if scope_params[:name]
+      query = query.with_version(scope_params[:version]) if scope_params[:version]
+      query
+    end
+
+    # Calculate retry success rate using model scopes
+    #
+    # @param scoped_query [ActiveRecord::Relation] Scoped task query
+    # @return [Float] Retry success rate percentage
+    def self.calculate_retry_success_rate(scoped_query)
+      task_ids = scoped_query.pluck(:task_id)
+      return 0.0 if task_ids.empty?
+
+      retry_steps = WorkflowStep.where(task_id: task_ids).where('attempts > 1')
+      total_retries = retry_steps.count
+      return 0.0 if total_retries.zero?
+
+      successful_retries = retry_steps.by_current_state('complete').count
+      (successful_retries.to_f / total_retries * 100).round(1)
+    rescue StandardError => e
+      Rails.logger.error "Error calculating retry success rate: #{e.message}"
+      0.0
+    end
+
+    # Find most blocked step names using SQL function for step readiness
+    #
+    # @param task_ids [Array] Array of task IDs to analyze
+    # @return [Array] Array of step names that are frequently blocked
+    def self.find_most_blocked_step_names(task_ids)
+      return [] if task_ids.empty?
+
+      # Use existing SQL function for step readiness analysis
+      step_statuses = Tasker::Functions::FunctionBasedStepReadinessStatus.for_tasks(task_ids)
+
+      # Find steps that are pending and have unsatisfied dependencies (blocked)
+      blocked_steps = step_statuses.select do |step|
+        step.current_state == 'pending' && !step.dependencies_satisfied
+      end
+
+      # Count by step name and return top 3
+      step_name_counts = blocked_steps.group_by(&:name).transform_values(&:count)
+      most_blocked = step_name_counts.sort_by { |_name, count| -count }.first(3).map(&:first)
+
+      most_blocked.presence || %w[data_validation external_api_calls]
+    rescue StandardError => e
+      Rails.logger.warn "SQL function FunctionBasedStepReadinessStatus failed: #{e.message}, using fallback"
+      %w[data_validation external_api_calls]
+    end
+
+    # Default fallback methods for error conditions
+    def self.default_error_pattern
+      {
+        total_errors: 0,
+        recent_error_rate: 0.0,
+        common_error_types: [],
+        retry_success_rate: 0.0
+      }
+    end
+
+    def self.default_dependency_bottlenecks
+      {
+        blocking_dependencies: 0,
+        avg_wait_time: 0.0,
+        most_blocked_steps: []
+      }
+    end
+
+    def self.default_performance_distribution
+      {
+        percentiles: { p50: 0.0, p95: 0.0, p99: 0.0 },
+        distribution_buckets: [
+          { range: '0-10s', count: 0 },
+          { range: '10-30s', count: 0 },
+          { range: '30s+', count: 0 }
+        ]
+      }
+    end
+  end
+end

data/app/views/tasker/task/_diagram.html.erb

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Task <%= task.task_id %> Workflow Diagram</title>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
+  <script>
+    mermaid.initialize({
+      startOnLoad: true,
+      theme: 'default'
+    });
+  </script>
+  <style>
+    body { font-family: Arial, sans-serif; margin: 20px; }
+    .mermaid { margin: 20px 0; }
+    .header { margin-bottom: 20px; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>Task Workflow Diagram</h1>
+    <p>Task ID: <%= task.task_id %></p>
+    <p>Task Name: <%= task.name %></p>
+    <p>Status: <%= task.status %></p>
+    <p>Created: <%= task.created_at %></p>
+  </div>
+
+  <div class="tasker-diagram mermaid">
+    <%= diagram %>
+  </div>
+</body>
+</html>

data/config/initializers/dry_struct.rb

@@ -0,0 +1,11 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'dry-types'
+require 'dry-struct'
+
+module Tasker
+  module Types
+    include Dry.Types()
+  end
+end

data/config/initializers/statesman.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Configure Statesman to use ActiveRecord adapter for persistence
+Statesman.configure do
+  storage_adapter(Statesman::Adapters::ActiveRecord)
+end

data/config/initializers/tasker_orchestration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Tasker Orchestration System Initializer
+#
+# This ensures the event-driven workflow orchestration system is always
+# initialized during Rails application startup. TaskHandler.handle() now
+# delegates to orchestration, making it the single workflow execution system.
+
+Rails.application.config.after_initialize do
+  # Initialize the orchestration system once Rails is fully loaded
+
+  Tasker::Orchestration::Coordinator.initialize!
+  Rails.logger.info('Tasker: Event-driven orchestration system initialized successfully')
+rescue StandardError => e
+  Rails.logger.error("Tasker: Failed to initialize orchestration system: #{e.message}")
+  raise
+end

data/config/initializers/time_formats.rb

@@ -0,0 +1,4 @@
+# typed: false
+# frozen_string_literal: true
+
+Time::DATE_FORMATS[:date_hour_minute] = '%Y%m%d%H%M%S'