collavre 0.5.0 → 0.7.0

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

@@ -0,0 +1,161 @@
+module Collavre
+  module Comments
+    class WorkCommand
+      include Concerns::WorkflowSupport
+
+      def initialize(comment:, user:)
+        @comment = comment
+        @user = user
+        @creative = comment.creative.effective_origin
+      end
+
+      def call
+        return unless work_command?
+        execute_work
+      rescue StandardError => e
+        Rails.logger.error("Work command failed: #{e.message}")
+        e.message
+      end
+
+      private
+
+      COMMAND_PATTERN = /\A\/work\b/i.freeze
+
+      attr_reader :comment, :user, :creative
+
+      def work_command?
+        comment.content.to_s.strip.match?(COMMAND_PATTERN)
+      end
+
+      def execute_work
+        subcommand = parse_subcommand
+        case subcommand
+        when :stop then execute_stop
+        when :resume then execute_resume
+        else execute_start
+        end
+      end
+
+      def parse_subcommand
+        content = comment.content.to_s.strip.sub(/\A\/work\s*/i, "")
+        case content
+        when /\Astop\b/i then :stop
+        when /\Aresume\b/i then :resume
+        else :start
+        end
+      end
+
+      # --- /work stop ---
+
+      def execute_stop
+        parent_task = find_active_workflow
+        return I18n.t("collavre.comments.work_command.no_active_workflow") unless parent_task
+
+        WorkflowExecutor.new(parent_task).stop!
+        I18n.t("collavre.comments.work_command.stopped",
+               agent: parent_task.agent.display_name)
+      end
+
+      # --- /work resume ---
+
+      def execute_resume
+        parent_task = find_resumable_workflow
+        return I18n.t("collavre.comments.work_command.no_resumable_workflow") unless parent_task
+
+        WorkflowExecutor.new(parent_task).resume!
+        parent_task.reload
+        I18n.t("collavre.comments.work_command.resumed",
+               agent: parent_task.agent.display_name,
+               remaining: (parent_task.workflow_state["pending_creative_ids"] || []).size)
+      end
+
+      # --- /work start (default) ---
+
+      def execute_start
+        worker, supervisor = find_agents
+        return I18n.t("collavre.comments.work_command.agent_not_found") unless worker
+        return I18n.t("collavre.comments.work_command.no_children") if creative.descendants.empty?
+
+        workflow_text = extract_workflow_context
+        child_ids = collect_dfs_creative_ids
+        skipped_ids = filter_already_tasked(child_ids)
+        pending_ids = child_ids - skipped_ids
+
+        return I18n.t("collavre.comments.work_command.all_already_tasked") if pending_ids.empty?
+
+        parent_task = create_parent_task(worker, supervisor, workflow_text, pending_ids)
+        WorkflowExecutor.advance!(parent_task)
+
+        I18n.t("collavre.comments.work_command.started",
+               agent: worker.display_name,
+               total: pending_ids.size,
+               skipped: skipped_ids.size)
+      end
+
+      # Parse mentioned AI agents: first = worker, second = supervisor (optional)
+      # Usage: /work @Worker @Supervisor: context
+      def find_agents
+        mentioned = MentionParser.resolve_all_users(comment.content.to_s).select(&:ai_user?)
+        worker = mentioned.first
+        supervisor = mentioned.second # nil if only one agent mentioned
+        [ worker, supervisor ]
+      end
+
+      def extract_workflow_context
+        content = comment.content.to_s.strip
+        content = content.sub(/\A\/work\s+/, "")
+        # Strip @mentions using the same pattern as MentionParser
+        content = content.gsub(MentionParser::MENTION_PATTERN, "")
+        content.strip
+      end
+
+      def collect_dfs_creative_ids
+        dfs_ids = []
+        dfs_traverse(creative) { |c| dfs_ids << c.id }
+        dfs_ids.reject { |id| id == creative.id }
+      end
+
+      def filter_already_tasked(creative_ids)
+        filter_active_or_completed(creative_ids)
+      end
+
+      def create_parent_task(worker, supervisor, workflow_text, pending_ids)
+        state = {
+          "pending_creative_ids" => pending_ids,
+          "completed_creative_ids" => [],
+          "current_creative_id" => nil,
+          "total" => pending_ids.size
+        }
+
+        # Store supervisor info for WorkflowExecutor to include in trigger comments
+        if supervisor
+          state["supervisor"] = { "id" => supervisor.id, "name" => supervisor.display_name }
+        end
+
+        Task.create!(
+          name: "Workflow: #{creative.description&.truncate(50)}",
+          status: "running",
+          agent: worker,
+          creative: creative,
+          workflow_context: workflow_text,
+          workflow_state: state,
+          trigger_event_name: "work_command",
+          trigger_event_payload: {
+            "creative" => { "id" => creative.id },
+            "comment" => { "id" => comment.id, "user_id" => comment.user_id }
+          }
+        )
+      end
+
+      def find_active_workflow
+        Task.where(creative: creative, trigger_event_name: "work_command", status: "running")
+            .order(created_at: :desc).first
+      end
+
+      def find_resumable_workflow
+        Task.where(creative: creative, trigger_event_name: "work_command", status: %w[failed cancelled])
+            .order(created_at: :desc).first
+      end
+    end
+  end
+end

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

@@ -0,0 +1,276 @@
+module Collavre
+  module Comments
+    class WorkflowExecutor
+      include Concerns::WorkflowSupport
+
+      def self.advance!(parent_task)
+        new(parent_task).advance!
+      end
+
+      def initialize(parent_task)
+        @parent_task = parent_task
+        @state = parent_task.workflow_state || {}
+      end
+
+      def advance!
+        loop do
+          return if @parent_task.status == "cancelled"
+
+          pending = @state["pending_creative_ids"] || []
+
+          if pending.empty?
+            complete_workflow!
+            return
+          end
+
+          next_creative_id = pending.first
+          next_creative = Creative.find_by(id: next_creative_id)
+
+          unless next_creative
+            skip_current!
+            next
+          end
+
+          @state["current_creative_id"] = next_creative_id
+          @parent_task.update!(workflow_state: @state)
+
+          sub_task_context = build_subtask_context(next_creative)
+
+          sub_task = Task.create!(
+            name: "Work on: #{next_creative.description&.truncate(50)}",
+            status: "pending",
+            agent: @parent_task.agent,
+            creative: next_creative,
+            parent_task: @parent_task,
+            workflow_context: @parent_task.workflow_context,
+            trigger_event_name: "workflow_subtask",
+            trigger_event_payload: sub_task_context,
+            topic_id: nil
+          )
+
+          post_progress_notice(next_creative)
+          AiAgentJob.perform_later(sub_task)
+          return
+        end
+      end
+
+      def complete_subtask!(sub_task)
+        completed = @state["completed_creative_ids"] || []
+        pending = @state["pending_creative_ids"] || []
+
+        Rails.logger.info(
+          "[WorkflowExecutor] complete_subtask! task=#{sub_task.id} creative=#{sub_task.creative_id} " \
+          "pending=#{pending.inspect} completed=#{completed.inspect}"
+        )
+
+        completed << sub_task.creative_id
+        pending.delete(sub_task.creative_id)
+
+        @state["completed_creative_ids"] = completed
+        @state["pending_creative_ids"] = pending
+        @state["current_creative_id"] = nil
+        @parent_task.update!(workflow_state: @state)
+
+        total = @state["total"] || 1
+        progress = completed.size.to_f / total
+        @parent_task.creative&.update!(progress: progress.clamp(0.0, 1.0))
+
+        Rails.logger.info(
+          "[WorkflowExecutor] Progress updated: #{completed.size}/#{total} (#{(progress * 100).round}%)"
+        )
+
+        post_subtask_completed_notice(sub_task, completed.size, total)
+
+        advance!
+      end
+
+      def fail_subtask!(sub_task, error_message: nil)
+        @state["current_creative_id"] = nil
+        @parent_task.update!(
+          status: "failed",
+          workflow_state: @state.merge(
+            "failed_creative_id" => sub_task.creative_id,
+            "failure_reason" => error_message
+          )
+        )
+
+        post_failure_notice(sub_task, error_message)
+      end
+
+      def stop!
+        # Cancel running sub-task if any
+        current_sub = @parent_task.sub_tasks.where(status: %w[running queued pending]).first
+        current_sub&.update!(status: "cancelled")
+
+        @state["current_creative_id"] = nil
+        @parent_task.update!(
+          status: "cancelled",
+          workflow_state: @state
+        )
+
+        post_notice(
+          I18n.t("collavre.comments.work_command.workflow_stopped",
+                 agent: @parent_task.agent.display_name,
+                 completed: (@state["completed_creative_ids"] || []).size,
+                 remaining: (@state["pending_creative_ids"] || []).size)
+        )
+      end
+
+      def resume!
+        # Re-check pending creatives — some may have been completed manually
+        pending = @state["pending_creative_ids"] || []
+        pending = refilter_pending(pending)
+        @state["pending_creative_ids"] = pending
+        @state["current_creative_id"] = nil
+
+        # Clear failure state
+        @state.delete("failed_creative_id")
+        @state.delete("failure_reason")
+
+        @parent_task.update!(
+          status: "running",
+          workflow_state: @state
+        )
+
+        post_notice(
+          I18n.t("collavre.comments.work_command.workflow_resumed",
+                 agent: @parent_task.agent.display_name,
+                 remaining: pending.size)
+        )
+
+        advance!
+      end
+
+      private
+
+      def skip_current!
+        pending = @state["pending_creative_ids"] || []
+        pending.shift
+        @state["pending_creative_ids"] = pending
+        @parent_task.update!(workflow_state: @state)
+      end
+
+      def complete_workflow!
+        @parent_task.update!(status: "done")
+        @parent_task.creative&.update!(progress: 1.0)
+
+        post_notice(
+          I18n.t("collavre.comments.work_command.workflow_completed",
+                 agent: @parent_task.agent.display_name,
+                 completed: (@state["completed_creative_ids"] || []).size)
+        )
+      end
+
+      def post_progress_notice(creative)
+        total = @state["total"] || 1
+        completed_count = (@state["completed_creative_ids"] || []).size
+        current_index = completed_count + 1
+        creative_desc = creative.description&.truncate(50) || "untitled"
+
+        post_notice(
+          I18n.t("collavre.comments.work_command.subtask_started",
+                 agent: @parent_task.agent.display_name,
+                 creative: creative_desc,
+                 current: current_index,
+                 total: total)
+        )
+      end
+
+      def post_subtask_completed_notice(sub_task, completed_count, total)
+        creative_desc = sub_task.creative&.description&.truncate(50) || "untitled"
+        progress_pct = ((completed_count.to_f / total) * 100).round
+
+        post_notice(
+          I18n.t("collavre.comments.work_command.subtask_completed",
+                 agent: @parent_task.agent.display_name,
+                 creative: creative_desc,
+                 completed: completed_count,
+                 total: total,
+                 progress: progress_pct)
+        )
+      end
+
+      def post_failure_notice(sub_task, error_message)
+        creative_desc = sub_task.creative&.description&.truncate(50) || "unknown"
+        post_notice(
+          I18n.t("collavre.comments.work_command.workflow_failed",
+                 agent: @parent_task.agent.display_name,
+                 creative: creative_desc,
+                 reason: error_message || "unknown error")
+        )
+      end
+
+      def post_notice(content)
+        post_workflow_notice(@parent_task, content)
+      end
+
+      def build_subtask_context(creative)
+        original_user = find_original_user
+
+        # Build rich trigger comment with creative content + workflow instruction
+        # This mimics a user manually asking the agent in the creative's chat
+        trigger_content = build_trigger_content(creative)
+
+        trigger_comment = creative.comments.create!(
+          content: trigger_content,
+          user: original_user,
+          topic_id: nil
+        )
+
+        # Context matches the format MessageBuilder expects:
+        # - creative.id → MessageBuilder renders creative tree markdown + chat history
+        # - comment.id → points to trigger comment in the child creative
+        # - sender → original user who issued /work
+        {
+          "creative" => { "id" => creative.id, "description" => creative.description },
+          "workflow" => {
+            "context" => @parent_task.workflow_context,
+            "parent_task_id" => @parent_task.id
+          },
+          "comment" => { "id" => trigger_comment.id, "content" => trigger_comment.content,
+                         "user_id" => trigger_comment.user_id },
+          "sender" => { "name" => original_user.name, "id" => original_user.id }
+        }
+      end
+
+      def build_trigger_content(_creative)
+        # Resolve workflow_context: if it's a creative ID, render that creative's markdown
+        # as the instruction (like a user pasting the content). Otherwise use as-is.
+        # NOTE: Do NOT prefix with @Agent — the trigger comment is authored by the
+        # original /work user, not the agent. Including @Agent causes the agent to
+        # interpret it as a self-referencing instruction.
+        # MessageBuilder already renders current creative's markdown from context["creative"]["id"].
+        content = resolve_workflow_context
+
+        # If a supervisor is assigned, append instruction to consult them instead of asking the user
+        supervisor = @state["supervisor"]
+        if supervisor
+          supervisor_instruction = I18n.t(
+            "collavre.comments.work_command.supervisor_instruction",
+            supervisor: supervisor["name"]
+          )
+          content = "#{content}\n\n#{supervisor_instruction}"
+        end
+
+        content
+      end
+
+      def resolve_workflow_context
+        resolve_workflow_context_from_task(@parent_task, @state)
+      end
+
+      def render_creative_markdown(creative)
+        render_creative_markdown_for_task(@parent_task, creative)
+      end
+
+      def find_original_user
+        find_original_user_from_task(@parent_task)
+      end
+
+      def refilter_pending(creative_ids)
+        return [] if creative_ids.empty?
+        creative_ids - filter_active_or_completed(creative_ids)
+      end
+    end
+  end
+end

data/app/services/collavre/creatives/plan_tagger.rb

@@ -3,9 +3,10 @@ module Creatives
   class PlanTagger
     Result = Struct.new(:success?, :message, keyword_init: true)
 
-    def initialize(plan_id:, creative_ids: [])
+    def initialize(plan_id:, creative_ids: [], user: nil)
       @plan = Plan.find_by(id: plan_id)
       @creative_ids = Array(creative_ids).map(&:presence).compact
+      @user = user
     end
 
     def apply
@@ -31,10 +32,20 @@ module Creatives
 
     private
 
-    attr_reader :plan, :creative_ids
+    attr_reader :plan, :creative_ids, :user
 
     def creatives
-      Creative.where(id: creative_ids)
+      all_creatives = Creative.where(id: creative_ids)
+      return all_creatives unless user
+
+      # Scope to creatives the user has write permission for via creative_shares
+      permitted_ids = all_creatives.joins(:creative_shares)
+                                   .where(creative_shares: { user_id: user.id })
+                                   .where("creative_shares.permission IN (?)", %w[write admin])
+                                   .pluck(:id)
+      # Also include creatives owned by the user
+      owned_ids = all_creatives.where(user_id: user.id).pluck(:id)
+      Creative.where(id: (permitted_ids + owned_ids).uniq)
     end
 
     def valid?

data/app/services/collavre/creatives/tree_formatter.rb

@@ -1,9 +1,31 @@
 module Collavre
   module Creatives
+    # Compact markdown tree formatter for AI Agent consumption.
+    # Used by: creative_retrieval_service, GeminiParentRecommender, Agent context injection.
+    #
+    # Output format (header declared once, rows are values only):
+    #   <!-- format: [id] description (progress%) -->
+    #   - [123] My Task (50%)
+    #     - [124] Subtask A (100%)
+    #     - [125] Subtask B (0%)
+    #
+    # Options:
+    #   max_depth:        Max tree depth (nil = unlimited)
+    #   include_header:   Include format comment header (default: true)
+    #   include_comments: Include recent comments per node (default: false)
+    #   use_permissions:  Use permission-filtered children (default: true)
     class TreeFormatter
+      def initialize(max_depth: nil, include_header: true, include_comments: false, use_permissions: true)
+        @max_depth = max_depth
+        @include_header = include_header
+        @include_comments = include_comments
+        @use_permissions = use_permissions
+      end
+
       def format(creatives)
         roots = Array(creatives)
         lines = []
+        lines << "<!-- format: [id] description (progress%) -->" if @include_header
 
         roots.each do |root|
           format_node(root, 0, lines)
@@ -12,25 +34,43 @@ module Collavre
         lines.join("\n")
       end
 
+      # Extract plain text description from a creative (shared helper)
+      def self.plain_description(creative)
+        raw = creative.effective_description(nil, true)
+        ActionView::Base.full_sanitizer.sanitize(raw).strip
+      end
+
       private
 
       def format_node(node, depth, lines)
-        indent = " " * (depth * 4)
-        desc = ActionController::Base.helpers.strip_tags(node.effective_description(nil, false))
-        progress = node.progress || 0.0
-
-        node_data = { id: node.id, progress: progress, desc: desc }
-        lines << "#{indent}- #{node_data.to_json}"
-
-        # We need to handle children. If the node is a new instance (in tests),
-        # children might depend on how it's set up.
-        # In real app, we use children association.
-        # To match the logic in views/controllers where we might want specific ordering:
-        # We'll validly assume `children` association is available.
-        node.children.each do |child|
+        return if @max_depth && depth > @max_depth
+
+        indent = "  " * depth
+        desc = self.class.plain_description(node)
+        progress = ((node.progress || 0.0) * 100).round
+
+        lines << "#{indent}- [#{node.id}] #{desc} (#{progress}%)"
+
+        if @include_comments
+          node.comments.order(created_at: :desc).limit(3).reverse_each do |comment|
+            comment_text = ActionView::Base.full_sanitizer.sanitize(comment.content).strip.truncate(100)
+            lines << "#{indent}    > #{comment_text}"
+          end
+        end
+
+        children_for(node).each do |child|
           format_node(child, depth + 1, lines)
         end
       end
+
+      def children_for(node)
+        if @use_permissions
+          node.linked_children
+        else
+          # When children are pre-set on association target (e.g. GeminiParentRecommender)
+          node.children
+        end
+      end
     end
   end
 end

data/app/services/collavre/gemini_parent_recommender.rb

@@ -33,9 +33,9 @@ module Collavre
       category_ids = categories.index_by(&:id)
       top_level_categories = categories.reject { |c| category_ids.key?(c.parent_id) }
 
-      tree_text = Creatives::TreeFormatter.new.format(top_level_categories)
+      tree_text = Creatives::TreeFormatter.new(use_permissions: false).format(top_level_categories)
 
-      prompt = build_prompt(tree_text, ActionController::Base.helpers.strip_tags(creative.description).to_s)
+      prompt = build_prompt(tree_text, Creatives::TreeFormatter.plain_description(creative))
       Rails.logger.info("### prompt=#{prompt}")
 
       response = @client.chat([ { role: :user, parts: [ { text: prompt } ] } ])
@@ -45,7 +45,7 @@ module Collavre
       ids.map do |id|
          c = Creative.find_by(id: id)
          next unless c
-         path = c.ancestors.reverse.map { |a| ActionController::Base.helpers.strip_tags(a.description) } + [ ActionController::Base.helpers.strip_tags(c.description) ]
+         path = c.ancestors.reverse.map { |a| Creatives::TreeFormatter.plain_description(a) } + [ Creatives::TreeFormatter.plain_description(c) ]
          { id: id, path: path.join(" > ") }
       end.compact
     end
@@ -55,7 +55,7 @@ module Collavre
     def default_client
       AiClient.new(
         vendor: "google",
-        model: "gemini-2.5-flash",
+        model: "gemini-3-flash-preview",
         system_prompt: nil
       )
     end

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

@@ -111,9 +111,7 @@ module Collavre
         sections << I18n.t("collavre.ai_agent.collaboration.rules_header")
         sections << (collab["mention_rule"] || I18n.t("collavre.ai_agent.collaboration.mention_rule"))
         sections << (collab["confidence_rule"] || I18n.t("collavre.ai_agent.collaboration.confidence_rule"))
-        if @policy_resolver&.self_reflection_enabled?
-          sections << I18n.t("collavre.ai_agent.collaboration.confidence_format_instruction")
-        end
+        sections << I18n.t("collavre.ai_agent.collaboration.confidence_format_instruction")
         sections << (collab["escalation_rule"] || I18n.t("collavre.ai_agent.collaboration.escalation_rule"))
         sections << (collab["review_rule"] || I18n.t("collavre.ai_agent.collaboration.review_rule"))
         sections << ""

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

@@ -16,8 +16,8 @@ module Collavre
         new(event_name: event_name, context: context).dispatch
       end
 
-      def self.dequeue_next_for_topic(topic_id)
-        task = Task.queued_for_topic(topic_id).first
+      def self.dequeue_next_for_topic(topic_id, creative_id = nil)
+        task = Task.queued_for_topic(topic_id, creative_id).first
         return unless task
 
         updated = Task.where(id: task.id, status: "queued").update_all(status: "pending")
@@ -29,7 +29,7 @@ module Collavre
           if task.status == "cancelled"
             # refresh_deferred_context! cancelled this task (no eligible comment),
             # try the next queued task for this topic.
-            dequeue_next_for_topic(topic_id)
+            dequeue_next_for_topic(topic_id, creative_id)
           else
             AiAgentJob.perform_later(task)
           end
@@ -127,6 +127,16 @@ module Collavre
           agent = decision[:agent]
           log_decision(decision)
 
+          # Guard: skip if agent already has a running task for this comment
+          comment_id = @context.dig("comment", "id")
+          if comment_id && Task.duplicate_running_for_comment?(agent.id, comment_id)
+            Rails.logger.warn(
+              "[AgentOrchestrator] Skipping enqueue: agent #{agent.id} already has a running task " \
+              "for comment #{comment_id}"
+            )
+            next
+          end
+
           case decision[:timing]
           when :immediate
             AiAgentJob.perform_later(agent.id, @event_name, @context)
@@ -138,7 +148,8 @@ module Collavre
               trigger_event_name: @event_name,
               trigger_event_payload: @context,
               agent: agent,
-              topic_id: @context.dig("topic", "id")
+              topic_id: @context.dig("topic", "id"),
+              creative_id: @context.dig("creative", "id")
             )
             post_waiting_notice(agent, decision)
             agent

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

@@ -28,11 +28,6 @@ module Collavre
           "rate_limit_per_minute" => 20,
           "backoff_strategy" => "exponential",
           "topic_max_concurrent_jobs" => 1,
-          # Self-reflection settings
-          "self_reflection_enabled" => false,
-          "confidence_threshold" => 70,
-          "max_retries" => 3,
-          "retry_delay_seconds" => 5,
           # Loop breaker settings
           "loop_breaker_enabled" => true,
           "ping_pong_threshold" => 5,           # Max back-and-forth between same agents
@@ -113,20 +108,6 @@ module Collavre
         arbitration_config["bid_fallback_enabled"] != false
       end
 
-      # Self-reflection settings
-      def self_reflection_enabled?
-        scheduling_config["self_reflection_enabled"] == true
-      end
-
-      def self_reflection_config
-        {
-          "enabled" => scheduling_config["self_reflection_enabled"],
-          "confidence_threshold" => scheduling_config["confidence_threshold"],
-          "max_retries" => scheduling_config["max_retries"],
-          "retry_delay_seconds" => scheduling_config["retry_delay_seconds"]
-        }
-      end
-
       # Loop breaker settings
       def loop_breaker_enabled?
         scheduling_config["loop_breaker_enabled"] == true