collavre 0.2.5 → 0.3.1

data/app/services/collavre/orchestration/stuck_detector.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+module Collavre
+  module Orchestration
+    # StuckDetector detects stuck tasks and creatives, then auto-escalates to admins.
+    #
+    # Detection conditions:
+    # 1. Running tasks that haven't progressed for N minutes
+    # 2. Tasks with too many retries (escalated but not handled)
+    # 3. Creatives with no progress for extended periods
+    #
+    # Auto-escalation:
+    # - Creates InboxItem for admin users
+    # - Optionally creates a system comment
+    #
+    class StuckDetector
+      # Result object for detection
+      Result = Struct.new(:stuck_items, :escalated_count, keyword_init: true)
+
+      # StuckItem represents a detected stuck item
+      StuckItem = Struct.new(:type, :item, :reason, :stuck_since, :escalation_targets, keyword_init: true)
+
+      def initialize(policy_resolver: nil)
+        @policy_resolver = policy_resolver || PolicyResolver.new({})
+      end
+
+      # Run detection, auto-recovery, and escalation
+      # Returns Result with stuck items and escalation count
+      def detect_and_escalate
+        config = stuck_detection_config
+        return Result.new(stuck_items: [], escalated_count: 0) unless config["enabled"]
+
+        stuck_items = []
+        stuck_items.concat(detect_stuck_tasks(config))
+        stuck_items.concat(detect_stalled_creatives(config))
+
+        auto_recover_stuck_tasks(stuck_items)
+        escalated_count = escalate_stuck_items(stuck_items, config)
+
+        Result.new(stuck_items: stuck_items, escalated_count: escalated_count)
+      end
+
+      # Detect only (no escalation)
+      def detect
+        config = stuck_detection_config
+        return [] unless config["enabled"]
+
+        stuck_items = []
+        stuck_items.concat(detect_stuck_tasks(config))
+        stuck_items.concat(detect_stalled_creatives(config))
+        stuck_items
+      end
+
+      private
+
+      # Auto-recover stuck tasks by marking them as failed and draining the queue.
+      def auto_recover_stuck_tasks(stuck_items)
+        stuck_items.each do |stuck_item|
+          next unless stuck_item.type == :task
+
+          task = stuck_item.item
+          next unless task.status == "running"
+
+          task.update!(status: "failed")
+          Rails.logger.info(
+            "[StuckDetector] Auto-recovered task #{task.id} (agent=#{task.agent_id}): " \
+            "marked as failed after #{((Time.current - stuck_item.stuck_since) / 60).round} minutes"
+          )
+
+          # Release resources held by the stuck task
+          if task.agent
+            tracker = ResourceTracker.for(task.agent)
+            tracker.release!(task.id)
+          end
+
+          # Drain the queue for the topic so waiting tasks can execute
+          AgentOrchestrator.dequeue_next_for_topic(task.topic_id)
+        rescue StandardError => e
+          Rails.logger.error("[StuckDetector] Auto-recovery failed for task #{task.id}: #{e.message}")
+        end
+      end
+
+      def stuck_detection_config
+        @policy_resolver.resolve("stuck_detection")
+      end
+
+      # Detect tasks that are stuck in running state
+      def detect_stuck_tasks(config)
+        threshold_minutes = config["task_stuck_threshold_minutes"] || 30
+        threshold_time = threshold_minutes.minutes.ago
+
+        stuck_tasks = Task.where(status: "running")
+                          .where("updated_at < ?", threshold_time)
+
+        stuck_tasks.filter_map do |task|
+          # Skip if already escalated recently
+          next if recently_escalated?(task)
+
+          escalation_targets = find_escalation_targets(task)
+          next if escalation_targets.empty?
+
+          StuckItem.new(
+            type: :task,
+            item: task,
+            reason: :no_progress,
+            stuck_since: task.updated_at,
+            escalation_targets: escalation_targets
+          )
+        end
+      end
+
+      # Detect creatives that have stalled (no activity for extended period)
+      def detect_stalled_creatives(config)
+        threshold_minutes = config["creative_stall_threshold_minutes"] || 120
+        threshold_time = threshold_minutes.minutes.ago
+
+        # Find creatives with incomplete status but no recent activity
+        # Only check creatives that have at least one AI agent with access
+        stalled = []
+
+        Creative.where("progress < 1.0")
+                .where("updated_at < ?", threshold_time)
+                .find_each do |creative|
+          # Skip if no AI agents have access
+          ai_agents = creative.creative_shares.joins(:user)
+                              .where(users: { llm_vendor: [ nil, "" ].map { |v| v } })
+                              .or(creative.creative_shares.joins(:user).where.not(users: { llm_vendor: nil }))
+                              .where.not(permission: "no_access")
+                              .map(&:user)
+                              .select(&:ai_user?)
+
+          next if ai_agents.empty?
+
+          # Skip if already escalated recently
+          next if recently_escalated_creative?(creative)
+
+          escalation_targets = find_creative_escalation_targets(creative)
+          next if escalation_targets.empty?
+
+          stalled << StuckItem.new(
+            type: :creative,
+            item: creative,
+            reason: :stalled,
+            stuck_since: creative.updated_at,
+            escalation_targets: escalation_targets
+          )
+        end
+
+        stalled
+      end
+
+      def find_escalation_targets(task)
+        # Find admin users for the task's creative
+        creative_id = task.trigger_event_payload&.dig("creative", "id")
+        return [] unless creative_id
+
+        creative = Creative.find_by(id: creative_id)
+        return [] unless creative
+
+        find_creative_escalation_targets(creative)
+      end
+
+      def find_creative_escalation_targets(creative)
+        # Find users with admin permission on the creative or its ancestors
+        admin_users = []
+
+        ([ creative ] + creative.ancestors.to_a).each do |c|
+          c.creative_shares.where(permission: "admin").includes(:user).each do |share|
+            admin_users << share.user unless share.user.ai_user?
+          end
+        end
+
+        # Also include the creative owner
+        admin_users << creative.user if creative.user && !creative.user.ai_user?
+
+        admin_users.uniq
+      end
+
+      def recently_escalated?(task)
+        # Check if we've already escalated this task in the last hour
+        cache_key = "stuck_detector:task:#{task.id}"
+        Rails.cache.exist?(cache_key)
+      end
+
+      def recently_escalated_creative?(creative)
+        cache_key = "stuck_detector:creative:#{creative.id}"
+        Rails.cache.exist?(cache_key)
+      end
+
+      def mark_escalated(item)
+        cache_key = case item.type
+        when :task then "stuck_detector:task:#{item.item.id}"
+        when :creative then "stuck_detector:creative:#{item.item.id}"
+        end
+        # Don't re-escalate for 1 hour
+        Rails.cache.write(cache_key, true, expires_in: 1.hour)
+      end
+
+      def escalate_stuck_items(stuck_items, config)
+        escalated_count = 0
+
+        stuck_items.each do |stuck_item|
+          escalated = escalate_item(stuck_item, config)
+          if escalated
+            mark_escalated(stuck_item)
+            escalated_count += 1
+          end
+        end
+
+        escalated_count
+      end
+
+      def escalate_item(stuck_item, config)
+        stuck_item.escalation_targets.each do |target|
+          create_inbox_notification(target, stuck_item)
+        end
+
+        # Optionally create a system comment
+        if config["create_system_comment"] && stuck_item.type == :task
+          create_system_comment(stuck_item)
+        end
+
+        true
+      rescue StandardError => e
+        Rails.logger.error("[StuckDetector] Failed to escalate: #{e.message}")
+        false
+      end
+
+      def create_inbox_notification(owner, stuck_item)
+        message_key, message_params = build_message(stuck_item)
+
+        creative = case stuck_item.type
+        when :task
+                     creative_id = stuck_item.item.trigger_event_payload&.dig("creative", "id")
+                     Creative.find_by(id: creative_id)
+        when :creative
+                     stuck_item.item
+        end
+
+        InboxItem.create!(
+          owner: owner,
+          message_key: message_key,
+          message_params: message_params,
+          creative: creative,
+          link: creative ? Collavre::Engine.routes.url_helpers.creative_path(creative) : nil
+        )
+      end
+
+      def build_message(stuck_item)
+        case stuck_item.type
+        when :task
+          task = stuck_item.item
+          minutes_stuck = ((Time.current - stuck_item.stuck_since) / 60).round
+
+          [
+            "collavre.stuck_detection.task_stuck",
+            {
+              task_name: task.name,
+              agent_name: task.agent&.display_name || "Unknown",
+              minutes: minutes_stuck
+            }
+          ]
+        when :creative
+          creative = stuck_item.item
+          hours_stuck = ((Time.current - stuck_item.stuck_since) / 3600).round
+
+          [
+            "collavre.stuck_detection.creative_stalled",
+            {
+              creative_title: creative.description&.truncate(50) || "Untitled",
+              hours: hours_stuck,
+              progress: ((creative.progress || 0) * 100).round
+            }
+          ]
+        end
+      end
+
+      def create_system_comment(stuck_item)
+        return unless stuck_item.type == :task
+
+        task = stuck_item.item
+        creative_id = task.trigger_event_payload&.dig("creative", "id")
+        creative = Creative.find_by(id: creative_id)
+        return unless creative
+
+        topic_id = task.topic_id
+
+        content = I18n.t(
+          "collavre.stuck_detection.system_comment",
+          task_name: task.name,
+          agent_name: task.agent&.display_name || "Unknown"
+        )
+
+        Comment.create!(
+          creative: creative,
+          content: content,
+          user: nil, # System comment
+          topic_id: topic_id
+        )
+      end
+    end
+  end
+end

data/app/services/collavre/system_events/context_builder.rb

@@ -14,22 +14,49 @@ module Collavre
           ctx["chat"]["mentioned_user"] ||= mentioned_user(ctx["chat"])
         end
 
+        # Add sender context for A2A communication
+        ctx["sender"] ||= build_sender_context(ctx)
+
         ctx
       end
 
       private
 
-      def mentioned_user(chat_context)
-        # This mimics the chat.mentioned_user function requested
-        # It assumes chat_context has 'content' or similar, or we might need to look up the comment
-        # For now, let's assume the context passed in already has the necessary info or we extract it.
-        # If the event is comment_created, the payload usually has the comment content.
+      def build_sender_context(ctx)
+        user_id = ctx.dig("comment", "user_id")
+        return nil unless user_id
+
+        user = User.find_by(id: user_id)
+        return nil unless user
+
+        {
+          "id" => user.id,
+          "name" => user.name,
+          "display_name" => user.respond_to?(:display_name) ? user.display_name : user.name,
+          "is_ai" => user.ai_user?,
+          "type" => user.ai_user? ? extract_agent_type(user) : "human"
+        }
+      end
 
+      def extract_agent_type(user)
+        prompt = user.system_prompt.to_s.downcase
+        case prompt
+        when /developer|개발/ then "developer"
+        when /pm|project.?manager|프로젝트/ then "pm"
+        when /qa|test|quality|테스트|품질/ then "qa"
+        when /research|조사|연구/ then "researcher"
+        when /market|마케팅/ then "marketer"
+        when /plan|기획/ then "planner"
+        else "agent"
+        end
+      end
+
+      def mentioned_user(chat_context)
         content = chat_context["content"]
         return nil unless content
 
-        # Simple regex to find the first mention
-        match = content.match(/\A@([^:]+?):\s*/) || content.match(/\A@(\S+)\s+/)
+        # Canonical mention format: @name: (with colon)
+        match = content.match(/\A@([^:]+?):\s*/)
         return nil unless match
 
         name = match[1].strip

data/app/services/collavre/system_events/dispatcher.rb

@@ -6,13 +6,8 @@ module Collavre
       end
 
       def dispatch(event_name, context)
-        # Build context once to ensure consistency between Router and Job
-        enriched_context = Collavre::SystemEvents::ContextBuilder.new(context).build
-        agents = Router.new.route(event_name, enriched_context)
-
-        agents.each do |agent|
-          AiAgentJob.perform_later(agent.id, event_name, enriched_context)
-        end
+        # Delegate to AgentOrchestrator for unified routing/scheduling
+        Orchestration::AgentOrchestrator.dispatch(event_name, context)
       end
     end
   end

data/app/services/collavre/tools/cron_cancel_service.rb

@@ -0,0 +1,49 @@
+module Collavre
+require "sorbet-runtime"
+require "rails_mcp_engine"
+module Tools
+  class CronCancelService
+    extend T::Sig
+    extend ToolMeta
+
+    tool_name "cron_cancel"
+    tool_description "Cancel (delete) a recurring scheduled job by its key. Only jobs for creatives you have write access to can be cancelled."
+
+    tool_param :key, description: "The unique key of the cron job to cancel (from cron_list).", required: true
+
+    sig { params(key: String).returns(T::Hash[Symbol, T.untyped]) }
+    def call(key:)
+      raise "Current.user is required" unless Current.user
+
+      task = SolidQueue::RecurringTask.find_by(key: key, static: false)
+      return { error: "Cron job not found", key: key } unless task
+
+      args = parse_arguments(task)
+      creative_id = args["creative_id"] || parse_creative_id_from_key(key)
+      creative = Creative.find_by(id: creative_id)
+
+      unless creative&.has_permission?(Current.user, :write)
+        return { error: "No write permission to cancel this cron job", key: key }
+      end
+
+      task.destroy!
+
+      { success: true, key: key, message: "Cron job cancelled successfully" }
+    end
+
+    private
+
+    def parse_arguments(task)
+      args = task.arguments
+      return {} unless args.is_a?(Array) && args.first.is_a?(Hash)
+
+      args.first.stringify_keys
+    end
+
+    def parse_creative_id_from_key(key)
+      match = key.match(/\Acron_(\d+)_/)
+      match[1].to_i if match
+    end
+  end
+end
+end

data/app/services/collavre/tools/cron_create_service.rb

@@ -0,0 +1,73 @@
+module Collavre
+require "sorbet-runtime"
+require "rails_mcp_engine"
+module Tools
+  class CronCreateService
+    extend T::Sig
+    extend ToolMeta
+
+    tool_name "cron_create"
+    tool_description "Create a new recurring scheduled job. The job will periodically post a message to a creative's topic, triggering agent orchestration. Schedule uses cron syntax (e.g., '*/5 * * * *' for every 5 minutes, '0 9 * * *' for daily at 9am)."
+
+    tool_param :creative_id, description: "The creative ID to post recurring messages to.", required: true
+    tool_param :topic_id, description: "The topic ID within the creative to post to.", required: true
+    tool_param :schedule, description: "Cron schedule expression (e.g., '0 9 * * *' for daily at 9am, '*/30 * * * *' for every 30 minutes).", required: true
+    tool_param :message, description: "The message content to post on each execution. This triggers the agent orchestration pipeline.", required: true
+    tool_param :description, description: "Human-readable description of what this cron job does.", required: false
+
+    sig do
+      params(
+        creative_id: Integer,
+        topic_id: Integer,
+        schedule: String,
+        message: String,
+        description: T.nilable(String)
+      ).returns(T::Hash[Symbol, T.untyped])
+    end
+    def call(creative_id:, topic_id:, schedule:, message:, description: nil)
+      raise "Current.user is required" unless Current.user
+
+      creative = Creative.find_by(id: creative_id)
+      return { error: "Creative not found", id: creative_id } unless creative
+      unless creative.has_permission?(Current.user, :write)
+        return { error: "No write permission on this Creative", id: creative_id }
+      end
+
+      topic = Topic.find_by(id: topic_id, creative_id: creative.effective_origin.id)
+      return { error: "Topic not found or does not belong to this creative", topic_id: topic_id } unless topic
+
+      parsed = Fugit.parse(schedule)
+      unless parsed.is_a?(Fugit::Cron)
+        return { error: "Invalid cron schedule: #{schedule}. Use cron syntax like '0 9 * * *'." }
+      end
+
+      suffix = SecureRandom.hex(4)
+      key = "cron_#{creative_id}_#{suffix}"
+
+      task = SolidQueue::RecurringTask.create!(
+        key: key,
+        class_name: "Collavre::CronActionJob",
+        schedule: schedule,
+        queue_name: "default",
+        static: false,
+        description: description || "Cron job for creative #{creative_id}",
+        arguments: [ {
+          creative_id: creative_id,
+          topic_id: topic_id,
+          agent_id: Current.user.id,
+          message: message
+        } ]
+      )
+
+      {
+        success: true,
+        key: task.key,
+        schedule: task.schedule,
+        description: task.description,
+        creative_id: creative_id,
+        next_run: task.next_time&.iso8601
+      }
+    end
+  end
+end
+end

data/app/services/collavre/tools/cron_list_service.rb

@@ -0,0 +1,65 @@
+module Collavre
+require "sorbet-runtime"
+require "rails_mcp_engine"
+module Tools
+  class CronListService
+    extend T::Sig
+    extend ToolMeta
+
+    tool_name "cron_list"
+    tool_description "List recurring scheduled jobs. Returns all cron jobs for creatives the current user has access to. Filter by creative_id to see jobs for a specific creative."
+
+    tool_param :creative_id, description: "Filter by creative ID. If omitted, lists all accessible cron jobs.", required: false
+
+    sig { params(creative_id: T.nilable(Integer)).returns(T::Hash[Symbol, T.untyped]) }
+    def call(creative_id: nil)
+      raise "Current.user is required" unless Current.user
+
+      tasks = SolidQueue::RecurringTask.where(static: false)
+
+      if creative_id.present?
+        creative = Creative.find_by(id: creative_id)
+        return { error: "Creative not found", id: creative_id } unless creative
+        unless creative.has_permission?(Current.user, :read)
+          return { error: "No read permission on this Creative", id: creative_id }
+        end
+        tasks = tasks.where("key LIKE ?", "cron_#{creative_id}_%")
+      end
+
+      results = tasks.filter_map do |task|
+        args = parse_arguments(task)
+        task_creative_id = args["creative_id"] || parse_creative_id_from_key(task.key)
+        task_creative = Creative.find_by(id: task_creative_id)
+        next unless task_creative&.has_permission?(Current.user, :read)
+
+        {
+          key: task.key,
+          schedule: task.schedule,
+          description: task.description,
+          creative_id: task_creative_id,
+          topic_id: args["topic_id"],
+          agent_id: args["agent_id"],
+          message: args["message"],
+          created_at: task.created_at&.iso8601
+        }
+      end
+
+      { success: true, cron_jobs: results, count: results.size }
+    end
+
+    private
+
+    def parse_arguments(task)
+      args = task.arguments
+      return {} unless args.is_a?(Array) && args.first.is_a?(Hash)
+
+      args.first.stringify_keys
+    end
+
+    def parse_creative_id_from_key(key)
+      match = key.match(/\Acron_(\d+)_/)
+      match[1].to_i if match
+    end
+  end
+end
+end

data/app/services/collavre/tools/cron_update_service.rb

@@ -0,0 +1,82 @@
+module Collavre
+require "sorbet-runtime"
+require "rails_mcp_engine"
+module Tools
+  class CronUpdateService
+    extend T::Sig
+    extend ToolMeta
+
+    tool_name "cron_update"
+    tool_description "Update the schedule, message, or description of an existing recurring job. Only jobs for creatives you have write access to can be updated."
+
+    tool_param :key, description: "The unique key of the cron job to update.", required: true
+    tool_param :schedule, description: "New cron schedule expression (optional).", required: false
+    tool_param :message, description: "New message content (optional).", required: false
+    tool_param :description, description: "New description (optional).", required: false
+
+    sig do
+      params(
+        key: String,
+        schedule: T.nilable(String),
+        message: T.nilable(String),
+        description: T.nilable(String)
+      ).returns(T::Hash[Symbol, T.untyped])
+    end
+    def call(key:, schedule: nil, message: nil, description: nil)
+      raise "Current.user is required" unless Current.user
+
+      task = SolidQueue::RecurringTask.find_by(key: key, static: false)
+      return { error: "Cron job not found", key: key } unless task
+
+      args = parse_arguments(task)
+      creative_id = args["creative_id"] || parse_creative_id_from_key(key)
+      creative = Creative.find_by(id: creative_id)
+
+      unless creative&.has_permission?(Current.user, :write)
+        return { error: "No write permission to update this cron job", key: key }
+      end
+
+      if schedule.present?
+        parsed = Fugit.parse(schedule)
+        unless parsed.is_a?(Fugit::Cron)
+          return { error: "Invalid cron schedule: #{schedule}. Use cron syntax like '0 9 * * *'." }
+        end
+        task.schedule = schedule
+      end
+
+      if message.present?
+        new_args = args.merge("message" => message)
+        task.arguments = [ new_args.symbolize_keys ]
+      end
+
+      task.description = description if description.present?
+
+      unless task.save
+        return { error: "Failed to update cron job", details: task.errors.full_messages }
+      end
+
+      {
+        success: true,
+        key: task.key,
+        schedule: task.schedule,
+        description: task.description,
+        next_run: task.next_time&.iso8601
+      }
+    end
+
+    private
+
+    def parse_arguments(task)
+      args = task.arguments
+      return {} unless args.is_a?(Array) && args.first.is_a?(Hash)
+
+      args.first.stringify_keys
+    end
+
+    def parse_creative_id_from_key(key)
+      match = key.match(/\Acron_(\d+)_/)
+      match[1].to_i if match
+    end
+  end
+end
+end

data/app/views/admin/shared/_tabs.html.erb

@@ -1,4 +1,5 @@
 <div class="tab-list">
   <%= link_to t('admin.tabs.system'), main_app.admin_path, class: "tab-button #{'active' if controller_name == 'settings'}" %>
   <%= link_to t('admin.tabs.users'), collavre.users_path, class: "tab-button #{'active' if controller_name == 'users'}" %>
+  <%= link_to t('admin.tabs.orchestration'), collavre.admin_orchestration_path, class: "tab-button #{'active' if controller_name == 'orchestration'}" %>
 </div>