collavre 0.24.0 → 0.25.0

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

@@ -38,12 +38,12 @@ module Collavre
       end
 
       # Main entry point - checks all loop conditions
-      def check
+      def check(prospective_interaction: nil)
         return Result.new(should_break: false, reason: nil, details: {}) unless enabled?
 
         # Check each condition
         checks = [
-          check_ping_pong,
+          check_ping_pong(prospective_interaction),
           check_creative_retry,
           check_task_timeout,
           check_token_spike
@@ -110,13 +110,14 @@ module Collavre
       end
 
       # Detect ping-pong between agents
-      def check_ping_pong
+      def check_ping_pong(prospective_interaction)
         creative_id = @context.dig("creative", "id")
         return safe_result unless creative_id
 
         # Check the ping-pong tracking key for this creative
         key = "#{CACHE_PREFIX}:ping_pong_history:#{creative_id}"
-        interactions = Rails.cache.read(key) || []
+        interactions = Array(Rails.cache.read(key)).dup
+        interactions << prospective_interaction_entry(prospective_interaction) if prospective_interaction
 
         # Count exchanges for each agent pair
         pair_exchanges = count_pair_exchanges(interactions)
@@ -139,6 +140,11 @@ module Collavre
         safe_result
       end
 
+      def prospective_interaction_entry(interaction)
+        edge = interaction.with_indifferent_access
+        { at: Time.current.to_i, from: edge[:from_agent_id], to: edge[:to_agent_id] }
+      end
+
       # Detect too many tasks on same topic (per-topic, not per-creative)
       def check_creative_retry
         creative_id = @context.dig("creative", "id")

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

@@ -8,13 +8,53 @@ module Collavre
     # 1. Mention-based: If a user is @mentioned, route exclusively to that user
     #    - If mentioned user is AI agent → route to that agent only
     #    - If mentioned user is human → no AI agents respond
-    # 2. Expression-based: Evaluate each agent's routing_expression (Liquid)
+    # 2. Primary-agent assignment: If the topic has a primary_agent, that agent is
+    #    the topic's sole ambient responder (see #match_by_primary_agent)
+    # 3. Expression-based: Evaluate each agent's routing_expression (Liquid)
     #
     # Permission checks:
     # - All agents need feedback permission on the creative to respond
     # - searchable only affects discoverability, not response permission
     #
     class Matcher
+      # The one entry point for "may this agent answer, given the topic's
+      # primary-agent assignment?", taking a raw trigger payload.
+      #
+      # Three paths re-ask this question about a waiting task — promotion
+      # (AgentOrchestrator.revalidate_assignment!), the resumed AiAgentJob, and
+      # approval resumption through it — and each one cancels the task on a
+      # "no". They must ask the same question, because a direct @mention
+      # outranks the assignment and coalescing moves that mention out of the
+      # anchor and into "merged_comment_ids": judging the anchor alone cancels a
+      # task that WAS explicitly addressed, and discards every comment it had
+      # absorbed along with it. The mention still reaches the agent
+      # (MergedTriggerComments folds it into the trigger), so it still counts.
+      def self.permits_assignment?(context, agent)
+        return true if new(SystemEvents::ContextBuilder.new(context).build)
+                       .assignment_permits?(agent)
+
+        merged_ids = Array(context[TaskCoalescer::PAYLOAD_KEY]).compact
+        return false if merged_ids.empty?
+
+        # Scoped to the turn, through the same predicate that decides what is
+        # delivered. A merged mention moved to another creative while the task
+        # waited is deliberately kept out of the trigger, so it cannot also be
+        # the reason the turn is permitted: that would let a non-primary agent
+        # answer an ambient anchor with no in-scope mention anywhere.
+        AiAgent::MergedTriggerComments.in_turn(merged_ids, context).pluck(:content).any? do |content|
+          probe = context.merge("chat" => { "content" => content })
+          new(SystemEvents::ContextBuilder.new(probe).build).assignment_permits?(agent)
+        end
+      end
+
+      # The permission every routing path in #match is gated on, asked on its
+      # own — for a caller that names its agent instead of matching one.
+      # DeliveryRecord.restore! is that caller: it puts back the dispatch this
+      # matcher once produced, and nothing else on its way re-asks this.
+      def self.permits_creative_access?(context, agent)
+        new(SystemEvents::ContextBuilder.new(context).build).has_creative_permission?(agent)
+      end
+
       def initialize(context)
         @context = context
       end
@@ -29,10 +69,60 @@ module Collavre
         mentioned_result = match_by_mention
         return mentioned_result unless mentioned_result.nil?
 
-        # Priority 2: Liquid expression routing (fallback)
+        # Priority 2: Topic primary agent assignment (exclusive)
+        primary_result = match_by_primary_agent
+        return primary_result unless primary_result.nil?
+
+        # Priority 3: Liquid expression routing (fallback)
         match_by_expression
       end
 
+      # May this agent still take the floor in this topic, given the topic's
+      # CURRENT primary-agent assignment?
+      #
+      # #match runs when an event is dispatched, but the agent it selects can
+      # reach execution much later: a :deferred decision parks a queued Task
+      # until the topic's blocker finishes, and a :delayed one sleeps in the job
+      # queue. Neither path re-matches — AiAgentJob#perform runs the agent the
+      # decision named — so an assignment created or moved during that window
+      # would be bypassed by work scheduled moments before it, and a demoted
+      # agent would speak in a topic that is now exclusively someone else's.
+      #
+      # Mirrors #match's precedence rather than re-deriving it: review and
+      # mention are exclusive routings that outrank the assignment (see
+      # #match_by_primary_agent), so those dispatches stay valid. Expression
+      # routing does not, so it is revalidated. Only the assignment is rechecked
+      # here — re-running the whole match would also re-evaluate each
+      # routing_expression against the refreshed comment, silently dropping
+      # deferred work for reasons that have nothing to do with the assignment.
+      def assignment_permits?(agent)
+        primary_id = matched_topic&.primary_agent_id
+        return true if primary_id.nil? || primary_id == agent.id
+
+        # A review can only ever be applied in place by the author of the quoted
+        # comment; no assignment can transfer it, so the alternative to running
+        # it is not "the primary answers instead" but a dead Review button.
+        return true if matched_comment&.review_message? &&
+          matched_comment.quoted_comment&.user_id == agent.id
+
+        mentioned_id = @context.dig("chat", "mentioned_user", "id") ||
+          @context.dig(:chat, :mentioned_user, :id)
+        mentioned_id.present? && mentioned_id.to_i == agent.id
+      end
+
+      # Public because #match is not the only door onto a dispatch: a restore
+      # names the agent the match once produced, and this is the gate every
+      # branch of #match shares. One predicate, so the two doors cannot come to
+      # disagree about what "may answer this creative" means.
+      def has_creative_permission?(agent)
+        # All agents need feedback permission on the creative to respond
+        # searchable only affects discoverability, not response permission
+        creative = matched_creative
+        return false unless creative
+
+        creative.has_permission?(agent, :feedback)
+      end
+
       private
 
       # Returns [author] for a routable review message, [] for an unroutable one,
@@ -92,26 +182,60 @@ module Collavre
         [ mentioned_user ]
       end
 
+      # Returns [primary_agent] when the topic has one, nil when it does not.
+      #
+      # A topic's primary agent is an exclusive assignment: it is the only agent
+      # that speaks on ambient events in that topic. This deliberately overrides
+      # each agent's own routing_expression in BOTH directions:
+      #
+      # - The primary speaks even with no routing_expression (or one that
+      #   evaluates false), so pinning an agent is enough to talk to it.
+      # - Every other agent stays silent even when its expression matches, so a
+      #   project-wide roster of agents does not all pile into one task.
+      #
+      # Other agents are not muted, only demoted to explicit invitation: an
+      # @mention routes to them via #match_by_mention, which runs first.
+      #
+      # Returning [] (rather than nil) when the primary is ineligible is
+      # intentional — falling through to expression routing would let exactly
+      # the agents this assignment excludes take the floor instead.
+      def match_by_primary_agent
+        agent = matched_topic&.primary_agent
+        return nil unless agent
+
+        return [] unless agent.ai_user?
+        return [] unless has_creative_permission?(agent)
+        return [] unless eligible_in_inbox?(agent)
+
+        [ agent ]
+      end
+
       def match_by_expression
-        # Find all AI agents with routing expressions
-        # Order by id for consistent ordering (important for round_robin strategy)
-        agents = User.where.not(llm_vendor: nil).where.not(routing_expression: [ nil, "" ]).order(:id)
+        # A Claude Channel agent is ambiently routable only while its cable
+        # subscription has a live presence row. Its routing_expression remains
+        # available for an explicitly configured Liquid rule, but is never used
+        # as a session-liveness flag.
+        live_claude_agent_ids = AgentSubscription.live.pluck(:agent_id)
+        expression_agents = User.where.not(llm_vendor: nil)
+                                .where.not(routing_expression: [ nil, "" ])
+        agents = expression_agents.or(User.where(id: live_claude_agent_ids)).order(:id)
 
         agents.select do |agent|
           next false unless has_creative_permission?(agent)
           next false unless eligible_in_inbox?(agent)
+          next false if agent.claude_channel_agent? && !live_claude_agent_ids.include?(agent.id)
 
-          evaluate_routing_expression(agent)
+          agent.routing_expression.blank? || evaluate_routing_expression(agent)
         end
       end
 
       # A Claude Channel session agent holds inbox-wide :feedback +
-      # routing_expression="true", so within the user's Inbox it would otherwise
+      # a live presence row, so within the user's Inbox it would otherwise
       # match EVERY topic. Confine it to its own registered session topic (the
       # topic it is primary_agent on, carrying a session_id) so ordinary inbox
       # topics — Main, Content, user threads — stay identical to a normal topic
       # and are never absorbed by a live session. Only the inbox is affected: on
-      # work/project creatives the agent still matches via routing_expression.
+      # work/project creatives the agent still matches while it is live.
       def eligible_in_inbox?(agent)
         return true unless matched_creative&.inbox?
         return true unless agent.claude_channel_agent?
@@ -139,15 +263,6 @@ module Collavre
         false
       end
 
-      def has_creative_permission?(agent)
-        # All agents need feedback permission on the creative to respond
-        # searchable only affects discoverability, not response permission
-        creative = matched_creative
-        return false unless creative
-
-        creative.has_permission?(agent, :feedback)
-      end
-
       def matched_creative
         return @matched_creative if defined?(@matched_creative)
 

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

@@ -28,6 +28,13 @@ module Collavre
           "rate_limit_per_minute" => 20,
           "backoff_strategy" => "exponential",
           "topic_max_concurrent_jobs" => 1,
+          # Fold un-started tasks for the same agent/topic/creative into one so a
+          # burst of comments produces one answer instead of one per comment.
+          "coalesce_pending_tasks" => true,
+          # Drop a dispatch whose comment an in-flight turn has already been
+          # given, instead of parking it as a waiter (see
+          # Orchestration::DeliveryRecord).
+          "drop_delivered_dispatches" => true,
           # Loop breaker settings
           "loop_breaker_enabled" => true,
           "ping_pong_threshold" => 5,           # Max back-and-forth between same agents
@@ -38,9 +45,8 @@ module Collavre
           "token_spike_window_minutes" => 10
         },
         "stuck_detection" => {
-          "enabled" => false,
+          "enabled" => true,
           "task_stuck_threshold_minutes" => 30,            # Task running for > N minutes
-          "creative_stall_threshold_minutes" => 120,       # Creative no progress for > N minutes
           "queued_orphan_threshold_minutes" => 5,          # Queued waiter with no live blocker for > N minutes
           "create_system_comment" => true                  # Create system comment on escalation
         },
@@ -87,6 +93,43 @@ module Collavre
         scheduling_config["topic_max_concurrent_jobs"]
       end
 
+      # Whether un-started tasks for the same agent/topic/creative are folded
+      # into a single one (see Orchestration::TaskCoalescer).
+      #
+      # Resolved per agent, because that is the granularity of the thing being
+      # switched: coalescing folds *same-agent* siblings, and a User-scoped
+      # scheduling policy is how an administrator turns it off for one agent
+      # without touching the others in the topic. #scheduling_config excludes
+      # agent policies by construction, so asking it here silently ignored that
+      # opt-out on every enqueue, promotion, start and notice path.
+      #
+      # There is deliberately no agent-less variant to fall back to: a second
+      # door onto this question is how the two answers drift, and every caller
+      # has the agent to hand. `nil` is accepted only for a dispatch with no
+      # agent resolved yet, where the global answer is the only one there is.
+      def coalesce_pending_tasks_for?(agent)
+        config = agent ? scheduling_config_for(agent) : scheduling_config
+        config["coalesce_pending_tasks"] != false
+      end
+
+      # Whether a dispatch is dropped outright when an in-flight turn has
+      # already delivered its comment (see Orchestration::DeliveryRecord).
+      #
+      # Resolved per agent for the same reason coalescing is: delivery is a
+      # same-agent question, and a User-scoped scheduling policy is how an
+      # administrator turns this off for one agent without touching the others
+      # in the topic.
+      #
+      # Only the *drop* is switched. The record itself keeps being written
+      # whatever this says — it is evidence of what an agent was sent, and the
+      # promotion door reads it to keep a parked waiter from replaying a
+      # delivered comment. Gating the write here would make turning the switch
+      # off mid-burst leave that door reading a record with a hole in it.
+      def drop_delivered_dispatches_for?(agent)
+        config = agent ? scheduling_config_for(agent) : scheduling_config
+        config["drop_delivered_dispatches"] != false
+      end
+
       # Convenience methods
       def arbitration_strategy
         return "primary_first" if topic_primary_agent_id.present?
@@ -102,6 +145,19 @@ module Collavre
         topic_primary_agent_id || arbitration_config["primary_agent_id"]
       end
 
+      # Read primary_agent_id directly from the topics table.
+      #
+      # Public because the two sources of a primary agent carry different
+      # strength: a topic-column assignment is exclusive, while a policy-level
+      # primary_agent_id is only a preference. The Arbiter needs to tell them
+      # apart even though #primary_agent_id collapses both.
+      def topic_primary_agent_id
+        topic_id = @context.dig("topic", "id")
+        return nil unless topic_id
+
+        Topic.where(id: topic_id).pick(:primary_agent_id)
+      end
+
       # Bid strategy specific
       def confidence_threshold
         arbitration_config["confidence_threshold"]
@@ -163,14 +219,6 @@ module Collavre
 
         config
       end
-
-      # Read primary_agent_id directly from the topics table
-      def topic_primary_agent_id
-        topic_id = @context.dig("topic", "id")
-        return nil unless topic_id
-
-        Topic.where(id: topic_id).pick(:primary_agent_id)
-      end
     end
   end
 end

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

@@ -31,10 +31,10 @@ module Collavre
       # @param agents [Array<User>] Agents selected by Arbiter
       # @return [Array<Hash>] Scheduling decisions
       #   Each decision: { agent:, timing:, delay: (optional), reason: (optional) }
-      def schedule(agents)
+      def schedule(agents, scheduling_hooks: nil)
         topic_immediate_count = 0
         agents.map do |agent|
-          decision = evaluate(agent, topic_immediate_count: topic_immediate_count)
+          decision = evaluate(agent, topic_immediate_count: topic_immediate_count, scheduling_hooks: scheduling_hooks)
           topic_immediate_count += 1 if decision[:timing] == :immediate
           decision
         end
@@ -42,13 +42,13 @@ module Collavre
 
       private
 
-      def evaluate(agent, topic_immediate_count: 0)
+      def evaluate(agent, topic_immediate_count: 0, scheduling_hooks: nil)
         tracker = ResourceTracker.for(agent)
         config = @policy_resolver.scheduling_config_for(agent)
 
         # Check 0: Loop breaker
         if @policy_resolver.loop_breaker_enabled?
-          loop_result = LoopBreaker.new(@context, policy_resolver: @policy_resolver).check
+          loop_result = loop_breaker_result(agent, scheduling_hooks)
           if loop_result.should_break?
             return loop_broken_decision(agent, loop_result)
           end
@@ -86,6 +86,12 @@ module Collavre
         immediate_decision(agent)
       end
 
+      def loop_breaker_result(agent, scheduling_hooks)
+        LoopBreaker.new(@context, policy_resolver: @policy_resolver).check(
+          prospective_interaction: scheduling_hooks&.interaction_for(agent)
+        )
+      end
+
       def immediate_decision(agent)
         {
           agent: agent,

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Collavre
+  module Orchestration
+    SchedulingHooks = Data.define(:interaction_callback, :scheduled_callback) do
+      def interaction_for(agent) = interaction_callback&.call(agent)
+      def scheduled(agents) = scheduled_callback&.call(agents)
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Collavre
+  module Orchestration
+    # Resolves the exact responders for an event without scheduling work.
+    class Selection
+      attr_reader :agents
+
+      def initialize(context, policy_resolver:, candidate_overrides: {})
+        @context = context
+        @policy_resolver = policy_resolver
+        @candidate_overrides = candidate_overrides
+      end
+
+      def call
+        candidates = candidates_for_contexts
+        @agents = [] if candidates.empty?
+        return self if candidates.empty?
+
+        @arbiter = Arbiter.new(@context, policy_resolver: @policy_resolver)
+        @agents = @arbiter.select(candidates, commit: false)
+        self
+      end
+
+      def commit!
+        @arbiter&.commit_selection!
+        self
+      end
+
+      private
+
+      def candidates_for_contexts
+        candidates = Matcher.new(@context).match
+        @candidate_overrides.each do |agent_id, override|
+          candidates = candidates.reject { |agent| agent.id == agent_id }
+          overridden = Matcher.new(@context.deep_merge(override.deep_stringify_keys)).match
+          candidates.concat(overridden.select { |agent| agent.id == agent_id })
+        end
+        candidates.uniq(&:id).sort_by(&:id)
+      end
+    end
+  end
+end

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

@@ -2,15 +2,14 @@
 
 module Collavre
   module Orchestration
-    # StuckDetector detects stuck tasks and creatives, then auto-escalates to admins.
+    # StuckDetector detects stuck tasks, auto-recovers them, and 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
+    # - Creates inbox comments for admin users
     # - Optionally creates a system comment
     #
     class StuckDetector
@@ -33,7 +32,6 @@ module Collavre
         stuck_items = []
         stuck_items.concat(detect_stuck_tasks(config))
         stuck_items.concat(detect_orphaned_queued_tasks(config))
-        stuck_items.concat(detect_stalled_creatives(config))
 
         auto_recover_stuck_tasks(stuck_items)
         escalated_count = escalate_stuck_items(stuck_items, config)
@@ -49,7 +47,6 @@ module Collavre
         stuck_items = []
         stuck_items.concat(detect_stuck_tasks(config))
         stuck_items.concat(detect_orphaned_queued_tasks(config))
-        stuck_items.concat(detect_stalled_creatives(config))
         stuck_items
       end
 
@@ -133,7 +130,14 @@ module Collavre
         task = stuck_item.item
         return unless %w[running delegated].include?(task.status)
 
-        task.update!(status: "failed")
+        recovered = if task.status == "running"
+          DeliveryRecord.fail_while_worker_settles!(task)
+        else
+          task.update!(status: "failed")
+          true
+        end
+        return unless recovered
+
         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"
@@ -145,23 +149,6 @@ module Collavre
           tracker.release!(task.id)
         end
 
-        # If this was a workflow subtask, fail the parent so the workflow
-        # advances instead of staying running with pending_creative_ids
-        # pointing at a child that's been failed underneath it.
-        if task.parent_task_id.present?
-          begin
-            Collavre::Comments::WorkflowExecutor.new(task.parent_task).fail_subtask!(
-              task,
-              error_message: "Auto-recovered: stuck for " \
-                             "#{((Time.current - stuck_item.stuck_since) / 60).round} minutes"
-            )
-          rescue StandardError => e
-            Rails.logger.error(
-              "[StuckDetector] fail_subtask! failed for task #{task.id}: #{e.message}"
-            )
-          end
-        end
-
         # Drain the queue for the topic so waiting tasks can execute
         AgentOrchestrator.dequeue_next_for_topic(task.topic_id, task.creative_id)
       rescue StandardError => e
@@ -184,7 +171,6 @@ module Collavre
                           .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)
@@ -232,45 +218,6 @@ module Collavre
         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)
-                .includes(creative_shares: :user)
-                .find_each do |creative|
-          # Skip if no AI agents have access
-          ai_agents = creative.creative_shares
-                              .reject { |s| s.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")
@@ -287,7 +234,7 @@ module Collavre
         ancestor_ids = [ creative.id ] + creative.ancestor_ids
         admin_users = CreativeShare.where(creative_id: ancestor_ids, permission: "admin")
                                    .includes(:user)
-                                   .filter_map { |share| share.user unless share.user.ai_user? }
+                                   .filter_map { |share| share.user if share.user && !share.user.ai_user? }
 
         # Also include the creative owner
         admin_users << creative.user if creative.user && !creative.user.ai_user?
@@ -301,18 +248,9 @@ module Collavre
         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)
+        Rails.cache.write("stuck_detector:task:#{item.item.id}", true, expires_in: 1.hour)
       end
 
       def escalate_stuck_items(stuck_items, config)
@@ -339,9 +277,7 @@ module Collavre
         end
 
         # Optionally create a system comment
-        if config["create_system_comment"] && stuck_item.type == :task
-          create_system_comment(stuck_item)
-        end
+        create_system_comment(stuck_item) if config["create_system_comment"]
 
         true
       rescue StandardError => e
@@ -352,13 +288,8 @@ module Collavre
       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
+        creative_id = stuck_item.item.trigger_event_payload&.dig("creative", "id")
+        creative = Creative.find_by(id: creative_id)
 
         inbox_creative = Creative.inbox_for(owner)
         system_topic = inbox_creative.system_topic(fallback_user: owner)
@@ -377,37 +308,19 @@ module Collavre
       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.creative_snippet,
-              hours: hours_stuck,
-              progress: ((creative.progress || 0) * 100).round
-            }
-          ]
-        end
+        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
+          }
+        ]
       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)