collavre 0.22.0 → 0.24.0

data/app/services/collavre/markdown_importer.rb

@@ -20,6 +20,12 @@ module Collavre
         end
       end
       created = []
+      # Per-parent sequence counters. closure_tree orders siblings by the
+      # `sequence` column (default 0), but plain Creative.create never assigns
+      # it — so without this every imported sibling would share sequence 0 and
+      # fall back to a DB-defined tie-break (stable on SQLite, arbitrary on
+      # Postgres), corrupting document order. Assign contiguous values here.
+      seq = {}
       root = parent
       i = 0
       if create_root
@@ -28,7 +34,7 @@ module Collavre
         end
         if i < lines.size && lines[i] !~ /^\s*#/ && lines[i] !~ /^\s*[-*+]/
           page_title = lines[i].strip
-          root = Creative.create(user: user, parent: parent, description: page_title)
+          root = create_child(user: user, parent: parent, description: page_title, seq: seq)
           created << root
           i += 1
         end
@@ -73,7 +79,7 @@ module Collavre
           code_html = build_code_block_html(code_content, fence_info)
 
           new_parent = stack.any? ? stack.last[1] : root
-          c = Creative.create(user: user, parent: new_parent, description: code_html)
+          c = create_child(user: user, parent: new_parent, description: code_html, seq: seq)
           created << c
           next
         end
@@ -81,7 +87,7 @@ module Collavre
         if (table_data = parse_markdown_table(lines, i))
           table_html = build_table_html(table_data, image_refs)
           new_parent = stack.any? ? stack.last[1] : root
-          c = Creative.create(user: user, parent: new_parent, description: table_html)
+          c = create_child(user: user, parent: new_parent, description: table_html, seq: seq)
           created << c
           i = table_data[:next_index]
         elsif line =~ /^(#+)\s+(.*)$/
@@ -89,7 +95,7 @@ module Collavre
           desc = ApplicationController.helpers.markdown_links_to_html($2.strip, image_refs)
           stack.pop while stack.any? && stack.last[0] >= level
           new_parent = stack.any? ? stack.last[1] : root
-          c = Creative.create(user: user, parent: new_parent, description: desc)
+          c = create_child(user: user, parent: new_parent, description: desc, seq: seq)
           created << c
           stack << [ level, c ]
           i += 1
@@ -99,14 +105,14 @@ module Collavre
           bullet_level = 10 + indent / 2
           stack.pop while stack.any? && stack.last[0] >= bullet_level
           new_parent = stack.any? ? stack.last[1] : root
-          c = Creative.create(user: user, parent: new_parent, description: desc)
+          c = create_child(user: user, parent: new_parent, description: desc, seq: seq)
           created << c
           stack << [ bullet_level, c ]
           i += 1
         elsif !line.strip.empty?
           desc = ApplicationController.helpers.markdown_links_to_html(line.strip, image_refs)
           new_parent = stack.any? ? stack.last[1] : root
-          c = Creative.create(user: user, parent: new_parent, description: desc)
+          c = create_child(user: user, parent: new_parent, description: desc, seq: seq)
           created << c
           i += 1
         else
@@ -121,6 +127,24 @@ module Collavre
       created
     end
 
+    # Creates a child under `parent` with an explicit `sequence`, tracking the
+    # next value per parent in `seq`. The first time a parent is seen the
+    # counter is seeded past any pre-existing children so an import into an
+    # already-populated parent appends after them instead of colliding at 0.
+    # A nil parent means a root-level import (top-level page with no parent_id);
+    # closure_tree orders roots by `sequence` too, so seed from Creative.roots.
+    def self.create_child(user:, parent:, description:, seq:)
+      key = parent&.id
+      unless seq.key?(key)
+        siblings = parent ? parent.children : Creative.roots
+        max = siblings.maximum(:sequence)
+        seq[key] = max ? max + 1 : 0
+      end
+      creative = Creative.create(user: user, parent: parent, description: description, sequence: seq[key])
+      seq[key] += 1
+      creative
+    end
+
     def self.build_code_block_html(code_content, language = nil)
       escaped_content = ERB::Util.html_escape(code_content)
       lang_class = language.present? ? " class=\"language-#{ERB::Util.html_escape(language)}\"" : ""

data/app/services/collavre/mobile/event_summarizer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Collavre
+  module Mobile
+    # Turns an approval/permission comment or an agent reply into a SHORT,
+    # decision-oriented line of speech. Deterministic (no LLM) so the hot path
+    # stays fast: it extracts the tool name / human description from the
+    # permission action payload and renders a localized, spoken-friendly summary.
+    class EventSummarizer
+      def initialize(locale:)
+        @locale = (locale.presence || I18n.default_locale).to_s
+      end
+
+      def approval_summary(comment:, label:)
+        payload = parse_action(comment)
+        I18n.with_locale(@locale) do
+          detail =
+            payload&.dig("description").presence ||
+            payload&.dig("tool_name").presence ||
+            I18n.t("collavre.mobile.summary.a_tool")
+          I18n.t("collavre.mobile.summary.approval", label: label, detail: flatten(detail))
+        end
+      end
+
+      private
+
+      def flatten(text)
+        text.to_s.gsub(/\s+/, " ").strip
+      end
+
+      def parse_action(comment)
+        return nil unless comment.approval_action?
+
+        JSON.parse(comment.action)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

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

@@ -126,24 +126,10 @@ module Collavre
           "id" => @agent.id,
           "name" => @agent.name,
           "display_name" => @agent.display_name,
-          "type" => extract_agent_type
+          "type" => AgentTypeClassifier.classify(@agent)
         }
       end
 
-      def extract_agent_type
-        # Extract agent type from system_prompt or default
-        prompt = @agent.system_prompt.to_s.downcase
-        case prompt
-        when /developer|개발/ then "developer"
-        when /pm|project.?manager|프로젝트/ then "pm"
-        when /qa|test|quality|테스트|품질/ then "qa"
-        when /research|조사|연구/ then "researcher"
-        when /market|마케팅/ then "marketer"
-        when /plan|기획/ then "planner"
-        else "agent"
-        end
-      end
-
       def build_collaborators
         return [] unless @creative
 

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

@@ -45,7 +45,12 @@ module Collavre
 
         Comment.where(creative_id: creative_id, topic_id: topic_id, user_id: nil)
                .where("content LIKE ?", "⏳%")
-               .destroy_all
+               .find_each do |notice|
+          # System promotion, not user abandonment: do not let the destroy
+          # callback cancel other still-queued waiters in this topic.
+          notice.suppress_waiter_cancellation = true
+          notice.destroy
+        end
       end
       private_class_method :cleanup_waiting_notices!
 
@@ -59,7 +64,7 @@ module Collavre
         return unless creative_id && context&.key?("topic")
 
         topic_id = context.dig("topic", "id")
-        scope = Comment.public_only
+        scope = Comment.public_only.without_approval_action
           .where(creative_id: creative_id, topic_id: topic_id)
           .where.not(user_id: [ task.agent_id, nil ])
           .order(created_at: :desc)
@@ -184,17 +189,38 @@ module Collavre
         creative = Creative.find_by(id: creative_id)
         return unless creative
 
-        reason_key = decision[:reason] || :unknown
-        reason_text = I18n.t(
-          "collavre.orchestration.waiting_reasons.#{reason_key}",
-          default: reason_key.to_s.humanize
-        )
+        reason_text = waiting_reason_text(decision[:reason] || :unknown, topic_id, creative_id)
 
         creative.comments.create!(
           content: I18n.t("collavre.orchestration.waiting_notice", reason: reason_text),
           topic_id: topic_id,
           private: false,
-          skip_default_user: true
+          skip_default_user: true,
+          # Only :deferred queues a topic waiter; mark it so its stop button can
+          # target the blocker. :delayed (busy / rate_limited) notices stay false.
+          topic_concurrency_defer: decision[:timing] == :deferred
+        )
+      end
+
+      # Human-readable reason for the "⏳" waiting notice. For topic-concurrency
+      # deferrals, name the agent(s) actually holding the topic's running slot so
+      # a waiting user can see *who* is blocking them (and reach that task's stop
+      # button) rather than an anonymous "another task is running" dead end.
+      def waiting_reason_text(reason_key, topic_id, creative_id)
+        if reason_key == :topic_concurrency && topic_id
+          names = Task.running_for_topic(topic_id, creative_id)
+                      .includes(:agent).filter_map { |t| t.agent&.name }.uniq
+          if names.any?
+            return I18n.t(
+              "collavre.orchestration.waiting_reasons.topic_concurrency_with_agent",
+              agent: names.join(", ")
+            )
+          end
+        end
+
+        I18n.t(
+          "collavre.orchestration.waiting_reasons.#{reason_key}",
+          default: reason_key.to_s.humanize
         )
       end
     end

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

@@ -25,6 +25,13 @@ module Collavre
       def select(candidates)
         return [] if candidates.empty?
 
+        # Review feedback is forced routing: the Matcher already restricts candidates
+        # to the quoted comment's author, the sole agent ReviewHandler will accept.
+        # Floor-control arbitration (bid scoring, round_robin) among a forced single
+        # recipient is meaningless, and a low bid score must not drop it (e.g. bid
+        # strategy with bid_fallback_enabled: false) or the Review button no-ops.
+        return candidates if review_message?
+
         strategy = @policy_resolver.arbitration_strategy
         selected = apply_strategy(strategy, candidates)
 
@@ -37,6 +44,15 @@ module Collavre
 
       private
 
+      # True when the triggering comment is review feedback (mirrors Matcher's
+      # review-author routing), so arbitration can be bypassed for forced routing.
+      def review_message?
+        comment_id = @context.dig("comment", "id") || @context.dig(:comment, :id)
+        return false unless comment_id
+
+        Comment.find_by(id: comment_id)&.review_message? || false
+      end
+
       def apply_strategy(strategy, candidates)
         case strategy
         when "all"

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

@@ -21,6 +21,10 @@ module Collavre
 
       # Returns Array of User (AI agents) that are qualified to respond
       def match
+        # Priority 0: Review routing (exclusive)
+        review_result = match_by_review_author
+        return review_result unless review_result.nil?
+
         # Priority 1: Mention-based routing (exclusive)
         mentioned_result = match_by_mention
         return mentioned_result unless mentioned_result.nil?
@@ -31,6 +35,39 @@ module Collavre
 
       private
 
+      # Returns [author] for a routable review message, [] for an unroutable one,
+      # nil when this is not a review message.
+      #
+      # A review message can ONLY be handled by the author of the quoted comment:
+      # ReviewHandler#eligible? requires quoted_comment.user_id == agent.id, so any
+      # other agent would post a stray reply instead of the in-place review update.
+      # Route exclusively to that author — independent of mention or
+      # routing_expression — so the Review button is reliable even when the author
+      # has none (e.g. /compress summaries authored by a primary agent resolved via
+      # primary_agent_id). Without this the button renders but the feedback no-ops.
+      #
+      # Once this IS a review message, the only safe outcomes are exclusive-route or
+      # block ([]) — never nil. ResponseFinalizer keys on review_message? regardless
+      # of which agent the matcher picks, so a fall-through to mention/expression
+      # routing would schedule an agent that ReviewHandler#handle then bails on,
+      # producing the very stray reply this routing exists to prevent.
+      def match_by_review_author
+        return nil unless matched_comment&.review_message?
+
+        author = matched_comment.quoted_comment&.user
+        return [] unless author&.ai_user?
+
+        # Mirror ReviewHandler#eligible?: if the handler would reject this quote
+        # (private, or from another topic/creative), no agent can handle the review.
+        # Block rather than fall through, so it can't become a stray normal reply.
+        return [] unless Collavre::AiAgent::ReviewHandler.eligible?(matched_comment, author)
+
+        return [] unless has_creative_permission?(author)
+        return [] unless eligible_in_inbox?(author)
+
+        [ author ]
+      end
+
       # Returns Array of agents if mention found, nil if no mention
       # When mention IS found, this is exclusive routing
       def match_by_mention
@@ -47,6 +84,11 @@ module Collavre
         # Permission check for mentioned AI agent
         return [] unless has_creative_permission?(mentioned_user)
 
+        # Inbox confinement applies to mentions too: a live Claude Channel
+        # session agent must not be pulled into an ordinary inbox topic, even by
+        # an explicit @mention (see #eligible_in_inbox?).
+        return [] unless eligible_in_inbox?(mentioned_user)
+
         [ mentioned_user ]
       end
 
@@ -57,11 +99,26 @@ module Collavre
 
         agents.select do |agent|
           next false unless has_creative_permission?(agent)
+          next false unless eligible_in_inbox?(agent)
 
           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
+      # 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.
+      def eligible_in_inbox?(agent)
+        return true unless matched_creative&.inbox?
+        return true unless agent.claude_channel_agent?
+
+        matched_topic&.session_id.present? && matched_topic.primary_agent_id == agent.id
+      end
+
       def evaluate_routing_expression(agent)
         expression = agent.routing_expression.strip
 
@@ -85,14 +142,32 @@ module Collavre
       def has_creative_permission?(agent)
         # All agents need feedback permission on the creative to respond
         # searchable only affects discoverability, not response permission
-        creative_id = @context.dig("creative", "id") || @context.dig(:creative, :id)
-        return false unless creative_id
-
-        creative = Creative.find_by(id: creative_id)
+        creative = matched_creative
         return false unless creative
 
         creative.has_permission?(agent, :feedback)
       end
+
+      def matched_creative
+        return @matched_creative if defined?(@matched_creative)
+
+        creative_id = @context.dig("creative", "id") || @context.dig(:creative, :id)
+        @matched_creative = creative_id && Creative.find_by(id: creative_id)
+      end
+
+      def matched_topic
+        return @matched_topic if defined?(@matched_topic)
+
+        topic_id = @context.dig("topic", "id") || @context.dig(:topic, :id)
+        @matched_topic = topic_id && Topic.find_by(id: topic_id)
+      end
+
+      def matched_comment
+        return @matched_comment if defined?(@matched_comment)
+
+        comment_id = @context.dig("comment", "id") || @context.dig(:comment, :id)
+        @matched_comment = comment_id && Comment.find_by(id: comment_id)
+      end
     end
   end
 end

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

@@ -39,9 +39,10 @@ module Collavre
         },
         "stuck_detection" => {
           "enabled" => false,
-          "task_stuck_threshold_minutes" => 30,       # Task running for > N minutes
-          "creative_stall_threshold_minutes" => 120,  # Creative no progress for > N minutes
-          "create_system_comment" => true             # Create system comment on escalation
+          "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
         },
         "collaboration" => {
           "a2a_focus_instruction" => nil,         # nil = locale default

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

@@ -32,6 +32,7 @@ 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)
@@ -47,54 +48,124 @@ 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
 
       private
 
-      # Auto-recover stuck tasks by marking them as failed and draining the queue.
+      # Auto-recover stuck items: fail-and-drain for live tasks, self-heal for
+      # orphaned queued waiters.
       def auto_recover_stuck_tasks(stuck_items)
         stuck_items.each do |stuck_item|
-          next unless stuck_item.type == :task
+          case stuck_item.type
+          when :task          then recover_stuck_task(stuck_item)
+          when :queued_orphan then recover_orphaned_queued_task(stuck_item)
+          end
+        end
+      end
 
-          task = stuck_item.item
-          next unless %w[running delegated].include?(task.status)
+      # Self-heal an orphaned queued waiter: its blocker is gone but it was never
+      # drained (missed dequeue / enqueue-vs-terminate TOCTOU race / lost
+      # cross-process broadcast). Re-check liveness atomically, then drain.
+      def recover_orphaned_queued_task(stuck_item)
+        task = stuck_item.item.reload
+        return unless task.status == "queued"
+
+        # If the topic is back at capacity since detection, the normal terminal
+        # callback will drain the queue when a slot frees — leave it alone. This
+        # check also bounds promotions across one detection cycle: dequeue moves
+        # a waiter queued -> pending synchronously, which occupying_topic_slot
+        # counts, so consecutive orphans each fill exactly one free slot until the
+        # topic is full. With topic_max_concurrent_jobs > 1 and several free slots
+        # all are filled this cycle; a per-topic dedupe would instead leave every
+        # waiter past the first orphaned until the next run.
+        return if topic_at_capacity?(task)
+
+        Rails.logger.info(
+          "[StuckDetector] Self-healing orphaned queued task #{task.id} " \
+          "(topic=#{task.topic_id}, creative=#{task.creative_id}): no live blocker, draining queue"
+        )
+        AgentOrchestrator.dequeue_next_for_topic(task.topic_id, task.creative_id)
+      rescue StandardError => e
+        Rails.logger.error("[StuckDetector] Self-heal failed for queued task #{stuck_item.item.id}: #{e.message}")
+      end
 
-          task.update!(status: "failed")
-          Rails.logger.info(
-            "[StuckDetector] Auto-recovered task #{task.id} (agent=#{task.agent_id}): " \
-            "marked as failed after #{((Time.current - stuck_item.stuck_since) / 60).round} minutes"
-          )
+      # Whether a topic holds no free concurrency slot for a queued waiter.
+      # Compares occupied slots against topic_max (the scheduler's admission rule)
+      # rather than treating any single live blocker as full capacity — otherwise,
+      # with topic_max_concurrent_jobs > 1, a missed dequeue would leave the waiter
+      # suppressed until the *last* blocker terminates instead of the moment a slot
+      # frees up. Occupancy counts pending as well as running/delegated: a waiter
+      # that a prior dequeue already claimed sits in "pending" until its AiAgentJob
+      # starts, and the detector fires precisely on the backed-up condition where
+      # that window is wide — counting only running/delegated would see a free slot
+      # and promote a second waiter into a slot that is already claimed (double
+      # dequeue). This is intentionally stricter than the scheduler's reactive
+      # check; being stricter can only suppress recovery, never over-admit. When no
+      # topic limit is configured the scheduler never defers, so fall back to the
+      # conservative "any occupied slot" check.
+      def topic_at_capacity?(task)
+        topic_max = scheduling_resolver_for(task).topic_max_concurrent_jobs
+        occupied_count = Task.occupying_topic_slot(task.topic_id, task.creative_id).count
+        return occupied_count.positive? unless topic_max
+
+        occupied_count >= topic_max
+      end
 
-          # Release resources held by the stuck task
-          if task.agent
-            tracker = ResourceTracker.for(task.agent)
-            tracker.release!(task.id)
-          end
+      # Resolve scheduling policy against the queued task's own topic/creative
+      # context — the same context the scheduler used to admit it. The detector's
+      # default resolver is built with an empty context (it only needs the global
+      # stuck_detection policy), so reading topic_max_concurrent_jobs off it would
+      # see only the global default and ignore any topic-/creative-scoped override.
+      # That mismatch would violate a topic's serialization when its scoped limit
+      # is below the global value, or wrongly suppress recovery when it is above.
+      def scheduling_resolver_for(task)
+        context = {}
+        context["creative"] = { "id" => task.creative_id } if task.creative_id
+        context["topic"] = { "id" => task.topic_id } if task.topic_id
+        PolicyResolver.new(context)
+      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
+      # Fail a stuck running/delegated task and drain the topic queue.
+      def recover_stuck_task(stuck_item)
+        task = stuck_item.item
+        return unless %w[running delegated].include?(task.status)
+
+        task.update!(status: "failed")
+        Rails.logger.info(
+          "[StuckDetector] Auto-recovered task #{task.id} (agent=#{task.agent_id}): " \
+          "marked as failed after #{((Time.current - stuck_item.stuck_since) / 60).round} minutes"
+        )
 
-          # 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
-          Rails.logger.error("[StuckDetector] Auto-recovery failed for task #{task.id}: #{e.message}")
+        # Release resources held by the stuck task
+        if task.agent
+          tracker = ResourceTracker.for(task.agent)
+          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
+        Rails.logger.error("[StuckDetector] Auto-recovery failed for task #{stuck_item.item.id}: #{e.message}")
       end
 
       def stuck_detection_config
@@ -129,6 +200,38 @@ module Collavre
         end
       end
 
+      # Detect orphaned queued waiters: tasks left in "queued" for a topic that
+      # holds no occupied slot (no running/delegated blocker and no pending claim).
+      # A queued task's only path to
+      # execution is dequeue_next_for_topic, which fires when the blocker reaches
+      # a terminal status. If that single hand-off is missed — an
+      # enqueue-vs-terminate TOCTOU race, or a lost cross-process broadcast — the
+      # blocker is already gone and nothing will ever wake the waiter: it shows
+      # "⏳" waiting notice forever. These are invisible to detect_stuck_tasks, which only
+      # scans running/delegated. There is no stop button to press here because the
+      # blocker no longer exists; the fix is to drain the queue (see
+      # recover_orphaned_queued_task), not to escalate.
+      def detect_orphaned_queued_tasks(config)
+        threshold_minutes = config["queued_orphan_threshold_minutes"] || 5
+        threshold_time = threshold_minutes.minutes.ago
+
+        Task.where(status: "queued")
+            .where("updated_at < ?", threshold_time)
+            .filter_map do |task|
+          # Only orphaned if the topic has a free slot. A waiter is legitimately
+          # queued while the topic is at capacity.
+          next if topic_at_capacity?(task)
+
+          StuckItem.new(
+            type: :queued_orphan,
+            item: task,
+            reason: :orphaned_waiter,
+            stuck_since: task.updated_at,
+            escalation_targets: []
+          )
+        end
+      end
+
       # Detect creatives that have stalled (no activity for extended period)
       def detect_stalled_creatives(config)
         threshold_minutes = config["creative_stall_threshold_minutes"] || 120
@@ -216,6 +319,10 @@ module Collavre
         escalated_count = 0
 
         stuck_items.each do |stuck_item|
+          # Orphaned queued waiters are silently self-healed (queue drained),
+          # not escalated to admins — there is no human action to take.
+          next if stuck_item.type == :queued_orphan
+
           escalated = escalate_item(stuck_item, config)
           if escalated
             mark_escalated(stuck_item)

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

@@ -34,23 +34,10 @@ module Collavre
           "name" => user.name,
           "display_name" => user.respond_to?(:display_name) ? user.display_name : user.name,
           "is_ai" => user.ai_user?,
-          "type" => user.ai_user? ? extract_agent_type(user) : "human"
+          "type" => user.ai_user? ? AgentTypeClassifier.classify(user) : "human"
         }
       end
 
-      def extract_agent_type(user)
-        prompt = user.system_prompt.to_s.downcase
-        case prompt
-        when /developer|개발/ then "developer"
-        when /pm|project.?manager|프로젝트/ then "pm"
-        when /qa|test|quality|테스트|품질/ then "qa"
-        when /research|조사|연구/ then "researcher"
-        when /market|마케팅/ then "marketer"
-        when /plan|기획/ then "planner"
-        else "agent"
-        end
-      end
-
       def mentioned_user(chat_context)
         content = chat_context["content"]
         return nil unless content

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

@@ -18,9 +18,10 @@ module Collavre
       end
 
       tool_param :operations, description: "Array of operation objects. Each object must have an 'action' key.\n\n" \
-                 "For 'create': { action: 'create', parent_id: <int>, description: <string>, progress: <float>, after_id: <int>, before_id: <int> }\n" \
-                 "For 'update': { action: 'update', id: <int>, description: <string>, progress: 1.0, parent_id: <int> } — progress only accepts 1.0 (complete) and only on leaf Creatives\n" \
+                 "For 'create': { action: 'create', parent_id: <int>, description: <markdown string>, progress: <float>, after_id: <int>, before_id: <int> }\n" \
+                 "For 'update': { action: 'update', id: <int>, description: <markdown string>, progress: 1.0, parent_id: <int> } — progress only accepts 1.0 (complete) and only on leaf Creatives\n" \
                  "For 'delete': { action: 'delete', id: <int> }\n\n" \
+                 "The 'description' field is written as Markdown (GitHub-Flavored).\n" \
                  "Fields other than 'action' and 'id'/'parent_id' are optional.", required: true
 
       class BatchRollbackError < StandardError