collavre 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ad04ae23058f911aed4ecb6d53a0b650b3e90de1296258cc3a481b5d2984e60
-  data.tar.gz: a7a19242045151694e551ee8f998ca6bc15213804f4b28a0da1e3d8f3b110946
+  metadata.gz: bb2d48043704a517d8970498aa1057e5eaa29133304fe4fb82ebe37ac96b8458
+  data.tar.gz: d517609fd42be9255120f2faafe4acaf0fa36a2797c96021c5502acb6206af66
 SHA512:
-  metadata.gz: 000ca6cfec2bef14c9199f0a8204ce40c498da48a437b765d9f08c8623a86ec4434a2094d29fa9717488cd5cedf9a44e3016699c0e0a37f8e5eee55890fbfa33
-  data.tar.gz: 7f2235ffb0bbc1c37943f3be68dd17bdc4f0c1185b85019e7b748485e5915b22d24ff41ba62eae5625233820cdb902733ac186f36b9a0082f8a2c1140292759a
+  metadata.gz: ca97eb7ec6d858f67b1d3da6f7db767d15a7ba16a14b3dcb883c051a8bef55b2d679441ff8eb32cd9455528ef977f74430e535553cf9511d74024a23d7c8d0e7
+  data.tar.gz: a5cccbe54450cc225d25935ab85720302f61354785dfac02c1170933369c470767786a7c2fc683a93f907ffdc6ce5a34cb2abd1fec8b77aa6fbce9408c68873d

data/app/channels/collavre/comments_presence_channel.rb

@@ -12,20 +12,23 @@ class CommentsPresenceChannel < ApplicationCable::Channel
         status: "thinking",
         agent_id: task.agent_id,
         agent_name: task.agent.display_name,
-        task_id: task.id
+        task_id: task.id,
+        source_creative_id: task_creative_id
       )
     end
   end
 
   # Broadcast agent status (thinking/streaming/idle) to presence channel.
   # This allows the frontend typing indicator to show AI agent activity.
-  def self.broadcast_agent_status(creative_id, status:, agent_id:, agent_name:, task_id: nil, content: nil)
+  # source_creative_id: the actual creative where agent is working (for filtering on frontend)
+  def self.broadcast_agent_status(creative_id, status:, agent_id:, agent_name:, task_id: nil, content: nil, source_creative_id: nil)
     payload = {
       agent_status: {
         id: agent_id,
         name: agent_name,
         status: status,
-        task_id: task_id
+        task_id: task_id,
+        creative_id: source_creative_id || creative_id
       }
     }
     payload[:agent_status][:content] = content if content.present?

data/app/controllers/collavre/admin/orchestration_controller.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Collavre
+  module Admin
+    class OrchestrationController < ApplicationController
+      before_action :require_system_admin!
+
+      def show
+        @policies_yaml = policies_to_yaml
+      end
+
+      def update
+        yaml_content = params[:policies_yaml].to_s
+
+        begin
+          parsed = YAML.safe_load(yaml_content, permitted_classes: [ Symbol ])
+          validate_policies!(parsed)
+          apply_policies!(parsed)
+
+          redirect_to main_app.admin_orchestration_path, notice: t("admin.orchestration.updated")
+        rescue Psych::SyntaxError => e
+          flash.now[:alert] = t("admin.orchestration.yaml_syntax_error", message: e.message)
+          @policies_yaml = yaml_content
+          render :show, status: :unprocessable_entity
+        rescue PolicyValidationError => e
+          flash.now[:alert] = e.message
+          @policies_yaml = yaml_content
+          render :show, status: :unprocessable_entity
+        end
+      end
+
+      private
+
+      class PolicyValidationError < StandardError; end
+
+      def policies_to_yaml
+        policies = OrchestratorPolicy.enabled.order(:policy_type, :scope_type, :priority)
+
+        # Group by type for readable YAML structure
+        structure = {
+          "arbitration" => { "global" => nil, "overrides" => [] },
+          "scheduling" => { "global" => nil, "overrides" => [] }
+        }
+
+        policies.each do |policy|
+          type = policy.policy_type
+          next unless structure.key?(type)
+
+          if policy.global?
+            structure[type]["global"] = policy.config
+          else
+            structure[type]["overrides"] << {
+              "scope_type" => policy.scope_type,
+              "scope_id" => policy.scope_id,
+              "config" => policy.config,
+              "priority" => policy.priority
+            }
+          end
+        end
+
+        # Remove empty sections
+        structure.each do |type, data|
+          data.delete("global") if data["global"].nil?
+          data.delete("overrides") if data["overrides"].empty?
+        end
+        structure.delete_if { |_, v| v.empty? }
+
+        # Add defaults if empty
+        if structure.empty?
+          structure = default_policies_structure
+        end
+
+        structure.to_yaml
+      end
+
+      def default_policies_structure
+        {
+          "arbitration" => {
+            "global" => {
+              "strategy" => "all",
+              "max_responders" => nil
+            }
+          },
+          "scheduling" => {
+            "global" => {
+              "max_concurrent_jobs" => 5,
+              "daily_token_limit" => 100_000,
+              "rate_limit_per_minute" => 20,
+              "backoff_strategy" => "exponential",
+              "topic_max_concurrent_jobs" => 1
+            }
+          }
+        }
+      end
+
+      def validate_policies!(parsed)
+        raise PolicyValidationError, t("admin.orchestration.invalid_format") unless parsed.is_a?(Hash)
+
+        parsed.each do |type, data|
+          unless %w[arbitration scheduling].include?(type)
+            raise PolicyValidationError, t("admin.orchestration.unknown_policy_type", type: type)
+          end
+
+          unless data.is_a?(Hash)
+            raise PolicyValidationError, t("admin.orchestration.invalid_policy_structure", type: type)
+          end
+
+          if data["global"].present? && !data["global"].is_a?(Hash)
+            raise PolicyValidationError, t("admin.orchestration.invalid_global_config", type: type)
+          end
+
+          if data["overrides"].present?
+            unless data["overrides"].is_a?(Array)
+              raise PolicyValidationError, t("admin.orchestration.invalid_overrides", type: type)
+            end
+
+            data["overrides"].each_with_index do |override, idx|
+              validate_override!(type, override, idx)
+            end
+          end
+        end
+      end
+
+      def validate_override!(type, override, idx)
+        unless override.is_a?(Hash)
+          raise PolicyValidationError, t("admin.orchestration.invalid_override_format", type: type, index: idx)
+        end
+
+        unless %w[Creative Topic User].include?(override["scope_type"])
+          raise PolicyValidationError, t("admin.orchestration.invalid_scope_type",
+                                         type: type, index: idx, scope_type: override["scope_type"])
+        end
+
+        unless override["scope_id"].is_a?(Integer) && override["scope_id"].positive?
+          raise PolicyValidationError, t("admin.orchestration.invalid_scope_id", type: type, index: idx)
+        end
+
+        unless override["config"].is_a?(Hash)
+          raise PolicyValidationError, t("admin.orchestration.invalid_override_config", type: type, index: idx)
+        end
+      end
+
+      def apply_policies!(parsed)
+        OrchestratorPolicy.transaction do
+          # Clear existing policies
+          OrchestratorPolicy.delete_all
+
+          parsed.each do |type, data|
+            # Create global policy
+            if data["global"].present?
+              OrchestratorPolicy.create!(
+                policy_type: type,
+                scope_type: nil,
+                scope_id: nil,
+                config: data["global"],
+                priority: 100,
+                enabled: true
+              )
+            end
+
+            # Create override policies
+            data["overrides"]&.each_with_index do |override, idx|
+              OrchestratorPolicy.create!(
+                policy_type: type,
+                scope_type: override["scope_type"],
+                scope_id: override["scope_id"],
+                config: override["config"],
+                priority: override["priority"] || (50 - idx),
+                enabled: true
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/collavre/comments_controller.rb

@@ -173,6 +173,9 @@ module Collavre
             id: @creative.id,
             description: @creative.description
           },
+          topic: {
+            id: @comment.topic_id
+          },
           chat: {
             content: @comment.content
           }

data/app/javascript/controllers/comments/presence_controller.js

@@ -151,7 +151,11 @@ export default class extends Controller {
       this.renderTypingIndicator()
     }
     if (data.agent_status) {
-      const { id, name, status } = data.agent_status
+      const { id, name, status, creative_id: agentCreativeId } = data.agent_status
+      // Only show typing indicator if agent is working on this specific creative
+      if (agentCreativeId && agentCreativeId !== this.creativeId) {
+        return
+      }
       if (status === 'thinking' || status === 'streaming') {
         this.typingUsers[id] = name
       } else {

data/app/jobs/collavre/ai_agent_job.rb

@@ -8,7 +8,9 @@ module Collavre
         # Resume existing task
         task = agent_id_or_task
         return if task.reload.status == "cancelled"
+
         task.update!(status: "running")
+        agent = task.agent
       else
         # Create new task
         agent = User.find(agent_id_or_task)
@@ -17,25 +19,74 @@ module Collavre
           status: "running",
           trigger_event_name: event_name,
           trigger_event_payload: context,
-          agent: agent
+          agent: agent,
+          topic_id: context&.dig("topic", "id")
         )
+
+        # Record task for loop breaker tracking
+        creative_id = context&.dig("creative", "id")
+        if creative_id
+          Orchestration::LoopBreaker.new(context).record_task(creative_id, agent.id)
+        end
       end
 
+      # Reserve resources before starting work
+      tracker = Orchestration::ResourceTracker.for(agent)
+      tracker.reserve!(job_id || task.id)
+
       begin
-        AiAgentService.new(task).call
-        task.update!(status: "done")
+        response_content = AiAgentService.new(task).call
+
+        # Evaluate self-reflection if enabled
+        reflection_result = evaluate_self_reflection(task, response_content)
+
+        case reflection_result.action
+        when :retry
+          # Schedule retry with delay - don't release resources yet
+          schedule_self_reflection_retry(task, reflection_result, response_content)
+          Rails.logger.info(
+            "[AiAgentJob] Task #{task.id} scheduled for retry " \
+            "(attempt #{task.retry_count + 1}, confidence: #{reflection_result.confidence})"
+          )
+          nil # Exit without releasing resources or dequeuing
+        when :escalate
+          # Escalate to admins
+          Orchestration::SelfReflectionEvaluator.new(task, response_content: response_content).escalate!(reflection_result)
+          tracker.release!(job_id || task.id, tokens_used: 0)
+          Rails.logger.info("[AiAgentJob] Task #{task.id} escalated after max retries")
+        else # :done
+          task.update!(status: "done")
+          tracker.release!(job_id || task.id, tokens_used: 0)
+        end
       rescue ApprovalPendingError
         # Task status already set to pending_approval by AiAgentService
-        # Don't mark as failed, just let the job complete gracefully
+        # Don't release resources yet - task will resume
         Rails.logger.info("AiAgentJob paused for task #{task.id}: awaiting tool approval")
       rescue CancelledError
         # Task status already set to "cancelled" by Comment callback
+        tracker.release!(job_id || task.id, tokens_used: 0)
         Rails.logger.info("AiAgentJob cancelled for task #{task.id}: trigger message deleted")
       rescue StandardError => e
         task.update!(status: "failed")
+        tracker.release!(job_id || task.id, tokens_used: 0)
         Rails.logger.error("AiAgentJob failed for task #{task.id}: #{e.message}")
         raise e
+      ensure
+        if task&.trigger_event_payload&.key?("topic") && %w[done failed cancelled escalated].include?(task.reload.status)
+          Orchestration::AgentOrchestrator.dequeue_next_for_topic(task.topic_id)
+        end
       end
     end
+
+    private
+
+    def evaluate_self_reflection(task, response_content)
+      Orchestration::SelfReflectionEvaluator.new(task, response_content: response_content).evaluate
+    end
+
+    def schedule_self_reflection_retry(task, result, response_content)
+      evaluator = Orchestration::SelfReflectionEvaluator.new(task, response_content: response_content)
+      evaluator.schedule_retry!(result)
+    end
   end
 end

data/app/jobs/collavre/cron_action_job.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Collavre
+  # CronActionJob is executed by SolidQueue recurring tasks to post
+  # a scheduled message into a creative's topic, triggering the
+  # agent orchestration pipeline.
+  #
+  # Created dynamically via the cron_create MCP tool.
+  class CronActionJob < ApplicationJob
+    queue_as :default
+
+    def perform(creative_id:, topic_id:, agent_id:, message:)
+      creative = Creative.find_by(id: creative_id)
+      topic = Topic.find_by(id: topic_id)
+      agent = User.find_by(id: agent_id)
+
+      unless creative && topic && agent
+        Rails.logger.warn(
+          "[CronActionJob] Skipping: creative=#{creative_id} topic=#{topic_id} agent=#{agent_id} - record not found"
+        )
+        return
+      end
+
+      comment = creative.comments.create!(
+        content: message,
+        user: agent,
+        topic_id: topic.id,
+        private: false
+      )
+
+      # Dispatch system event to trigger agent orchestration pipeline
+      SystemEvents::Dispatcher.dispatch("comment_created", {
+        comment: {
+          id: comment.id,
+          content: comment.content,
+          user_id: comment.user_id
+        },
+        creative: {
+          id: creative.id,
+          description: creative.description
+        },
+        topic: {
+          id: topic.id
+        },
+        chat: {
+          content: comment.content
+        }
+      })
+
+      Rails.logger.info("[CronActionJob] Posted cron message to creative #{creative_id}, topic #{topic_id}")
+    end
+  end
+end

data/app/jobs/collavre/stuck_detector_job.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Collavre
+  # StuckDetectorJob runs periodically to detect stuck tasks and creatives.
+  #
+  # This job should be scheduled to run every 5-10 minutes via cron or similar.
+  #
+  # Usage:
+  #   StuckDetectorJob.perform_later
+  #
+  # To schedule with SolidQueue:
+  #   # config/recurring.yml
+  #   stuck_detector:
+  #     class: Collavre::StuckDetectorJob
+  #     schedule: every 10 minutes
+  #
+  class StuckDetectorJob < ApplicationJob
+    queue_as :default
+
+    def perform
+      detector = Orchestration::StuckDetector.new
+      result = detector.detect_and_escalate
+
+      if result.escalated_count > 0
+        Rails.logger.info(
+          "[StuckDetectorJob] Detected #{result.stuck_items.count} stuck items, " \
+          "escalated #{result.escalated_count}"
+        )
+      end
+
+      result
+    end
+  end
+end

data/app/models/collavre/creative.rb

@@ -59,7 +59,7 @@ module Collavre
     has_many :tags, class_name: "Collavre::Tag", dependent: :destroy
     has_many :creative_expanded_states, class_name: "Collavre::CreativeExpandedState", dependent: :delete_all
     has_many :invitations, class_name: "Collavre::Invitation", dependent: :delete_all
-    has_many :github_repository_links, dependent: :destroy
+    # github_repository_links association added by CollavreGithub engine
     has_many :topics, class_name: "Collavre::Topic", dependent: :destroy
     has_many :mcp_tools, dependent: :destroy
     has_many :activity_logs, class_name: "Collavre::ActivityLog", dependent: :destroy

data/app/models/collavre/orchestrator_policy.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Collavre
+  # OrchestratorPolicy stores configuration for agent orchestration behavior.
+  #
+  # Table: orchestrator_policies
+  #
+  # Scope types:
+  # - nil (global): Default policy applied everywhere
+  # - "Creative": Policy for a specific creative/workspace
+  # - "Topic": Policy for a specific topic/conversation
+  # - "User": Policy for a specific agent
+  #
+  # Policy types:
+  # - matching: How agents are matched to messages
+  # - arbitration: How to select responders from candidates (floor control)
+  # - scheduling: When/how to execute agent jobs (resource management)
+  #
+  # Example configs:
+  #
+  #   Arbitration policy (primary_first):
+  #   {
+  #     "strategy": "primary_first",
+  #     "max_responders": 1,
+  #     "primary_agent_id": 123
+  #   }
+  #
+  #   Arbitration policy (round_robin):
+  #   {
+  #     "strategy": "round_robin",
+  #     "max_responders": 1
+  #   }
+  #
+  class OrchestratorPolicy < ApplicationRecord
+    self.table_name = "orchestrator_policies"
+
+    # Scope types
+    SCOPE_TYPES = %w[Creative Topic User].freeze
+
+    # Policy types
+    POLICY_TYPES = %w[matching arbitration scheduling stuck_detection].freeze
+
+    # Arbitration strategies
+    ARBITRATION_STRATEGIES = %w[all primary_first round_robin bid].freeze
+
+    # Validations
+    validates :policy_type, presence: true, inclusion: { in: POLICY_TYPES }
+    validates :scope_type, inclusion: { in: SCOPE_TYPES }, allow_nil: true
+    validates :priority, presence: true, numericality: { only_integer: true }
+
+    # Polymorphic scope
+    belongs_to :scope, polymorphic: true, optional: true
+
+    # Scopes
+    scope :enabled, -> { where(enabled: true) }
+    scope :by_priority, -> { order(priority: :asc) }
+    scope :global, -> { where(scope_type: nil, scope_id: nil) }
+    scope :for_type, ->(type) { where(policy_type: type) }
+
+    # Class methods
+    class << self
+      # Find policies applicable to a given context
+      # Returns policies in priority order (global < creative < topic < agent)
+      def for_context(context, policy_type:)
+        policies = enabled.for_type(policy_type).by_priority
+
+        applicable = []
+
+        # Global policies
+        applicable.concat(policies.global.to_a)
+
+        # Creative-level policies
+        if context["creative"].present?
+          creative_id = context["creative"]["id"]
+          applicable.concat(
+            policies.where(scope_type: "Creative", scope_id: creative_id).to_a
+          )
+        end
+
+        # Topic-level policies
+        if context["topic"].present?
+          topic_id = context["topic"]["id"]
+          applicable.concat(
+            policies.where(scope_type: "Topic", scope_id: topic_id).to_a
+          )
+        end
+
+        # Agent-level policies are handled separately per-agent
+
+        # Note: We don't sort by priority globally here because scope hierarchy
+        # (global < creative < topic) takes precedence. Each scope level is
+        # already sorted by priority from the query.
+        applicable
+      end
+
+      # Find policies for a specific agent
+      def for_agent(agent_id, policy_type:)
+        enabled
+          .for_type(policy_type)
+          .where(scope_type: "User", scope_id: agent_id)
+          .by_priority
+      end
+    end
+
+    # Instance methods
+
+    # Get a config value with default
+    def config_value(key, default: nil)
+      config[key.to_s] || default
+    end
+
+    # Check if this is a global policy
+    def global?
+      scope_type.nil? && scope_id.nil?
+    end
+
+    # Get the arbitration strategy
+    def arbitration_strategy
+      return nil unless policy_type == "arbitration"
+
+      config_value("strategy", default: "all")
+    end
+  end
+end

data/app/models/collavre/task.rb

@@ -6,5 +6,8 @@ module Collavre
     has_many :task_actions, class_name: "Collavre::TaskAction", dependent: :destroy
 
     validates :name, presence: true
+
+    scope :running_for_topic, ->(topic_id) { where(topic_id: topic_id, status: "running") }
+    scope :queued_for_topic, ->(topic_id) { where(topic_id: topic_id, status: "queued").order(:created_at) }
   end
 end

data/app/models/collavre/user.rb

@@ -16,7 +16,7 @@ module Collavre
     has_many :contacts, class_name: "Collavre::Contact", dependent: :destroy
     has_many :contact_users, through: :contacts
     has_many :contact_memberships, class_name: "Collavre::Contact", foreign_key: :contact_user_id, dependent: :destroy, inverse_of: :contact_user
-    has_one :github_account, class_name: "Collavre::GithubAccount", dependent: :destroy
+    # github_account association is added dynamically by collavre_github engine
     has_many :tasks, class_name: "Collavre::Task", foreign_key: :agent_id, dependent: :destroy
 
     # Associations that reference creatives - must be destroyed BEFORE creatives

data/app/services/collavre/ai_agent_service.rb

@@ -32,11 +32,19 @@ module Collavre
           rendering_context["creative"] = creative.as_json if creative
         end
 
+        # Add agent collaboration context
+        agent_context = build_agent_context(creative)
+        rendering_context.merge!(agent_context)
+
         rendered_system_prompt = AiSystemPromptRenderer.new(
           template: @agent.system_prompt,
           context: rendering_context
         ).render
 
+        # Append collaboration guide to system prompt
+        collaboration_prompt = build_collaboration_prompt(creative)
+        rendered_system_prompt = "#{rendered_system_prompt}\n\n#{collaboration_prompt}" if collaboration_prompt.present?
+
         # Create a placeholder comment to stream into
         target_comment_id = @context.dig("comment", "id")
         @original_comment = target_comment_id ? Comment.find_by(id: target_comment_id) : nil
@@ -109,6 +117,8 @@ module Collavre
 
         # Broadcast "idle" status
         broadcast_agent_status("idle")
+
+        @response_content
       end
     rescue ApprovalPendingError => e
       handle_approval_pending(e)
@@ -154,7 +164,8 @@ module Collavre
         agent_id: @agent.id,
         agent_name: @agent.display_name,
         task_id: @task.id,
-        content: content
+        content: content,
+        source_creative_id: @creative.id
       )
     end
 
@@ -236,6 +247,26 @@ module Collavre
                  .update_all(comment_id: to_comment.id)
     end
 
+    def build_agent_context(creative)
+      return {} unless creative
+
+      Orchestration::AgentContextBuilder.new(
+        agent: @agent,
+        creative: creative,
+        sender: @context["sender"]
+      ).build
+    end
+
+    def build_collaboration_prompt(creative)
+      return nil unless creative
+
+      Orchestration::AgentContextBuilder.new(
+        agent: @agent,
+        creative: creative,
+        sender: @context["sender"]
+      ).to_collaboration_prompt
+    end
+
     def handle_approval_pending(error)
       # Clean up placeholder comment if exists
       @reply_comment&.destroy! if @reply_comment&.content == Comment::STREAMING_PLACEHOLDER_CONTENT

data/app/services/collavre/ai_client.rb

@@ -83,10 +83,11 @@ module Collavre
     rescue CancelledError
       raise # Re-raise cancellation errors without catching them
     rescue StandardError => e
-      error_message = e.message
-      Rails.logger.error "AI Client error: #{e.message}"
+      error_message = "[#{e.class.name}] #{e.message}"
+      Rails.logger.error "AI Client error: #{error_message}"
+      Rails.logger.error "Partial response length: #{response_content.length} chars" if response_content.present?
       Rails.logger.debug e.backtrace.join("\n")
-      yield "AI Error: #{e.message}" if block_given?
+      yield "\n\n⚠️ AI Error: #{error_message}" if block_given?
       nil
     ensure
       log_interaction(

data/app/services/collavre/comments/command_processor.rb

@@ -26,7 +26,10 @@ module Collavre
       end
 
       def static_commands
-        [ Collavre::Comments::CalendarCommand.new(comment: comment, user: user) ]
+        [
+          Collavre::Comments::CalendarCommand.new(comment: comment, user: user),
+          Collavre::Comments::TopicCommand.new(comment: comment, user: user)
+        ]
       end
 
       def mcp_commands