collavre 0.5.0 → 0.7.0

data/app/javascript/modules/creative_row_editor.js

@@ -4,6 +4,7 @@ import { $getCharacterOffsets, $getSelection, $isRangeSelection, $isTextNode, $i
 import { createInlineEditor } from './lexical_inline_editor'
 import { renderCreativeTree, dispatchCreativeTreeUpdated } from '../creatives/tree_renderer'
 import { isProgressComplete, progressBaselineValueFrom, progressValueChangedFrom } from './creative_progress'
+import yaml from 'js-yaml'
 // Import Stimulus application from the global window (set by host app)
 const application = window.Stimulus
 
@@ -99,6 +100,11 @@ export function initializeCreativeRowEditor() {
     const afterInput = document.getElementById('inline-after-id');
     const childInput = document.getElementById('inline-child-id');
     const originIdInput = document.getElementById('inline-origin-id');
+    const metadataBtn = document.getElementById('inline-metadata-btn');
+    const metadataPopup = document.getElementById('metadata-popup');
+    const metadataEditor = document.getElementById('metadata-yaml-editor');
+    const metadataSaveBtn = document.getElementById('metadata-save-btn');
+    const metadataCloseBtn = document.getElementById('metadata-popup-close');
 
     let lexicalEditor = null;
     if (editorContainer) {
@@ -304,6 +310,16 @@ export function initializeCreativeRowEditor() {
       originalProgress = normalizedProgress;
       lexicalEditor.focus();
       updateActionButtonStates();
+      // Reload metadata if the popup is open
+      if (isMetadataPopupVisible()) {
+        if (data.data !== undefined) {
+          // Use data already fetched from API response — avoids extra request
+          const yamlStr = yaml.dump(data.data || {}, { lineWidth: -1 });
+          metadataEditor.value = yamlStr;
+        } else {
+          loadMetadataForCreative(creativeId);
+        }
+      }
     }
 
     function siblingTreeRow(row, direction) {
@@ -1925,5 +1941,77 @@ export function initializeCreativeRowEditor() {
           });
       });
     }
+
+    // Metadata editor handlers
+    function loadMetadataForCreative(creativeId) {
+      if (!creativeId || !metadataPopup || !metadataEditor) return;
+      creativesApi.get(creativeId)
+        .then(function (data) {
+          const metadataObj = data.data || {};
+          const yamlStr = yaml.dump(metadataObj, { lineWidth: -1 });
+          metadataEditor.value = yamlStr;
+        })
+        .catch(function (error) {
+          console.error('Failed to load metadata:', error);
+          alert('Failed to load metadata');
+        });
+    }
+
+    function isMetadataPopupVisible() {
+      return metadataPopup && metadataPopup.style.display !== 'none';
+    }
+
+    if (metadataBtn && metadataPopup && metadataEditor) {
+      metadataBtn.addEventListener('click', function () {
+        const creativeId = form.dataset.creativeId;
+        if (!creativeId) return;
+
+        if (isMetadataPopupVisible()) {
+          metadataPopup.style.display = 'none';
+          return;
+        }
+
+        loadMetadataForCreative(creativeId);
+        metadataPopup.style.display = 'block';
+      });
+
+      if (metadataCloseBtn) {
+        metadataCloseBtn.addEventListener('click', function () {
+          metadataPopup.style.display = 'none';
+        });
+      }
+
+      if (metadataSaveBtn) {
+        metadataSaveBtn.addEventListener('click', function () {
+          const creativeId = form.dataset.creativeId;
+          if (!creativeId) return;
+
+          try {
+            // Parse YAML back to JSON
+            const yamlStr = metadataEditor.value;
+            const parsedData = yaml.load(yamlStr) || {};
+
+            // Send PATCH request
+            creativesApi.updateMetadata(creativeId, parsedData)
+              .then(function (response) {
+                if (response.ok) {
+                  metadataPopup.style.display = 'none';
+                } else {
+                  return response.json().then(function (data) {
+                    alert('Failed to save metadata: ' + (data.error || 'Unknown error'));
+                  });
+                }
+              })
+              .catch(function (error) {
+                console.error('Failed to save metadata:', error);
+                alert('Failed to save metadata');
+              });
+          } catch (error) {
+            console.error('YAML parse error:', error);
+            alert('Invalid YAML format: ' + error.message);
+          }
+        });
+      }
+    }
   });
 }

data/app/javascript/modules/slide_view.js

@@ -1,4 +1,5 @@
 import { createSubscription } from '../services/cable'
+import DOMPurify from 'dompurify'
 
 document.addEventListener('DOMContentLoaded', function() {
   var container = document.getElementById('slide-view');
@@ -59,7 +60,7 @@ document.addEventListener('DOMContentLoaded', function() {
         }
         contentEl.innerHTML = '';
         var el = document.createElement(tag);
-        el.innerHTML = data.description;
+        el.innerHTML = DOMPurify.sanitize(data.description);
         contentEl.appendChild(el);
         if (captionEl) {
           captionEl.textContent = data.prompt || '';

data/app/jobs/collavre/ai_agent_job.rb

@@ -14,13 +14,25 @@ module Collavre
       else
         # Create new task
         agent = User.find(agent_id_or_task)
+
+        # Guard: skip if there's already a running task for the same agent + comment
+        comment_id = context&.dig("comment", "id")
+        if comment_id && Task.duplicate_running_for_comment?(agent.id, comment_id)
+          Rails.logger.warn(
+            "[AiAgentJob] Skipping duplicate: agent #{agent.id} already has a running task " \
+            "for comment #{comment_id} (event=#{event_name})"
+          )
+          return
+        end
+
         task = Task.create!(
           name: "Response to #{event_name}",
           status: "running",
           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")
         )
 
         # Record task for loop breaker tracking (per-topic, skip user-initiated)
@@ -41,26 +53,33 @@ module Collavre
       begin
         response_content = AiAgentService.new(task).call
 
-        # Evaluate self-reflection if enabled
-        reflection_result = evaluate_self_reflection(task, response_content)
+        # Workflow subtasks with empty responses should retry, then fail
+        if task.parent_task_id.present? && response_content.blank?
+          max_retries = 2
+          current_retry = task.retry_count || 0
 
-        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
+          if current_retry < max_retries
+            task.update!(retry_count: current_retry + 1, status: "pending")
+            tracker.release!(job_id || task.id, tokens_used: 0)
+            Rails.logger.warn(
+              "[AiAgentJob] Workflow subtask #{task.id} returned empty response, " \
+              "retrying (#{current_retry + 1}/#{max_retries})"
+            )
+            AiAgentJob.set(wait: 5.seconds).perform_later(task)
+          else
+            task.update!(status: "failed")
+            tracker.release!(job_id || task.id, tokens_used: 0)
+            Collavre::Comments::WorkflowExecutor.new(task.parent_task).fail_subtask!(
+              task, error_message: "Agent returned empty response after #{max_retries} retries"
+            )
+          end
+        else
           task.update!(status: "done")
           tracker.release!(job_id || task.id, tokens_used: 0)
+          # Advance workflow after releasing resources to avoid deadlock
+          if task.parent_task_id.present?
+            Collavre::Comments::WorkflowExecutor.new(task.parent_task).complete_subtask!(task)
+          end
         end
       rescue ApprovalPendingError
         # Task status already set to pending_approval by AiAgentService
@@ -73,24 +92,17 @@ module Collavre
       rescue StandardError => e
         task.update!(status: "failed")
         tracker.release!(job_id || task.id, tokens_used: 0)
+        # Fail workflow if this is a sub-task
+        if task.parent_task_id.present?
+          Collavre::Comments::WorkflowExecutor.new(task.parent_task).fail_subtask!(task, error_message: e.message)
+        end
         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)
+          Orchestration::AgentOrchestrator.dequeue_next_for_topic(task.topic_id, task.creative_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/compress_job.rb

@@ -0,0 +1,92 @@
+module Collavre
+  class CompressJob < ApplicationJob
+    queue_as :default
+
+    def perform(creative_id, topic_id, user_id, extra_prompt = nil)
+      creative = Creative.find(creative_id)
+      topic = Topic.find(topic_id)
+      user = User.find(user_id)
+
+      # Collect all comments in topic (chronological), excluding /compress command
+      all_comments = creative.comments
+        .where(topic_id: topic_id)
+        .order(created_at: :asc)
+        .includes(:user)
+
+      # Separate: comments to summarize vs the compress command itself
+      compress_pattern = /\A\/compress\b/i
+      target_comments = all_comments.reject { |c| c.content.to_s.strip.match?(compress_pattern) }
+
+      return if target_comments.size < 2
+
+      # Build conversation text
+      conversation = target_comments.map do |c|
+        author = c.user&.name || I18n.t("collavre.comments.anonymous")
+        "#{author}: #{c.content}"
+      end.join("\n\n")
+
+      # Build AI prompt
+      system_prompt = Comments::CompressCommand::SYSTEM_PROMPT.dup
+      if extra_prompt.present?
+        system_prompt += "\n\nAdditional instruction from the user: #{extra_prompt}"
+      end
+
+      # Find an AI agent on this creative, or use default config
+      agent = find_ai_agent(creative)
+
+      client = AiClient.new(
+        vendor: agent&.llm_vendor || default_vendor,
+        model: agent&.llm_model || default_model,
+        system_prompt: system_prompt,
+        llm_api_key: agent&.llm_api_key || agent&.creator&.llm_api_key
+      )
+
+      summary = String.new
+      client.chat([ { role: "user", text: conversation } ]) do |delta|
+        summary << delta
+      end
+
+      if summary.blank?
+        Rails.logger.error("[CompressJob] AI returned empty summary for topic #{topic_id}")
+        return
+      end
+
+      # Create summary comment
+      topic_name = topic.name.presence || "Topic"
+      title = I18n.t("collavre.comments.compress_command.summary_title", topic: topic_name)
+      summary_content = "**#{title}**\n\n#{summary}"
+
+      # Store comment IDs to delete before creating the new one (all originals including /compress command)
+      comment_ids_to_delete = all_comments.pluck(:id)
+
+      # Create the summary comment in the same topic
+      summary_comment = creative.comments.create!(
+        user: user,
+        topic_id: topic_id,
+        content: summary_content
+      )
+
+      # Delete original comments (excluding the newly created summary)
+      creative.comments.where(id: comment_ids_to_delete).destroy_all
+    rescue ActiveRecord::RecordNotFound => e
+      Rails.logger.error("[CompressJob] Record not found: #{e.message}")
+    end
+
+    private
+
+    def find_ai_agent(creative)
+      # Look for an AI agent with access to this creative
+      creative.effective_origin.all_shared_users(:feedback)
+        .map(&:user)
+        .find(&:ai_user?)
+    end
+
+    def default_vendor
+      "google"
+    end
+
+    def default_model
+      "gemini-3-flash-preview"
+    end
+  end
+end

data/app/models/collavre/comment.rb

@@ -15,8 +15,20 @@ module Collavre
     belongs_to :action_executed_by, class_name: Collavre.configuration.user_class_name, optional: true
     belongs_to :topic, class_name: "Collavre::Topic", optional: true
     belongs_to :quoted_comment, class_name: "Collavre::Comment", optional: true
+
+    # review_type: nil = normal chat, 0 = review, 1 = question
+    enum :review_type, { review: 0, question: 1 }, prefix: true
+
+    # Must run before dependent: :destroy on comment_versions to clear FK
+    before_destroy :nullify_selected_version
+
     has_many :activity_logs, class_name: "Collavre::ActivityLog", dependent: :destroy
     has_many :comment_reactions, class_name: "Collavre::CommentReaction", dependent: :destroy
+    has_many :comment_versions, class_name: "Collavre::CommentVersion", dependent: :destroy
+    has_many :review_versions, class_name: "Collavre::CommentVersion", foreign_key: :review_comment_id, dependent: :nullify
+    has_many :inbox_items, class_name: "Collavre::InboxItem", dependent: :nullify
+    has_many :quoting_comments, class_name: "Collavre::Comment", foreign_key: :quoted_comment_id, dependent: :destroy
+    belongs_to :selected_version, class_name: "Collavre::CommentVersion", optional: true
 
     has_many_attached :images, dependent: :purge_later
 
@@ -36,8 +48,12 @@ module Collavre
 
     after_destroy_commit :cancel_pending_tasks
 
+    def next_version_number
+      (comment_versions.maximum(:version_number) || 0) + 1
+    end
+
     def review_message?
-      quoted_comment_id.present?
+      quoted_comment_id.present? && !review_type_question?
     end
 
     # public for db migration
@@ -47,12 +63,31 @@ module Collavre
 
     private
 
+    def nullify_selected_version
+      update_column(:selected_version_id, nil) if selected_version_id.present?
+    end
+
     def cancel_pending_tasks
+      # Cancel tasks triggered by this comment
       Task.where(status: %w[pending running queued]).each do |task|
         if task.trigger_event_payload&.dig("comment", "id") == id
           task.update!(status: "cancelled")
         end
       end
+
+      # Cancel queued tasks when their waiting notice (system comment) is deleted
+      cancel_queued_tasks_for_waiting_notice if waiting_notice?
+    end
+
+    def waiting_notice?
+      user_id.nil? && content&.start_with?("⏳")
+    end
+
+    def cancel_queued_tasks_for_waiting_notice
+      scope = Task.where(status: "queued", creative_id: creative_id)
+      scope = topic_id ? scope.where(topic_id: topic_id) : scope.where(topic_id: nil)
+      task = scope.order(created_at: :desc).first
+      task&.update!(status: "cancelled")
     end
 
     def assign_default_user

data/app/models/collavre/comment_version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Collavre
+  class CommentVersion < ApplicationRecord
+    self.table_name = "comment_versions"
+
+    belongs_to :comment, class_name: "Collavre::Comment"
+    belongs_to :review_comment, class_name: "Collavre::Comment", optional: true
+
+    validates :content, presence: true
+    validates :version_number, presence: true,
+                               uniqueness: { scope: :comment_id },
+                               numericality: { only_integer: true, greater_than: 0 }
+  end
+end

data/app/models/collavre/creative/describable.rb

@@ -26,7 +26,7 @@ module Collavre
       end
 
       def creative_snippet
-        ActionController::Base.helpers.strip_tags(effective_origin.description || "").truncate(24, omission: "...")
+        CGI.unescapeHTML(ActionController::Base.helpers.strip_tags(effective_origin.description || "")).truncate(24, omission: "...")
       end
 
       private

data/app/models/collavre/creative.rb

@@ -36,6 +36,34 @@ module Collavre
     has_many :calendar_events, class_name: "Collavre::CalendarEvent", dependent: :destroy
     has_many :labels, class_name: "Collavre::Label", dependent: :destroy
 
+    # Returns IDs of creatives that have at least one active share and are
+    # accessible by the given user (owned or shared with/by them).
+    # Includes linked creatives whose origin has shares.
+    def self.shared_accessible_ids(user)
+      own_ids = where(user_id: user.id).pluck(:id)
+      shared_ids = CreativeShare
+        .where.not(permission: :no_access)
+        .where("user_id = :uid OR shared_by_id = :uid", uid: user.id)
+        .pluck(:creative_id)
+
+      accessible_ids = (own_ids | shared_ids).uniq
+
+      # Direct shares on accessible creatives
+      directly_shared = CreativeShare
+        .where(creative_id: accessible_ids)
+        .where.not(permission: :no_access)
+        .pluck(:creative_id)
+
+      # Linked creatives whose origin has shares
+      origin_shared = where(id: accessible_ids)
+        .where.not(origin_id: nil)
+        .joins("INNER JOIN creative_shares ON creative_shares.creative_id = creatives.origin_id")
+        .where.not(creative_shares: { permission: :no_access })
+        .pluck(:id)
+
+      (directly_shared | origin_shared).uniq
+    end
+
     validates :progress, numericality: { greater_than_or_equal_to: 0.0, less_than_or_equal_to: 1.0 }, unless: -> { origin_id.present? }
 
     validate :progress_cannot_change_if_has_origin, on: :update
@@ -46,6 +74,29 @@ module Collavre
     after_destroy :update_parent_progress
     after_save :update_mcp_tools
 
+    # --- Context IDs ---
+    # Returns the directly-configured context creative IDs for this creative.
+    def context_ids
+      Array(data&.dig("context_ids"))
+    end
+
+    # Returns the effective context IDs: own + inherited from ancestors (deduplicated).
+    def effective_context_ids(visited_ids = Set.new)
+      return [] if visited_ids.include?(id)
+
+      visited_ids.add(id)
+      own = context_ids
+      parent_ctx = parent&.effective_context_ids(visited_ids) || []
+      (own + parent_ctx).uniq
+    end
+
+    # Returns context creatives (excludes self to avoid duplication).
+    def context_creatives
+      ids = effective_context_ids
+      ids -= [ id ]
+      Creative.where(id: ids)
+    end
+
     # Compatibility helper: ancestry gem exposes `subtree_ids`, while
     # closure_tree typically uses `self_and_descendants`.
     def subtree_ids

data/app/models/collavre/task.rb

@@ -4,10 +4,38 @@ module Collavre
 
     belongs_to :agent, class_name: "Collavre::User"
     has_many :task_actions, class_name: "Collavre::TaskAction", dependent: :destroy
+    belongs_to :parent_task, class_name: "Collavre::Task", optional: true
+    has_many :sub_tasks, class_name: "Collavre::Task", foreign_key: :parent_task_id, dependent: :destroy
+    belongs_to :creative, class_name: "Collavre::Creative", optional: true
 
     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) }
+    scope :running_for_topic, ->(topic_id, creative_id = nil) {
+      rel = where(topic_id: topic_id, status: "running")
+      rel = rel.where(creative_id: creative_id) if creative_id
+      rel
+    }
+    scope :queued_for_topic, ->(topic_id, creative_id = nil) {
+      rel = where(topic_id: topic_id, status: "queued")
+      rel = rel.where(creative_id: creative_id) if creative_id
+      rel.order(:created_at)
+    }
+
+    # Check if agent already has a running task triggered by the same comment
+    def self.duplicate_running_for_comment?(agent_id, comment_id)
+      where(agent_id: agent_id, status: "running", trigger_event_name: "comment_created")
+        .find_each do |task|
+        return true if task.trigger_event_payload&.dig("comment", "id").to_s == comment_id.to_s
+      end
+      false
+    end
+
+    def workflow_parent?
+      workflow_state.present? && parent_task_id.nil?
+    end
+
+    def all_sub_tasks_done?
+      sub_tasks.where.not(status: %w[done cancelled]).empty?
+    end
   end
 end

data/app/models/collavre/user.rb

@@ -39,8 +39,9 @@ module Collavre
                                  dependent: :nullify, inverse_of: :approver
     has_many :comment_reactions, class_name: "Collavre::CommentReaction", dependent: :destroy
 
-    # Creatives must be destroyed AFTER all associations that reference them
-    has_many :creatives, class_name: "Collavre::Creative", dependent: :destroy
+    # Leaf-first destroy to avoid closure_tree find(parent_id) errors
+    has_many :creatives, class_name: "Collavre::Creative", dependent: nil
+    before_destroy :destroy_creatives_leaf_first
 
     belongs_to :creator, class_name: "Collavre::User", foreign_key: "created_by_id", optional: true
     has_many :created_ai_users, class_name: "Collavre::User", foreign_key: "created_by_id", dependent: :destroy
@@ -131,7 +132,7 @@ module Collavre
     end
 
     SUPPORTED_LLM_MODELS = [
-      "gemini-2.5-flash",
+      "gemini-3-flash-preview",
       "gemini-1.5-flash",
       "gemini-1.5-pro"
     ].freeze
@@ -140,6 +141,14 @@ module Collavre
       llm_vendor.present?
     end
 
+    scope :ai_agents, -> { where.not(llm_vendor: [ nil, "" ]) }
+
+    def self.accessible_ai_agents_for(user)
+      owned = ai_agents.where(created_by_id: user.id)
+      searchable = ai_agents.where(searchable: true)
+      owned.or(searchable).distinct.order(:name)
+    end
+
     def self.mentionable_for(creative)
       scope = where(searchable: true)
       return scope unless creative
@@ -226,5 +235,13 @@ module Collavre
         errors.add(:theme, "is invalid")
       end
     end
+
+    # Destroy creatives deepest-first so closure_tree always finds its parent
+    def destroy_creatives_leaf_first
+      all_creatives = creatives.flat_map { |c| c.self_and_descendants.to_a }.uniq
+      all_creatives.sort_by { |c| -c.self_and_ancestors.count }.each do |c|
+        c.reload.destroy! if Creative.exists?(c.id)
+      end
+    end
   end
 end

data/app/services/collavre/ai_agent/a2a_dispatcher.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Collavre
+  module AiAgent
+    # Handles agent-to-agent (A2A) orchestration dispatch.
+    # Detects mentioned agents, records interactions for loop prevention,
+    # and dispatches system events for downstream processing.
+    class A2aDispatcher
+      def initialize(agent:, reply_comment:, context:)
+        @agent = agent
+        @reply_comment = reply_comment
+        @context = context
+      end
+
+      # Dispatch A2A events if the response mentions any AI agents
+      def dispatch
+        return unless @reply_comment&.content.present?
+
+        mentioned_agents = find_mentioned_agents
+        return if mentioned_agents.empty?
+
+        creative = @reply_comment.creative
+        record_interactions(mentioned_agents, creative)
+        dispatch_event(creative)
+      rescue StandardError => e
+        Rails.logger.error("[AiAgent::A2aDispatcher] A2A dispatch failed: #{e.message}")
+      end
+
+      private
+
+      def find_mentioned_agents
+        MentionParser.resolve_all_users(@reply_comment.content).select(&:ai_user?)
+      end
+
+      def record_interactions(mentioned_agents, creative)
+        return unless creative
+
+        mentioned_agents.each do |mentioned_user|
+          context = {
+            "creative" => { "id" => creative.id },
+            "topic" => { "id" => @reply_comment.topic_id }
+          }
+          Orchestration::LoopBreaker.new(context).record_interaction(
+            @agent.id,
+            mentioned_user.id,
+            creative.id
+          )
+        end
+      end
+
+      def dispatch_event(creative)
+        SystemEvents::Dispatcher.dispatch("comment_created", {
+          comment: {
+            id: @reply_comment.id,
+            content: @reply_comment.content,
+            user_id: @reply_comment.user_id
+          },
+          creative: {
+            id: creative&.id,
+            description: creative&.description
+          },
+          topic: { id: @reply_comment.topic_id },
+          chat: { content: @reply_comment.content }
+        })
+      end
+    end
+  end
+end